/*
* Copyright (c) 2015, 2016, 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.
*/
/*
* @test
* @bug 8140364
* @author danielfuchs
* @summary JDK implementation specific unit test for JDK internal artifacts.
* Tests the consistency of the LoggerFinder and JDK extensions.
* @modules java.base/sun.util.logging
* java.base/jdk.internal.logger
* java.logging
* @run main LoggerFinderAPITest
*/
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.function.Supplier;
import java.util.logging.ConsoleHandler;
import java.util.logging.Handler;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import sun.util.logging.PlatformLogger;
public class LoggerFinderAPITest {
static final Class<java.lang.System.Logger> spiLoggerClass
= java.lang.System.Logger.class;
static final Class<java.lang.System.Logger> jdkLoggerClass
= java.lang.System.Logger.class;
static final Class<sun.util.logging.PlatformLogger.Bridge> bridgeLoggerClass
= sun.util.logging.PlatformLogger.Bridge.class;
static final Class<java.util.logging.Logger> julLoggerClass
= java.util.logging.Logger.class;
static final Class<sun.util.logging.PlatformLogger.Bridge> julLogProducerClass
= PlatformLogger.Bridge.class;
static final Pattern julLogNames = Pattern.compile(
"^((log(p|rb)?)|severe|warning|info|config|fine|finer|finest|isLoggable)$");
static final Collection<Method> julLoggerIgnores;
static {
List<Method> ignores = new ArrayList<>();
try {
ignores.add(julLoggerClass.getDeclaredMethod("log", LogRecord.class));
} catch (NoSuchMethodException | SecurityException ex) {
throw new ExceptionInInitializerError(ex);
}
julLoggerIgnores = Collections.unmodifiableList(ignores);
}
// Don't require LoggerBridge to have a body for those methods
interface LoggerBridgeMethodsWithNoBody extends
PlatformLogger.Bridge, java.lang.System.Logger {
@Override
public default String getName() {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public default boolean isLoggable(PlatformLogger.Level level) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public default void log(sun.util.logging.PlatformLogger.Level level,
String msg, Throwable thrown) {
}
@Override
public default void log(sun.util.logging.PlatformLogger.Level level,
Throwable thrown, Supplier<String> msgSupplier) {
}
@Override
public default void log(sun.util.logging.PlatformLogger.Level level,
Supplier<String> msgSupplier) {
}
@Override
public default void log(sun.util.logging.PlatformLogger.Level level, String msg) {
}
@Override
public default void log(sun.util.logging.PlatformLogger.Level level,
String format, Object... params) {
}
@Override
public default void logrb(sun.util.logging.PlatformLogger.Level level,
ResourceBundle bundle, String key, Throwable thrown) {
}
@Override
public default void logrb(sun.util.logging.PlatformLogger.Level level,
ResourceBundle bundle, String format, Object... params) {
}
@Override
public default void logrb(PlatformLogger.Level level,
String sourceClass, String sourceMethod,
ResourceBundle bundle, String msg, Throwable thrown) {
}
@Override
public default void logrb(PlatformLogger.Level level, String sourceClass,
String sourceMethod, ResourceBundle bundle, String msg,
Object... params) {
}
@Override
public default void logp(PlatformLogger.Level level, String sourceClass,
String sourceMethod, Supplier<String> msgSupplier) {
}
@Override
public default void logp(PlatformLogger.Level level, String sourceClass,
String sourceMethod, String msg, Object... params) {
}
@Override
public default void logp(PlatformLogger.Level level, String sourceClass,
String sourceMethod, String msg, Throwable thrown) {
}
@Override
public default void logp(PlatformLogger.Level level, String sourceClass,
String sourceMethod, String msg) {
}
@Override
public default void logp(PlatformLogger.Level level, String sourceClass,
String sourceMethod, Throwable thrown,
Supplier<String> msgSupplier) {
}
static boolean requiresDefaultBodyFor(Method m) {
try {
Method m2 = LoggerBridgeMethodsWithNoBody.class
.getDeclaredMethod(m.getName(),
m.getParameterTypes());
return !m2.isDefault();
} catch (NoSuchMethodException x) {
return true;
}
}
}
final boolean warnDuplicateMappings;
public LoggerFinderAPITest(boolean verbose) {
this.warnDuplicateMappings = verbose;
for (Handler h : Logger.getLogger("").getHandlers()) {
if (h instanceof ConsoleHandler) {
Logger.getLogger("").removeHandler(h);
}
}
Logger.getLogger("").addHandler( new Handler() {
@Override
public void publish(LogRecord record) {
StringBuilder builder = new StringBuilder();
builder.append("GOT LogRecord: ")
.append(record.getLevel().getLocalizedName())
.append(": [").append(record.getLoggerName())
.append("] ").append(record.getSourceClassName())
.append('.')
.append(record.getSourceMethodName()).append(" -> ")
.append(record.getMessage())
.append(' ')
.append(record.getParameters() == null ? ""
: Arrays.toString(record.getParameters()))
;
System.out.println(builder);
if (record.getThrown() != null) {
record.getThrown().printStackTrace(System.out);
}
}
@Override public void flush() {}
@Override public void close() {}
});
}
public Stream<Method> getJulLogMethodStream(Class<?> loggerClass) {
return Stream.of(loggerClass.getMethods()).filter((x) -> {
final Matcher m = julLogNames.matcher(x.getName());
return m.matches() ? x.getAnnotation(Deprecated.class) == null : false;
});
}
/**
* Tells whether a method invocation of 'origin' can be transformed in a
* method invocation of 'target'.
* This method only look at the parameter signatures, it doesn't look at
* the name, nor does it look at the return types.
* <p>
* Example:
* <ul>
* <li>java.util.logging.Logger.log(Level, String, Object) can be invoked as<br>
java.util.logging.spi.Logger.log(Level, String, Object...) because the
last parameter in 'target' is a varargs.</li>
* <li>java.util.logging.Logger.log(Level, String) can also be invoked as<br>
java.util.logging.spi.Logger.log(Level, String, Object...) for the
same reason.</li>
* </ul>
* <p>
* The algorithm is tailored for our needs: when the last parameter in the
* target is a vararg, and when origin & target have the same number of
* parameters, then we consider that the types of the last parameter *must*
* match.
* <p>
* Similarly - we do not consider that o(X x, Y y, Y y) matches t(X x, Y... y)
* although strictly speaking, it should...
*
* @param origin The method in the original class
* @param target The correspondent candidate in the target class
* @return true if a method invocation of 'origin' can be transformed in a
* method invocation of 'target'.
*/
public boolean canBeInvokedAs(Method origin, Method target,
Map<Class<?>,Class<?>> substitutes) {
final Class<?>[] xParams = target.getParameterTypes();
final Class<?>[] mParams = Stream.of(origin.getParameterTypes())
.map((x) -> substitutes.getOrDefault(x, x))
.collect(Collectors.toList()).toArray(new Class<?>[0]);
if (Arrays.deepEquals(xParams, mParams)) return true;
if (target.isVarArgs()) {
if (xParams.length == mParams.length) {
if (xParams[xParams.length-1].isArray()) {
return mParams[mParams.length -1].equals(
xParams[xParams.length -1].getComponentType());
}
} else if (xParams.length == mParams.length + 1) {
return Arrays.deepEquals(
Arrays.copyOfRange(xParams, 0, xParams.length-1), mParams);
}
}
return false;
}
/**
* Look whether {@code otherClass} has a public method similar to m
* @param m
* @param otherClass
* @return
*/
public Stream<Method> findInvokable(Method m, Class<?> otherClass) {
final Map<Class<?>,Class<?>> substitues =
Collections.singletonMap(java.util.logging.Level.class,
sun.util.logging.PlatformLogger.Level.class);
return Stream.of(otherClass.getMethods())
.filter((x) -> m.getName().equals(x.getName()))
.filter((x) -> canBeInvokedAs(m, x, substitues));
}
/**
* Test that the concrete Logger implementation passed as parameter
* overrides all the methods defined by its interface.
* @param julLogger A concrete implementation of System.Logger
* whose backend is a JUL Logger.
*/
StringBuilder testDefaultJULLogger(java.lang.System.Logger julLogger) {
final StringBuilder errors = new StringBuilder();
if (!bridgeLoggerClass.isInstance(julLogger)) {
final String errorMsg =
"Logger returned by LoggerFactory.getLogger(\"foo\") is not a "
+ bridgeLoggerClass + "\n\t" + julLogger;
System.err.println(errorMsg);
errors.append(errorMsg).append('\n');
}
final Class<? extends java.lang.System.Logger> xClass = julLogger.getClass();
List<Method> notOverridden =
Stream.of(bridgeLoggerClass.getDeclaredMethods()).filter((m) -> {
try {
Method x = xClass.getDeclaredMethod(m.getName(), m.getParameterTypes());
return x == null;
} catch (NoSuchMethodException ex) {
return !Modifier.isStatic(m.getModifiers());
}
}).collect(Collectors.toList());
notOverridden.stream().filter((x) -> {
boolean shouldOverride = true;
try {
final Method m = xClass.getMethod(x.getName(), x.getParameterTypes());
Method m2 = null;
try {
m2 = jdkLoggerClass.getDeclaredMethod(x.getName(), x.getParameterTypes());
} catch (Exception e) {
}
shouldOverride = m.isDefault() || m2 == null;
} catch (Exception e) {
// should override.
}
return shouldOverride;
}).forEach(x -> {
final String errorMsg = xClass.getName() + " should override\n\t" + x.toString();
System.err.println(errorMsg);
errors.append(errorMsg).append('\n');
});
if (notOverridden.isEmpty()) {
System.out.println(xClass + " overrides all methods from " + bridgeLoggerClass);
}
return errors;
}
public static class ResourceBundeParam extends ResourceBundle {
Map<String, String> map = Collections.synchronizedMap(new LinkedHashMap<>());
@Override
protected Object handleGetObject(String key) {
map.putIfAbsent(key, "${"+key+"}");
return map.get(key);
}
@Override
public Enumeration<String> getKeys() {
return Collections.enumeration(new LinkedHashSet<>(map.keySet()));
}
}
final ResourceBundle bundleParam =
ResourceBundle.getBundle(ResourceBundeParam.class.getName());
public static class ResourceBundeLocalized extends ResourceBundle {
Map<String, String> map = Collections.synchronizedMap(new LinkedHashMap<>());
@Override
protected Object handleGetObject(String key) {
map.putIfAbsent(key, "Localized:${"+key+"}");
return map.get(key);
}
@Override
public Enumeration<String> getKeys() {
return Collections.enumeration(new LinkedHashSet<>(map.keySet()));
}
}
final static ResourceBundle bundleLocalized =
ResourceBundle.getBundle(ResourceBundeLocalized.class.getName());
final Map<Class<?>, Object> params = new HashMap<>();
{
params.put(String.class, "TestString");
params.put(sun.util.logging.PlatformLogger.Level.class, sun.util.logging.PlatformLogger.Level.WARNING);
params.put(java.lang.System.Logger.Level.class, java.lang.System.Logger.Level.WARNING);
params.put(ResourceBundle.class, bundleParam);
params.put(Throwable.class, new Throwable("TestThrowable (Please ignore it!)"));
params.put(Object[].class, new Object[] {"One", "Two"});
params.put(Object.class, new Object() {
@Override public String toString() { return "I am an object!"; }
});
}
public Object[] getParamsFor(Method m) {
final Object[] res = new Object[m.getParameterCount()];
final Class<?>[] sig = m.getParameterTypes();
if (res.length == 0) {
return res;
}
for (int i=0; i<res.length; i++) {
Object p = params.get(sig[i]);
if (p == null && sig[i].equals(Supplier.class)) {
final String msg = "SuppliedMsg["+i+"]";
p = (Supplier<String>) () -> msg;
}
if (p instanceof String) {
res[i] = String.valueOf(p)+"["+i+"]";
} else {
res[i] = p;
}
}
return res;
}
public void invokeOn(java.lang.System.Logger logger, Method m) {
Object[] p = getParamsFor(m);
try {
m.invoke(logger, p);
} catch (Exception e) {
throw new RuntimeException("Failed to invoke "+m.toString(), e);
}
}
public void testAllJdkExtensionMethods(java.lang.System.Logger logger) {
Stream.of(jdkLoggerClass.getDeclaredMethods())
.filter(m -> !Modifier.isStatic(m.getModifiers()))
.forEach((m) -> invokeOn(logger, m));
}
public void testAllAPIMethods(java.lang.System.Logger logger) {
Stream.of(spiLoggerClass.getDeclaredMethods())
.filter(m -> !Modifier.isStatic(m.getModifiers()))
.forEach((m) -> invokeOn(logger, m));
}
public void testAllBridgeMethods(java.lang.System.Logger logger) {
Stream.of(bridgeLoggerClass.getDeclaredMethods())
.filter(m -> !Modifier.isStatic(m.getModifiers()))
.forEach((m) -> invokeOn(logger, m));
}
public void testAllLogProducerMethods(java.lang.System.Logger logger) {
Stream.of(julLogProducerClass.getDeclaredMethods())
.filter(m -> !Modifier.isStatic(m.getModifiers()))
.forEach((m) -> invokeOn(logger, m));
}
public StringBuilder testGetLoggerOverriddenOnSpi() {
final StringBuilder errors = new StringBuilder();
Stream.of(jdkLoggerClass.getDeclaredMethods())
.filter(m -> Modifier.isStatic(m.getModifiers()))
.filter(m -> Modifier.isPublic(m.getModifiers()))
.filter(m -> !m.getName().equals("getLoggerFinder"))
.filter(m -> {
try {
final Method x = bridgeLoggerClass.getDeclaredMethod(m.getName(), m.getParameterTypes());
return x == null;
} catch (NoSuchMethodException ex) {
return true;
}
}).forEach(m -> {
final String errorMsg = bridgeLoggerClass.getName() + " should override\n\t" + m.toString();
System.err.println(errorMsg);
errors.append(errorMsg).append('\n');
});
if (errors.length() == 0) {
System.out.println(bridgeLoggerClass + " overrides all static methods from " + jdkLoggerClass);
} else {
if (errors.length() > 0) throw new RuntimeException(errors.toString());
}
return errors;
}
public static void main(String argv[]) throws Exception {
final LoggerFinderAPITest test = new LoggerFinderAPITest(false);
final StringBuilder errors = new StringBuilder();
errors.append(test.testGetLoggerOverriddenOnSpi());
java.lang.System.Logger julLogger =
java.lang.System.LoggerFinder.getLoggerFinder()
.getLogger("foo", LoggerFinderAPITest.class.getModule());
errors.append(test.testDefaultJULLogger(julLogger));
if (errors.length() > 0) throw new RuntimeException(errors.toString());
java.lang.System.Logger julSystemLogger =
java.lang.System.LoggerFinder.getLoggerFinder()
.getLogger("bar", Thread.class.getModule());
errors.append(test.testDefaultJULLogger(julSystemLogger));
if (errors.length() > 0) throw new RuntimeException(errors.toString());
java.lang.System.Logger julLocalizedLogger =
(java.lang.System.Logger)
System.getLogger("baz", bundleLocalized);
java.lang.System.Logger julLocalizedSystemLogger =
java.lang.System.LoggerFinder.getLoggerFinder()
.getLocalizedLogger("oof", bundleLocalized, Thread.class.getModule());
final String error = errors.toString();
if (!error.isEmpty()) throw new RuntimeException(error);
for (java.lang.System.Logger logger : new java.lang.System.Logger[] {
julLogger, julSystemLogger, julLocalizedLogger, julLocalizedSystemLogger
}) {
test.testAllJdkExtensionMethods(logger);
test.testAllAPIMethods(logger);
test.testAllBridgeMethods(logger);
test.testAllLogProducerMethods(logger);
}
}
}