0d2a897c3e
SimpleConsoleLogger now emulates the behaviour of java.util.logging.Formatter, trapping MissingResourceException and using the key as the message if the ResourceBundle has no match for that key. Reviewed-by: naoto
283 lines
12 KiB
Java
283 lines
12 KiB
Java
/*
|
|
* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.OutputStream;
|
|
import java.io.PrintStream;
|
|
import java.lang.System.Logger;
|
|
import java.lang.System.Logger.Level;
|
|
import java.lang.System.LoggerFinder;
|
|
import java.util.Collections;
|
|
import java.util.Enumeration;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
import java.util.ResourceBundle;
|
|
// Can't use testng because testng requires java.logging
|
|
//import org.testng.annotations.Test;
|
|
|
|
/**
|
|
* @test
|
|
* @bug 8177835 8179222
|
|
* @summary Checks that the DefaultLoggerFinder and LoggingProviderImpl
|
|
* implementations of the System.LoggerFinder conform to the
|
|
* LoggerFinder specification, in particular with respect to
|
|
* throwing NullPointerException. The test uses --limit-module
|
|
* to force the selection of one or the other.
|
|
* @author danielfuchs
|
|
* @build LoggerFinderAPI
|
|
* @run main/othervm --limit-modules java.base,java.logging
|
|
* -Djava.util.logging.SimpleFormatter.format=LOG-%4$s:-[%2$s]-%5$s%6$s%n
|
|
* LoggerFinderAPI
|
|
* @run main/othervm -Djdk.system.logger.format=LOG-%4$s:-[%2$s]-%5$s%6$s%n
|
|
* --limit-modules java.base
|
|
* LoggerFinderAPI
|
|
*/
|
|
public class LoggerFinderAPI {
|
|
|
|
// Simplified log format string. No white space for main/othervm line
|
|
static final String TEST_FORMAT = "LOG-%4$s:-[%2$s]-%5$s%6$s%n";
|
|
static final String JDK_FORMAT_PROP_KEY = "jdk.system.logger.format";
|
|
static final String JUL_FORMAT_PROP_KEY =
|
|
"java.util.logging.SimpleFormatter.format";
|
|
static final String MESSAGE = "{0} with {1}: PASSED";
|
|
static final String LOCALIZED = "[localized] ";
|
|
|
|
static class RecordStream extends OutputStream {
|
|
static final Object LOCK = new Object[0];
|
|
final PrintStream out;
|
|
final PrintStream err;
|
|
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
|
boolean record;
|
|
RecordStream(PrintStream out, PrintStream err) {
|
|
this.out = out;
|
|
this.err = err;
|
|
}
|
|
|
|
@Override
|
|
public void write(int i) throws IOException {
|
|
if (record) {
|
|
bos.write(i);
|
|
out.write(i);
|
|
} else {
|
|
err.write(i);
|
|
}
|
|
}
|
|
|
|
void startRecording() {
|
|
out.flush();
|
|
err.flush();
|
|
bos.reset();
|
|
record = true;
|
|
}
|
|
byte[] stopRecording() {
|
|
out.flush();
|
|
err.flush();
|
|
record = false;
|
|
return bos.toByteArray();
|
|
}
|
|
}
|
|
|
|
static final PrintStream ERR = System.err;
|
|
static final PrintStream OUT = System.out;
|
|
static final RecordStream LOG_STREAM = new RecordStream(OUT, ERR);
|
|
static {
|
|
Locale.setDefault(Locale.US);
|
|
PrintStream perr = new PrintStream(LOG_STREAM);
|
|
System.setErr(perr);
|
|
}
|
|
|
|
public static class MyResourceBundle extends ResourceBundle {
|
|
final Map<String, String> map = Map.of(MESSAGE, LOCALIZED + MESSAGE);
|
|
@Override
|
|
protected Object handleGetObject(String string) {
|
|
return map.get(string);
|
|
}
|
|
|
|
@Override
|
|
public Enumeration<String> getKeys() {
|
|
return Collections.enumeration(map.keySet());
|
|
}
|
|
|
|
}
|
|
|
|
public static class EmptyResourceBundle extends ResourceBundle {
|
|
@Override
|
|
protected Object handleGetObject(String string) {
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public Enumeration<String> getKeys() {
|
|
return Collections.emptyEnumeration();
|
|
}
|
|
|
|
}
|
|
|
|
public static void main(String[] args) {
|
|
// Set on the command line, to ensure that the test will fail if
|
|
// the 'wrong' provider gets selected.
|
|
// System.setProperty(JDK_FORMAT_PROP_KEY, TEST_FORMAT);
|
|
// System.setProperty(JUL_FORMAT_PROP_KEY, TEST_FORMAT);
|
|
LoggerFinder finder = System.LoggerFinder.getLoggerFinder();
|
|
System.out.println("LoggerFinder is " + finder.getClass().getName());
|
|
|
|
LoggerFinderAPI apiTest = new LoggerFinderAPI();
|
|
for (Object[] params : getLoggerDataProvider()) {
|
|
@SuppressWarnings("unchecked")
|
|
Class<? extends Throwable> throwableClass =
|
|
Throwable.class.getClass().cast(params[3]);
|
|
apiTest.testGetLogger((String)params[0],
|
|
(String)params[1],
|
|
(Module)params[2],
|
|
throwableClass);
|
|
}
|
|
for (Object[] params : getLocalizedLoggerDataProvider()) {
|
|
@SuppressWarnings("unchecked")
|
|
Class<? extends Throwable> throwableClass =
|
|
Throwable.class.getClass().cast(params[4]);
|
|
apiTest.testGetLocalizedLogger((String)params[0],
|
|
(String)params[1],
|
|
(ResourceBundle)params[2],
|
|
(Module)params[3],
|
|
throwableClass);
|
|
}
|
|
}
|
|
|
|
//Can't use testng because testng requires java.logging
|
|
//@Test(dataProvider = "testGetLoggerDataProvider")
|
|
void testGetLogger(String desc, String name, Module mod, Class<? extends Throwable> thrown) {
|
|
try {
|
|
LoggerFinder finder = System.LoggerFinder.getLoggerFinder();
|
|
Logger logger = finder.getLogger(name, mod);
|
|
if (thrown != null) {
|
|
throw new AssertionError("Exception " + thrown.getName()
|
|
+ " not thrown for "
|
|
+ "LoggerFinder.getLogger"
|
|
+ " with " + desc);
|
|
}
|
|
// Make sure we don't fail if tests are run in parallel
|
|
synchronized(RecordStream.LOCK) {
|
|
LOG_STREAM.startRecording();
|
|
byte[] logged = null;
|
|
try {
|
|
logger.log(Level.INFO, "{0} with {1}: PASSED",
|
|
"LoggerFinder.getLogger",
|
|
desc);
|
|
} finally {
|
|
logged = LOG_STREAM.stopRecording();
|
|
}
|
|
check(logged, "testGetLogger", desc, null,
|
|
"LoggerFinder.getLogger");
|
|
}
|
|
} catch (Throwable x) {
|
|
if (thrown != null && thrown.isInstance(x)) {
|
|
System.out.printf("Got expected exception for %s with %s: %s\n",
|
|
"LoggerFinder.getLogger", desc, String.valueOf(x));
|
|
} else throw x;
|
|
}
|
|
}
|
|
|
|
//Can't use testng because testng requires java.logging
|
|
//@Test(dataProvider = "getLocalizedLoggerDataProvider")
|
|
void testGetLocalizedLogger(String desc, String name, ResourceBundle bundle,
|
|
Module mod, Class<? extends Throwable> thrown) {
|
|
try {
|
|
LoggerFinder finder = System.LoggerFinder.getLoggerFinder();
|
|
Logger logger = finder.getLocalizedLogger(name, bundle, mod);
|
|
if (thrown != null) {
|
|
throw new AssertionError("Exception " + thrown.getName()
|
|
+ " not thrown for "
|
|
+ "LoggerFinder.getLocalizedLogger"
|
|
+ " with " + desc);
|
|
}
|
|
// Make sure we don't fail if tests are run in parallel
|
|
synchronized(RecordStream.LOCK) {
|
|
LOG_STREAM.startRecording();
|
|
byte[] logged = null;
|
|
try {
|
|
logger.log(Level.INFO, MESSAGE,
|
|
"LoggerFinder.getLocalizedLogger",
|
|
desc);
|
|
} finally {
|
|
logged = LOG_STREAM.stopRecording();
|
|
}
|
|
check(logged, "testGetLocalizedLogger", desc, bundle,
|
|
"LoggerFinder.getLocalizedLogger");
|
|
}
|
|
} catch (Throwable x) {
|
|
if (thrown != null && thrown.isInstance(x)) {
|
|
System.out.printf("Got expected exception for %s with %s: %s\n",
|
|
"LoggerFinder.getLocalizedLogger", desc, String.valueOf(x));
|
|
} else throw x;
|
|
}
|
|
}
|
|
|
|
private void check(byte[] logged, String test, String desc,
|
|
ResourceBundle bundle, String meth) {
|
|
String msg = new String(logged);
|
|
String localizedPrefix =
|
|
((bundle==null || bundle==EMPTY_BUNDLE)?"":LOCALIZED);
|
|
String expected = String.format(TEST_FORMAT, null,
|
|
"LoggerFinderAPI " + test, null, Level.INFO.name(),
|
|
localizedPrefix + meth + " with " + desc + ": PASSED",
|
|
"");
|
|
if (!Objects.equals(msg, expected)) {
|
|
throw new AssertionError("Expected log message not found: "
|
|
+ "\n\texpected: " + expected
|
|
+ "\n\tretrieved: " + msg);
|
|
}
|
|
}
|
|
|
|
|
|
static final Module MODULE = LoggerFinderAPI.class.getModule();
|
|
static final ResourceBundle BUNDLE = new MyResourceBundle();
|
|
static final ResourceBundle EMPTY_BUNDLE = new EmptyResourceBundle();
|
|
static final Object[][] GET_LOGGER = {
|
|
{"null name", null, MODULE , NullPointerException.class},
|
|
{"null module", "foo", null, NullPointerException.class},
|
|
{"null name and module", null, null, NullPointerException.class},
|
|
{"non null name and module", "foo", MODULE, null},
|
|
};
|
|
static final Object[][] GET_LOCALIZED_LOGGER = {
|
|
{"null name", null, BUNDLE, MODULE , NullPointerException.class},
|
|
{"null module", "foo", BUNDLE, null, NullPointerException.class},
|
|
{"null name and module, non null bundle", null, BUNDLE, null, NullPointerException.class},
|
|
{"non null name, module, and bundle", "foo", BUNDLE, MODULE, null},
|
|
{"null name and bundle", null, null, MODULE , NullPointerException.class},
|
|
{"null module and bundle", "foo", null, null, NullPointerException.class},
|
|
{"null name and module and bundle", null, null, null, NullPointerException.class},
|
|
{"non null name and module, null bundle", "foo", null, MODULE, null},
|
|
// tests that MissingResourceBundle is not propagated to the caller of
|
|
// logger.log() if the key is not found in the resource bundle
|
|
{"non null name, module, and empty bundle", "foo", EMPTY_BUNDLE, MODULE, null},
|
|
};
|
|
public static Object[][] getLoggerDataProvider() {
|
|
return GET_LOGGER;
|
|
}
|
|
public static Object[][] getLocalizedLoggerDataProvider() {
|
|
return GET_LOCALIZED_LOGGER;
|
|
}
|
|
}
|