| /* |
| * Copyright (c) 2015, 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. |
| * This test tests all the public API methods defined in the {@link |
| * java.lang.System.Logger} interface, as well as all the JDK |
| * internal methods defined in the |
| * {@link sun.util.logging.PlatformLogger.Bridge} |
| * interface, with loggers returned by {@link |
| * java.lang.System.LoggerFinder#getLogger(java.lang.String, java.lang.Class)} |
| * and {@link java.lang.System.LoggerFinder#getLocalizedLogger(java.lang.String, |
| * java.util.ResourceBundle, java.lang.Class)} |
| * (using both a null resource bundle and a non null resource bundle). |
| * It calls both the {@link java.lang.System} factory methods and |
| * {@link jdk.internal.logger.LazyLoggers} to obtains those loggers, |
| * and configure them with all possible known levels. |
| * @modules java.base/java.lang:open |
| * java.base/sun.util.logging |
| * java.base/jdk.internal.logger |
| * java.logging/sun.util.logging.internal |
| * @build LoggerFinderBackendTest SystemClassLoader |
| * @run main/othervm -Djava.system.class.loader=SystemClassLoader -Dtest.logger.hidesProvider=true LoggerFinderBackendTest |
| * @run main/othervm -Djava.system.class.loader=SystemClassLoader -Dtest.logger.hidesProvider=false LoggerFinderBackendTest |
| */ |
| |
| |
| import java.lang.invoke.MethodHandle; |
| import java.lang.invoke.MethodHandles; |
| import java.lang.invoke.MethodHandles.Lookup; |
| import java.lang.invoke.MethodType; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| 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.Objects; |
| import java.util.ResourceBundle; |
| import java.util.concurrent.atomic.AtomicInteger; |
| import java.util.function.BiFunction; |
| import java.util.function.BooleanSupplier; |
| import java.util.function.Function; |
| import java.util.function.Supplier; |
| import java.lang.System.LoggerFinder; |
| import java.util.logging.ConsoleHandler; |
| import java.util.logging.Handler; |
| import sun.util.logging.PlatformLogger.Level; |
| import java.util.logging.LogManager; |
| import java.util.logging.LogRecord; |
| import java.util.logging.Logger; |
| import sun.util.logging.internal.LoggingProviderImpl; |
| |
| /** |
| * @author danielfuchs |
| */ |
| public class LoggerFinderBackendTest { |
| |
| // whether the implementation of Logger try to do a best |
| // effort for logp... If the provider is not hidden, then |
| // the logp() implementation comes from LoggerWrapper - which does a |
| // best effort. Otherwise, it comes from the default provider |
| // which does support logp. |
| static final boolean BEST_EFFORT_FOR_LOGP = |
| !Boolean.getBoolean("test.logger.hidesProvider"); |
| static final boolean VERBOSE = false; |
| |
| 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; |
| |
| /** Use to retrieve the log records that were produced by the JUL backend */ |
| static class LoggerTesterHandler extends Handler { |
| public final List<LogRecord> records = |
| Collections.synchronizedList(new ArrayList<>()); |
| |
| @Override |
| public void publish(LogRecord record) { |
| record.getSourceClassName(); record.getSourceMethodName(); |
| records.add(record); |
| } |
| |
| @Override |
| public void flush() { |
| } |
| |
| @Override |
| public void close() throws SecurityException { |
| records.clear(); |
| } |
| |
| public void reset() { |
| records.clear(); |
| } |
| } |
| |
| /** The {@link LoggerTesterHandler} handler is added to the root logger. */ |
| static final LoggerTesterHandler handler = new LoggerTesterHandler(); |
| static { |
| for (Handler h : Logger.getLogger("").getHandlers()) { |
| if (h instanceof ConsoleHandler) { |
| Logger.getLogger("").removeHandler(h); |
| } |
| } |
| Logger.getLogger("").addHandler(handler); |
| } |
| |
| /** |
| * A resource handler parameter that will be used when calling out the |
| * logrb-like methods - as well as when calling the level-specific |
| * methods that take a ResourceBundle parameter. |
| */ |
| 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 static ResourceBundle bundleParam = |
| ResourceBundle.getBundle(ResourceBundeParam.class.getName()); |
| |
| /** |
| * A resource handler parameter that will be used when creating localized |
| * loggers by calling {@link |
| * LoggerFinder#getLocalizedLogger(java.lang.String, java.util.ResourceBundle, java.lang.Class)}. |
| */ |
| 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())); |
| } |
| |
| } |
| |
| /** |
| * The Levels enum is used to call all the level-specific methods on |
| * a logger instance. To minimize the amount of code it uses reflection |
| * to do so. |
| */ |
| static Lookup lookup = MethodHandles.lookup(); |
| public enum Levels { |
| /** Used to call all forms of Logger.log?(SEVERE, ...) */ |
| SEVERE("severe", bridgeLoggerClass, Level.SEVERE, null, "error", false), |
| /** Used to call all forms of Logger.log?(WARNING,...) */ |
| WARNING("warning", bridgeLoggerClass, Level.WARNING, "warning", "warning", false), |
| /** Used to call all forms of Logger.log?(INFO,...) */ |
| INFO("info", bridgeLoggerClass, Level.INFO, "info", "info", false), |
| /** Used to call all forms of Logger.log?(CONFIG,...) */ |
| CONFIG("config", bridgeLoggerClass, Level.CONFIG, null, "debug", false), |
| /** Used to call all forms of Logger.log?(FINE,...) */ |
| FINE("fine", bridgeLoggerClass, Level.FINE, null, "debug", false), |
| /** Used to call all forms of Logger.log?(FINER,...) */ |
| FINER("finer", bridgeLoggerClass, Level.FINER, null, "trace", false), |
| /** Used to call all forms of Logger.log?(FINEST,...) */ |
| FINEST("finest", bridgeLoggerClass, Level.FINEST, null, "trace", false), |
| ; |
| public final String method; // The name of the level-specific method to call |
| public final Class<?> definingClass; // which interface j.u.logger.Logger or j.u.logging.spi.Logger defines it |
| public final Level platformLevel; // The platform Level it will be mapped to in Jul when Jul is the backend |
| public final String jdkExtensionToJUL; // The name of the method called on the JUL logger when JUL is the backend |
| public final String julToJdkExtension; // The name of the method called in the jdk extension by the default impl in jdk.internal.logging.Logger |
| public final String enableMethod; // The name of the isXxxxEnabled method |
| public final boolean hasSpecificIsEnabled; |
| Levels(String method, Class<?> definingClass, Level defaultMapping, |
| String jdkExtensionToJUL, String julToJdkExtension, |
| boolean hasSpecificIsEnabled) { |
| this.method = method; |
| this.definingClass = definingClass; |
| this.platformLevel = defaultMapping; |
| this.jdkExtensionToJUL = jdkExtensionToJUL; |
| this.julToJdkExtension = julToJdkExtension; |
| this.hasSpecificIsEnabled = hasSpecificIsEnabled; |
| if (hasSpecificIsEnabled) { |
| this.enableMethod = "is" + method.substring(0,1).toUpperCase() |
| + method.substring(1) + "Enabled"; |
| } else { |
| this.enableMethod = "isLoggable"; |
| } |
| } |
| |
| /* |
| * calls this level specific method - e.g. if this==INFO: logger.info(msg); |
| */ |
| public void level(Object logger, String msg) { |
| MethodType mt = MethodType.methodType(void.class, Level.class, String.class); |
| invoke("log", logger, mt, platformLevel, msg); |
| } |
| |
| /* |
| * calls this level specific method - e.g. if this==INFO: logger.info(msgSupplier); |
| */ |
| public void level(Object logger, Supplier<String> msgSupplier) { |
| MethodType mt = MethodType.methodType(void.class, Level.class, Supplier.class); |
| invoke("log", logger, mt, platformLevel, msgSupplier); |
| } |
| |
| /* |
| * calls this level specific method - e.g. if this==INFO: logger.info(msg, params); |
| */ |
| public void level(Object logger, String msg, Object... params) { |
| MethodType mt = MethodType.methodType(void.class, Level.class, String.class, |
| Object[].class); |
| invoke("log", logger, mt, platformLevel, msg, params); |
| } |
| |
| /* |
| * calls this level specific method - e.g. if this==INFO: logger.info(msg, thrown); |
| */ |
| public void level(Object logger, String msg, Throwable thrown) { |
| MethodType mt = MethodType.methodType(void.class, Level.class, String.class, |
| Throwable.class); |
| invoke("log", logger, mt, platformLevel, msg, thrown); |
| } |
| |
| /* |
| * calls this level specific method - e.g. if this==INFO: logger.info(msgSupplier, thrown); |
| */ |
| public void level(Object logger, Supplier<String> msgSupplier, Throwable thrown) { |
| MethodType mt = MethodType.methodType(void.class, Level.class, |
| Throwable.class, Supplier.class); |
| invoke("log", logger, mt, platformLevel, thrown, msgSupplier); |
| } |
| |
| /* |
| * calls this level specific method - e.g. if this==INFO: logger.info(bundle, msg); |
| */ |
| public void level(Object logger, String msg, ResourceBundle bundle) { |
| MethodType mt = MethodType.methodType(void.class, Level.class, |
| ResourceBundle.class, String.class, Object[].class); |
| invoke("logrb", logger, mt, platformLevel, bundle, msg, null); |
| } |
| |
| public void level(Object logger, String msg, ResourceBundle bundle, |
| Object... params) { |
| MethodType mt = MethodType.methodType(void.class, Level.class, |
| ResourceBundle.class, String.class, Object[].class); |
| invoke("logrb", logger, mt, platformLevel, bundle, msg, params); |
| } |
| |
| public void level(Object logger, String msg, ResourceBundle bundle, |
| Throwable thrown) { |
| MethodType mt = MethodType.methodType(void.class, Level.class, |
| ResourceBundle.class, String.class, Throwable.class); |
| invoke("logrb", logger, mt, platformLevel, bundle, msg, thrown); |
| } |
| |
| public boolean isEnabled(Object logger) { |
| try { |
| if (hasSpecificIsEnabled) { |
| MethodType mt = MethodType.methodType(boolean.class); |
| final MethodHandle handle = lookup.findVirtual(definingClass, |
| enableMethod, mt).bindTo(logger); |
| return Boolean.class.cast(handle.invoke()); |
| } else { |
| MethodType mt = MethodType.methodType(boolean.class, |
| Level.class); |
| final MethodHandle handle = lookup.findVirtual(definingClass, |
| enableMethod, mt).bindTo(logger); |
| return Boolean.class.cast(handle.invoke(platformLevel)); |
| } |
| } catch (Throwable ex) { |
| throw new RuntimeException(ex); |
| } |
| } |
| |
| private void invoke(String method, Object logger, MethodType mt, Object... args) { |
| try { |
| final int last = mt.parameterCount()-1; |
| boolean isVarargs = mt.parameterType(last).isArray(); |
| final MethodHandle handle = lookup.findVirtual(definingClass, |
| method, mt).bindTo(logger); |
| |
| final StringBuilder builder = new StringBuilder(); |
| builder.append(logger.getClass().getSimpleName()).append('.') |
| .append(method).append('('); |
| String sep = ""; |
| int offset = 0; |
| Object[] params = args; |
| for (int i=0; (i-offset) < params.length; i++) { |
| if (isVarargs && i == last) { |
| offset = last; |
| params = (Object[])args[i]; |
| if (params == null) break; |
| } |
| Object p = params[i - offset]; |
| String quote = (p instanceof String) ? "\"" : ""; |
| builder.append(sep).append(quote).append(p).append(quote); |
| sep = ", "; |
| } |
| builder.append(')'); |
| if (verbose) { |
| System.out.println(builder); |
| } |
| handle.invokeWithArguments(args); |
| } catch (Throwable ex) { |
| throw new RuntimeException(ex); |
| } |
| } |
| |
| }; |
| |
| static interface Checker<LogResult, L> extends BiFunction<LogResult, L, Void> {} |
| static interface JdkLogTester |
| extends BiFunction<sun.util.logging.PlatformLogger.Bridge, Level, Void> {} |
| static interface SpiLogTester |
| extends BiFunction<java.lang.System.Logger, java.lang.System.Logger.Level, Void> {} |
| |
| static interface MethodInvoker<LOGGER, LEVEL> { |
| public void logX(LOGGER logger, LEVEL level, Object... args); |
| } |
| |
| public enum JdkLogMethodInvoker |
| implements MethodInvoker<sun.util.logging.PlatformLogger.Bridge, Level> { |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#log(Level, String, Object...)}; |
| **/ |
| LOG_STRING_PARAMS("log", MethodType.methodType(void.class, |
| Level.class, String.class, Object[].class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#log(Level, String, Throwable)}; |
| **/ |
| LOG_STRING_THROWN("log", MethodType.methodType(void.class, |
| Level.class, String.class, Throwable.class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#log(Level, Supplier<String>)}; |
| **/ |
| LOG_SUPPLIER("log", MethodType.methodType(void.class, |
| Level.class, Supplier.class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#log(Level, Throwable, Supplier<String>)}; |
| **/ |
| LOG_SUPPLIER_THROWN("log", MethodType.methodType(void.class, |
| Level.class, Throwable.class, Supplier.class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#logp(Level, String, String, String)}; |
| **/ |
| LOGP_STRING("logp", MethodType.methodType(void.class, |
| Level.class, String.class, String.class, String.class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#logp(Level, String, String, String, Object...)}; |
| **/ |
| LOGP_STRING_PARAMS("logp", MethodType.methodType(void.class, |
| Level.class, String.class, String.class, String.class, Object[].class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#logp(Level, String, String, String, Throwable)}; |
| **/ |
| LOGP_STRING_THROWN("logp", MethodType.methodType(void.class, |
| Level.class, String.class, String.class, String.class, Throwable.class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#logp(Level, String, String, Supplier<String>)}; |
| **/ |
| LOGP_SUPPLIER("logp", MethodType.methodType(void.class, |
| Level.class, String.class, String.class, Supplier.class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#logp(Level, String, String, Throwable, Supplier<String>)}; |
| **/ |
| LOGP_SUPPLIER_THROWN("logp", MethodType.methodType(void.class, |
| Level.class, String.class, String.class, |
| Throwable.class, Supplier.class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#logrb(Level, ResourceBundle, String, Object...)}; |
| **/ |
| LOGRB_STRING_PARAMS("logrb", MethodType.methodType(void.class, |
| Level.class, ResourceBundle.class, String.class, Object[].class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#logrb(Level, ResourceBundle, String, Throwable)}; |
| **/ |
| LOGRB_STRING_THROWN("logrb", MethodType.methodType(void.class, |
| Level.class, ResourceBundle.class, String.class, Throwable.class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#logrb(Level, String, String, ResourceBundle, String, Object...)}; |
| **/ |
| LOGRBP_STRING_PARAMS("logrb", MethodType.methodType(void.class, |
| Level.class, String.class, String.class, ResourceBundle.class, |
| String.class, Object[].class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#logrb(Level, String, String, ResourceBundle, String, Throwable)}; |
| **/ |
| LOGRBP_STRING_THROWN("logrb", MethodType.methodType(void.class, |
| Level.class, String.class, String.class, ResourceBundle.class, |
| String.class, Throwable.class)), |
| ; |
| final MethodType mt; |
| final String method; |
| JdkLogMethodInvoker(String method, MethodType mt) { |
| this.mt = mt; |
| this.method = method; |
| } |
| Object[] makeArgs(Level level, Object... rest) { |
| List<Object> list = new ArrayList<>(rest == null ? 1 : rest.length + 1); |
| list.add(level); |
| if (rest != null) { |
| list.addAll(Arrays.asList(rest)); |
| } |
| return list.toArray(new Object[list.size()]); |
| } |
| |
| @Override |
| public void logX(sun.util.logging.PlatformLogger.Bridge logger, Level level, Object... args) { |
| try { |
| MethodHandle handle = lookup.findVirtual(bridgeLoggerClass, |
| method, mt).bindTo(logger); |
| final int last = mt.parameterCount()-1; |
| boolean isVarargs = mt.parameterType(last).isArray(); |
| |
| args = makeArgs(level, args); |
| |
| final StringBuilder builder = new StringBuilder(); |
| builder.append(logger.getClass().getSimpleName()).append('.') |
| .append(this.method).append('('); |
| String sep = ""; |
| int offset = 0; |
| Object[] params = args; |
| for (int i=0; (i-offset) < params.length; i++) { |
| if (isVarargs && i == last) { |
| offset = last; |
| params = (Object[])args[i]; |
| if (params == null) break; |
| } |
| Object p = params[i - offset]; |
| String quote = (p instanceof String) ? "\"" : ""; |
| p = p instanceof Level ? "Level."+p : p; |
| builder.append(sep).append(quote).append(p).append(quote); |
| sep = ", "; |
| } |
| builder.append(')'); |
| if (verbose) System.out.println(builder); |
| handle.invokeWithArguments(args); |
| } catch (Throwable ex) { |
| throw new RuntimeException(ex); |
| } |
| } |
| } |
| |
| |
| public enum SpiLogMethodInvoker implements MethodInvoker<java.lang.System.Logger, |
| java.lang.System.Logger.Level> { |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#log(Level, String, Object...)}; |
| **/ |
| LOG_STRING_PARAMS("log", MethodType.methodType(void.class, |
| java.lang.System.Logger.Level.class, String.class, Object[].class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#log(Level, String, Throwable)}; |
| **/ |
| LOG_STRING_THROWN("log", MethodType.methodType(void.class, |
| java.lang.System.Logger.Level.class, String.class, Throwable.class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#log(Level, Supplier<String>)}; |
| **/ |
| LOG_SUPPLIER("log", MethodType.methodType(void.class, |
| java.lang.System.Logger.Level.class, Supplier.class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#log(Level, Throwable, Supplier<String>)}; |
| **/ |
| LOG_SUPPLIER_THROWN("log", MethodType.methodType(void.class, |
| java.lang.System.Logger.Level.class, Supplier.class, Throwable.class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#log(Level, Supplier<String>)}; |
| **/ |
| LOG_OBJECT("log", MethodType.methodType(void.class, |
| java.lang.System.Logger.Level.class, Object.class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#logrb(Level, ResourceBundle, String, Object...)}; |
| **/ |
| LOGRB_STRING_PARAMS("log", MethodType.methodType(void.class, |
| java.lang.System.Logger.Level.class, ResourceBundle.class, |
| String.class, Object[].class)), |
| /** |
| * Tests {@link |
| * jdk.internal.logging.Logger#logrb(Level, ResourceBundle, String, Throwable)}; |
| **/ |
| LOGRB_STRING_THROWN("log", MethodType.methodType(void.class, |
| java.lang.System.Logger.Level.class, ResourceBundle.class, |
| String.class, Throwable.class)), |
| ; |
| final MethodType mt; |
| final String method; |
| SpiLogMethodInvoker(String method, MethodType mt) { |
| this.mt = mt; |
| this.method = method; |
| } |
| Object[] makeArgs(java.lang.System.Logger.Level level, Object... rest) { |
| List<Object> list = new ArrayList<>(rest == null ? 1 : rest.length + 1); |
| list.add(level); |
| if (rest != null) { |
| list.addAll(Arrays.asList(rest)); |
| } |
| return list.toArray(new Object[list.size()]); |
| } |
| |
| @Override |
| public void logX(java.lang.System.Logger logger, |
| java.lang.System.Logger.Level level, Object... args) { |
| try { |
| MethodHandle handle = lookup.findVirtual(spiLoggerClass, |
| method, mt).bindTo(logger); |
| final int last = mt.parameterCount()-1; |
| boolean isVarargs = mt.parameterType(last).isArray(); |
| |
| args = makeArgs(level, args); |
| |
| final StringBuilder builder = new StringBuilder(); |
| builder.append(logger.getClass().getSimpleName()).append('.') |
| .append(this.method).append('('); |
| String sep = ""; |
| int offset = 0; |
| Object[] params = args; |
| for (int i=0; (i-offset) < params.length; i++) { |
| if (isVarargs && i == last) { |
| offset = last; |
| params = (Object[])args[i]; |
| if (params == null) break; |
| } |
| Object p = params[i - offset]; |
| String quote = (p instanceof String) ? "\"" : ""; |
| p = p instanceof Level ? "Level."+p : p; |
| builder.append(sep).append(quote).append(p).append(quote); |
| sep = ", "; |
| } |
| builder.append(')'); |
| if (verbose) System.out.println(builder); |
| handle.invokeWithArguments(args); |
| } catch (Throwable ex) { |
| throw new RuntimeException(ex); |
| } |
| } |
| } |
| |
| |
| public abstract static class BackendTester<BackendRecord> { |
| static final Level[] levelMap = {Level.ALL, Level.FINER, Level.FINE, |
| Level.INFO, Level.WARNING, Level.SEVERE, Level.OFF}; |
| |
| abstract class BackendAdaptor { |
| public abstract String getLoggerName(BackendRecord res); |
| public abstract Object getLevel(BackendRecord res); |
| public abstract String getMessage(BackendRecord res); |
| public abstract String getSourceClassName(BackendRecord res); |
| public abstract String getSourceMethodName(BackendRecord res); |
| public abstract Throwable getThrown(BackendRecord res); |
| public abstract ResourceBundle getResourceBundle(BackendRecord res); |
| public abstract void setLevel(java.lang.System.Logger logger, |
| Level level); |
| public abstract void setLevel(java.lang.System.Logger logger, |
| java.lang.System.Logger.Level level); |
| public abstract List<BackendRecord> getBackendRecords(); |
| public abstract void resetBackendRecords(); |
| public boolean shouldBeLoggable(Levels level, Level loggerLevel) { |
| final Level logLevel = level.platformLevel; |
| return shouldBeLoggable(logLevel, loggerLevel); |
| } |
| public boolean shouldBeLoggable(Level logLevel, Level loggerLevel) { |
| return loggerLevel.intValue() != Level.OFF.intValue() |
| && logLevel.intValue() >= loggerLevel.intValue(); |
| } |
| public boolean shouldBeLoggable(java.lang.System.Logger.Level logLevel, |
| java.lang.System.Logger.Level loggerLevel) { |
| return loggerLevel != java.lang.System.Logger.Level.OFF |
| && logLevel.ordinal() >= loggerLevel.ordinal(); |
| } |
| public boolean isLoggable(java.lang.System.Logger logger, Level l) { |
| return bridgeLoggerClass.cast(logger).isLoggable(l); |
| } |
| public String getCallerClassName(Levels level, String clazz) { |
| return clazz != null ? clazz : Levels.class.getName(); |
| } |
| public String getCallerClassName(MethodInvoker<?,?> logMethod, |
| String clazz) { |
| return clazz != null ? clazz : logMethod.getClass().getName(); |
| } |
| public String getCallerMethodName(Levels level, String method) { |
| return method != null ? method : "invoke"; |
| } |
| public String getCallerMethodName(MethodInvoker<?,?> logMethod, |
| String method) { |
| return method != null ? method : "logX"; |
| } |
| public Object getMappedLevel(Object level) { |
| return level; |
| } |
| |
| public Level toJUL(java.lang.System.Logger.Level level) { |
| return levelMap[level.ordinal()]; |
| } |
| } |
| |
| public final boolean isSystem; |
| public final Class<? extends java.lang.System.Logger> restrictedTo; |
| public final ResourceBundle localized; |
| public BackendTester(boolean isSystem) { |
| this(isSystem,null,null); |
| } |
| public BackendTester(boolean isSystem, ResourceBundle localized) { |
| this(isSystem,null,localized); |
| } |
| public BackendTester(boolean isSystem, |
| Class<? extends java.lang.System.Logger> restrictedTo) { |
| this(isSystem, restrictedTo, null); |
| } |
| public BackendTester(boolean isSystem, |
| Class<? extends java.lang.System.Logger> restrictedTo, |
| ResourceBundle localized) { |
| this.isSystem = isSystem; |
| this.restrictedTo = restrictedTo; |
| this.localized = localized; |
| } |
| |
| public java.lang.System.Logger convert(java.lang.System.Logger logger) { |
| return logger; |
| } |
| |
| public static Level[] LEVELS = { |
| Level.OFF, |
| Level.SEVERE, Level.WARNING, Level.INFO, Level.CONFIG, |
| Level.FINE, Level.FINER, Level.FINEST, |
| Level.ALL |
| }; |
| |
| abstract BackendAdaptor adaptor(); |
| |
| protected void checkRecord(Levels test, BackendRecord res, String loggerName, |
| Level level, String msg, String className, String methodName, |
| Throwable thrown, ResourceBundle bundle, Object... params) { |
| checkRecord(test, res, loggerName, level, ()->msg, className, |
| methodName, thrown, bundle, params); |
| |
| } |
| protected void checkRecord(Levels test, BackendRecord res, String loggerName, |
| Level level, Supplier<String> msg, String className, String methodName, |
| Throwable thrown, ResourceBundle bundle, Object... params) { |
| checkRecord(test.method, res, loggerName, level, msg, |
| className, methodName, thrown, bundle, params); |
| } |
| protected <L> void checkRecord(String logMethod, BackendRecord res, String loggerName, |
| L level, Supplier<String> msg, String className, String methodName, |
| Throwable thrown, ResourceBundle bundle, Object... params) { |
| final BackendAdaptor analyzer = adaptor(); |
| if (! Objects.equals(analyzer.getLoggerName(res), loggerName)) { |
| throw new RuntimeException(logMethod+": expected logger name " |
| + loggerName + " got " + analyzer.getLoggerName(res)); |
| } |
| if (!Objects.equals(analyzer.getLevel(res), analyzer.getMappedLevel(level))) { |
| throw new RuntimeException(logMethod+": expected level " |
| + analyzer.getMappedLevel(level) + " got " + analyzer.getLevel(res)); |
| } |
| if (!Objects.equals(analyzer.getMessage(res), msg.get())) { |
| throw new RuntimeException(logMethod+": expected message \"" |
| + msg.get() + "\" got \"" + analyzer.getMessage(res) +"\""); |
| } |
| if (!Objects.equals(analyzer.getSourceClassName(res), className)) { |
| throw new RuntimeException(logMethod |
| + ": expected class name \"" + className |
| + "\" got \"" + analyzer.getSourceClassName(res) +"\""); |
| } |
| if (!Objects.equals(analyzer.getSourceMethodName(res), methodName)) { |
| throw new RuntimeException(logMethod |
| + ": expected method name \"" + methodName |
| + "\" got \"" + analyzer.getSourceMethodName(res) +"\""); |
| } |
| final Throwable thrownRes = analyzer.getThrown(res); |
| if (!Objects.equals(thrownRes, thrown)) { |
| throw new RuntimeException(logMethod |
| + ": expected throwable \"" + thrown |
| + "\" got \"" + thrownRes + "\""); |
| } |
| if (!Objects.equals(analyzer.getResourceBundle(res), bundle)) { |
| throw new RuntimeException(logMethod |
| + ": expected bundle \"" + bundle |
| + "\" got \"" + analyzer.getResourceBundle(res) +"\""); |
| } |
| } |
| |
| public void testLevel(Levels level, java.lang.System.Logger logger, |
| String msg) { |
| Runnable test = () -> level.level(logger, msg); |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord(level, res, logger.getName(), l, msg, |
| adaptor().getCallerClassName(level, Levels.class.getName()), |
| adaptor().getCallerMethodName(level, "invoke"), |
| null, localized); |
| return null; |
| }; |
| test("msg", level, logger, test, check); |
| } |
| |
| public void testLevel(Levels level, java.lang.System.Logger logger, |
| String msg, Object... params) { |
| Runnable test = () -> level.level(logger, msg, (Object[])params); |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord(level, res, logger.getName(), l, msg, |
| adaptor().getCallerClassName(level, Levels.class.getName()), |
| adaptor().getCallerMethodName(level, "invoke"), |
| null, localized, (Object[])params); |
| return null; |
| }; |
| test("msg, params", level, logger, test, check); |
| } |
| |
| public void testLevel(Levels level, java.lang.System.Logger logger, |
| String msg, Throwable thrown) { |
| Runnable test = () -> level.level(logger, msg, thrown); |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord(level, res, logger.getName(), l, msg, |
| adaptor().getCallerClassName(level, Levels.class.getName()), |
| adaptor().getCallerMethodName(level, "invoke"), |
| thrown, localized); |
| return null; |
| }; |
| test("msg, thrown", level, logger, test, check); |
| } |
| |
| public void testLevel(Levels level, java.lang.System.Logger logger, |
| Supplier<String> msg) { |
| Runnable test = () -> level.level(logger, msg); |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord(level, res, logger.getName(), l, msg, |
| adaptor().getCallerClassName(level, Levels.class.getName()), |
| adaptor().getCallerMethodName(level, "invoke"), |
| null, null); |
| return null; |
| }; |
| test("msgSupplier", level, logger, test, check); |
| } |
| |
| public void testLevel(Levels level, java.lang.System.Logger logger, |
| Supplier<String> msg, Throwable thrown) { |
| Runnable test = () -> level.level(logger, msg, thrown); |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord(level, res, logger.getName(), l, msg, |
| adaptor().getCallerClassName(level, Levels.class.getName()), |
| adaptor().getCallerMethodName(level, "invoke"), |
| thrown, null); |
| return null; |
| }; |
| test("throw, msgSupplier", level, logger, test, check); |
| } |
| |
| public void testLevel(Levels level, java.lang.System.Logger logger, |
| String msg, ResourceBundle bundle) { |
| Runnable test = () -> level.level(logger, msg, bundle); |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord(level, res, logger.getName(), l, msg, |
| adaptor().getCallerClassName(level, Levels.class.getName()), |
| adaptor().getCallerMethodName(level, "invoke"), |
| null, bundle); |
| return null; |
| }; |
| test("bundle, msg", level, logger, test, check); |
| } |
| |
| public void testLevel(Levels level, java.lang.System.Logger logger, |
| String msg, ResourceBundle bundle, Object... params) { |
| Runnable test = () -> level.level(logger, msg, bundle, (Object[])params); |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord(level, res, logger.getName(), l, msg, |
| adaptor().getCallerClassName(level, Levels.class.getName()), |
| adaptor().getCallerMethodName(level, "invoke"), |
| null, bundle, (Object[])params); |
| return null; |
| }; |
| test("bundle, msg, params", level, logger, test, check); |
| } |
| |
| public void testLevel(Levels level, java.lang.System.Logger logger, |
| String msg, ResourceBundle bundle, Throwable thrown) { |
| Runnable test = () -> level.level(logger, msg, bundle, thrown); |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord(level, res, logger.getName(), l, msg, |
| adaptor().getCallerClassName(level, Levels.class.getName()), |
| adaptor().getCallerMethodName(level, "invoke"), |
| thrown, bundle); |
| return null; |
| }; |
| test("bundle, msg, throwable", level, logger, test, check); |
| } |
| |
| // System.Logger |
| public void testSpiLog(java.lang.System.Logger logger, String msg) { |
| Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| SpiLogMethodInvoker.LOG_STRING_PARAMS, |
| SpiLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| SpiLogMethodInvoker.LOG_STRING_PARAMS, |
| "logX"), null, localized); |
| return null; |
| }; |
| SpiLogTester tester = (x, level) -> { |
| SpiLogMethodInvoker.LOG_STRING_PARAMS.logX(x, level, msg, (Object[])null); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> "log(Level." + l + ", \"" + msg + "\")"; |
| testSpiLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testSpiLog(java.lang.System.Logger logger, |
| ResourceBundle bundle, String msg) { |
| Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| SpiLogMethodInvoker.LOGRB_STRING_PARAMS, |
| SpiLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| SpiLogMethodInvoker.LOGRB_STRING_PARAMS, |
| "logX"), null, bundle); |
| return null; |
| }; |
| SpiLogTester tester = (x, level) -> { |
| SpiLogMethodInvoker.LOGRB_STRING_PARAMS.logX(x, level, bundle, msg, (Object[])null); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> "log(Level." + l |
| + ", bundle, \"" + msg + "\")"; |
| testSpiLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testSpiLog(java.lang.System.Logger logger, String msg, Object... params) { |
| Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| SpiLogMethodInvoker.LOG_STRING_PARAMS, |
| SpiLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| SpiLogMethodInvoker.LOG_STRING_PARAMS, |
| "logX"), null, localized, params); |
| return null; |
| }; |
| SpiLogTester tester = (x, level) -> { |
| SpiLogMethodInvoker.LOG_STRING_PARAMS.logX(x, level, msg, params); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> "log(Level." + l + ", \"" + msg + "\", params...)"; |
| testSpiLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testSpiLog(java.lang.System.Logger logger, |
| ResourceBundle bundle, String msg, Object... params) { |
| Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| SpiLogMethodInvoker.LOGRB_STRING_PARAMS, |
| SpiLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| SpiLogMethodInvoker.LOGRB_STRING_PARAMS, |
| "logX"), null, bundle, params); |
| return null; |
| }; |
| SpiLogTester tester = (x, level) -> { |
| SpiLogMethodInvoker.LOGRB_STRING_PARAMS.logX(x, level, bundle, msg, params); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> "log(Level." + l |
| + ", bundle, \"" + msg + "\", params...)"; |
| testSpiLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testSpiLog(java.lang.System.Logger logger, String msg, Throwable thrown) { |
| Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| SpiLogMethodInvoker.LOG_STRING_THROWN, |
| SpiLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| SpiLogMethodInvoker.LOG_STRING_THROWN, |
| "logX"), thrown, localized); |
| return null; |
| }; |
| SpiLogTester tester = (x, level) -> { |
| SpiLogMethodInvoker.LOG_STRING_THROWN.logX(x, level, msg, thrown); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", \"" + msg + "\", thrown)"; |
| testSpiLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testSpiLog(java.lang.System.Logger logger, |
| ResourceBundle bundle, String msg, Throwable thrown) { |
| Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| SpiLogMethodInvoker.LOGRB_STRING_THROWN, |
| SpiLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| SpiLogMethodInvoker.LOGRB_STRING_THROWN, |
| "logX"), thrown, bundle); |
| return null; |
| }; |
| SpiLogTester tester = (x, level) -> { |
| SpiLogMethodInvoker.LOGRB_STRING_THROWN.logX(x, level, bundle, msg, thrown); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", bundle, \"" + msg + "\", thrown)"; |
| testSpiLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testSpiLog(java.lang.System.Logger logger, Supplier<String> msg) { |
| Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, msg, |
| adaptor().getCallerClassName( |
| SpiLogMethodInvoker.LOG_SUPPLIER, |
| SpiLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| SpiLogMethodInvoker.LOG_SUPPLIER, |
| "logX"), null, null); |
| return null; |
| }; |
| SpiLogTester tester = (x, level) -> { |
| SpiLogMethodInvoker.LOG_SUPPLIER.logX(x, level, msg); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", () -> \"" + msg.get() + "\")"; |
| testSpiLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testSpiLog(java.lang.System.Logger logger, Object obj) { |
| Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, () -> obj.toString(), |
| adaptor().getCallerClassName( |
| SpiLogMethodInvoker.LOG_OBJECT, |
| SpiLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| SpiLogMethodInvoker.LOG_OBJECT, |
| "logX"), null, null); |
| return null; |
| }; |
| SpiLogTester tester = (x, level) -> { |
| SpiLogMethodInvoker.LOG_OBJECT.logX(x, level, obj); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", new "+obj.getClass().getSimpleName()+"(\"" |
| + obj.toString() + "\"))"; |
| testSpiLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testSpiLog(java.lang.System.Logger logger, Throwable thrown, Supplier<String> msg) { |
| Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, msg, |
| adaptor().getCallerClassName( |
| SpiLogMethodInvoker.LOG_SUPPLIER_THROWN, |
| SpiLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| SpiLogMethodInvoker.LOG_SUPPLIER_THROWN, |
| "logX"), thrown, null); |
| return null; |
| }; |
| SpiLogTester tester = (x, level) -> { |
| SpiLogMethodInvoker.LOG_SUPPLIER_THROWN.logX(x, level, msg, thrown); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", () -> \"" + msg.get() + "\", thrown)"; |
| testSpiLog(logger, tester, check, nameProducer); |
| } |
| |
| |
| // JDK |
| |
| public void testLog(java.lang.System.Logger logger, String msg) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOG_STRING_PARAMS, |
| JdkLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| JdkLogMethodInvoker.LOG_STRING_PARAMS, |
| "logX"), null, localized); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOG_STRING_PARAMS.logX(x, level, msg, (Object[])null); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> "log(Level." + l + ", \"" + msg + "\")"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testLogrb(java.lang.System.Logger logger, |
| ResourceBundle bundle, String msg) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGRB_STRING_PARAMS, |
| JdkLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| JdkLogMethodInvoker.LOGRB_STRING_PARAMS, |
| "logX"), null, bundle); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOGRB_STRING_PARAMS.logX(x, level, bundle, msg, (Object[])null); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> "logrb(Level." + l |
| + ", bundle, \"" + msg + "\")"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testLog(java.lang.System.Logger logger, String msg, Object... params) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOG_STRING_PARAMS, |
| JdkLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| JdkLogMethodInvoker.LOG_STRING_PARAMS, |
| "logX"), null, localized, params); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOG_STRING_PARAMS.logX(x, level, msg, params); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> "log(Level." + l + ", \"" + msg + "\", params...)"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testLogrb(java.lang.System.Logger logger, |
| ResourceBundle bundle, String msg, Object... params) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGRB_STRING_PARAMS, |
| JdkLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| JdkLogMethodInvoker.LOGRB_STRING_PARAMS, |
| "logX"), null, bundle, params); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOGRB_STRING_PARAMS.logX(x, level, bundle, msg, params); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> "log(Level." + l |
| + ", bundle, \"" + msg + "\", params...)"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testLog(java.lang.System.Logger logger, String msg, Throwable thrown) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOG_STRING_THROWN, |
| JdkLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| JdkLogMethodInvoker.LOG_STRING_THROWN, |
| "logX"), thrown, localized); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOG_STRING_THROWN.logX(x, level, msg, thrown); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", \"" + msg + "\", thrown)"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testLogrb(java.lang.System.Logger logger, |
| ResourceBundle bundle, String msg, Throwable thrown) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGRB_STRING_THROWN, |
| JdkLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| JdkLogMethodInvoker.LOGRB_STRING_THROWN, |
| "logX"), thrown, bundle); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOGRB_STRING_THROWN.logX(x, level, bundle, msg, thrown); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", bundle, \"" + msg + "\", thrown)"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testLog(java.lang.System.Logger logger, Supplier<String> msg) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, msg, |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOG_SUPPLIER, |
| JdkLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| JdkLogMethodInvoker.LOG_SUPPLIER, |
| "logX"), null, null); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOG_SUPPLIER.logX(x, level, msg); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", () -> \"" + msg.get() + "\")"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testLog(java.lang.System.Logger logger, Throwable thrown, Supplier<String> msg) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, msg, |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOG_SUPPLIER_THROWN, |
| JdkLogMethodInvoker.class.getName()), |
| adaptor().getCallerMethodName( |
| JdkLogMethodInvoker.LOG_SUPPLIER_THROWN, |
| "logX"), thrown, null); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOG_SUPPLIER_THROWN.logX(x, level, thrown, msg); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", () -> \"" + msg.get() + "\", thrown)"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| static Supplier<String> logpMessage(ResourceBundle bundle, |
| String className, String methodName, Supplier<String> msg) { |
| if (BEST_EFFORT_FOR_LOGP && bundle == null |
| && (className != null || methodName != null)) { |
| final String cName = className == null ? "" : className; |
| final String mName = methodName == null ? "" : methodName; |
| return () -> { |
| String m = msg.get(); |
| return String.format("[%s %s] %s", cName, mName, m == null ? "" : m); |
| }; |
| } else { |
| return msg; |
| } |
| } |
| |
| public void testLogp(java.lang.System.Logger logger, String className, |
| String methodName, String msg) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("logp", res, logger.getName(), l, |
| logpMessage(localized, className, methodName, () -> msg), |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGP_STRING, className), |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGP_STRING, methodName), |
| null, localized); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOGP_STRING.logX(x, level, |
| className, methodName, msg); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "logp(Level." + l + ", class, method, \"" + msg + "\")"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testLogrb(java.lang.System.Logger logger, String className, |
| String methodName, ResourceBundle bundle, String msg) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("logp", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGRBP_STRING_PARAMS, className), |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGRBP_STRING_PARAMS, methodName), |
| null, bundle); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOGRBP_STRING_PARAMS.logX(x, level, |
| className, methodName, bundle, msg, (Object[])null); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "logp(Level." + l + ", class, method, bundle, \"" + msg + "\")"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testLogp(java.lang.System.Logger logger, String className, |
| String methodName, String msg, Object... params) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("logp", res, logger.getName(), l, |
| logpMessage(localized, className, methodName, () -> msg), |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGP_STRING_PARAMS, className), |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGP_STRING_PARAMS, methodName), |
| null, localized, params); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOGP_STRING_PARAMS.logX(x, level, |
| className, methodName, msg, params); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", class, method, \"" + msg + "\", params...)"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testLogrb(java.lang.System.Logger logger, String className, |
| String methodName, ResourceBundle bundle, String msg, |
| Object... params) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("logp", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGRBP_STRING_PARAMS, className), |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGRBP_STRING_PARAMS, methodName), |
| null, bundle, params); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOGRBP_STRING_PARAMS.logX(x, level, |
| className, methodName, bundle, msg, params); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", class, method, bundle, \"" |
| + msg + "\", params...)"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testLogp(java.lang.System.Logger logger, String className, |
| String methodName, String msg, Throwable thrown) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, |
| logpMessage(localized, className, methodName, () -> msg), |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGP_STRING_THROWN, className), |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGP_STRING_THROWN, methodName), |
| thrown, localized); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOGP_STRING_THROWN.logX(x, level, |
| className, methodName, msg, thrown); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", class, method, \"" + msg + "\", thrown)"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testLogrb(java.lang.System.Logger logger, String className, |
| String methodName, ResourceBundle bundle, |
| String msg, Throwable thrown) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, () -> msg, |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGRBP_STRING_THROWN, className), |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGRBP_STRING_THROWN, methodName), |
| thrown, bundle); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOGRBP_STRING_THROWN.logX(x, level, |
| className, methodName, bundle, msg, thrown); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", class, method, bundle, \"" + msg + "\", thrown)"; |
| testJdkLog(logger, tester, check, nameProducer); |
| |
| } |
| |
| public void testLogp(java.lang.System.Logger logger, String className, |
| String methodName, Supplier<String> msg) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, |
| logpMessage(null, className, methodName, msg), |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGP_SUPPLIER, className), |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGP_SUPPLIER, methodName), |
| null, null); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOGP_SUPPLIER.logX(x, level, |
| className, methodName, msg); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", class, method, () -> \"" + msg.get() + "\")"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| public void testLogp(java.lang.System.Logger logger, String className, |
| String methodName, Throwable thrown, Supplier<String> msg) { |
| Checker<BackendRecord, Level> check = (res, l) -> { |
| checkRecord("log", res, logger.getName(), l, |
| logpMessage(null, className, methodName, msg), |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGP_SUPPLIER_THROWN, className), |
| adaptor().getCallerClassName( |
| JdkLogMethodInvoker.LOGP_SUPPLIER_THROWN, methodName), |
| thrown, null); |
| return null; |
| }; |
| JdkLogTester tester = (x, level) -> { |
| JdkLogMethodInvoker.LOGP_SUPPLIER_THROWN.logX(x, level, |
| className, methodName, thrown, msg); |
| return null; |
| }; |
| Function<String, String> nameProducer = (l) -> |
| "log(Level." + l + ", class, method, () -> \"" + msg.get() + "\", thrown)"; |
| testJdkLog(logger, tester, check, nameProducer); |
| } |
| |
| private void testJdkLog(java.lang.System.Logger logger, |
| JdkLogTester log, Checker<BackendRecord,Level> check, |
| Function<String, String> nameProducer) { |
| if (restrictedTo != null) { |
| if (!bridgeLoggerClass.isAssignableFrom(restrictedTo)) { |
| if (VERBOSE) { |
| System.out.println("Skipping method from " |
| + bridgeLoggerClass); |
| } |
| return; |
| } |
| } |
| System.out.println("Testing Logger." + nameProducer.apply("*") |
| + " on " + logger); |
| final BackendAdaptor adaptor = adaptor(); |
| for (Level loggerLevel : LEVELS) { |
| adaptor.setLevel(logger, loggerLevel); |
| for (Level l : LEVELS) { |
| check(logger, () -> log.apply(bridgeLoggerClass.cast(logger), l), |
| check, () -> adaptor.isLoggable(logger, l), |
| () -> adaptor.shouldBeLoggable(l, loggerLevel), |
| l, loggerLevel, nameProducer.apply(l.toString())); |
| } |
| } |
| } |
| |
| private void testSpiLog(java.lang.System.Logger logger, |
| SpiLogTester log, Checker<BackendRecord, java.lang.System.Logger.Level> check, |
| Function<String, String> nameProducer) { |
| System.out.println("Testing System.Logger." + nameProducer.apply("*") |
| + " on " + logger); |
| final BackendAdaptor adaptor = adaptor(); |
| for (java.lang.System.Logger.Level loggerLevel : java.lang.System.Logger.Level.values()) { |
| |
| adaptor.setLevel(logger, loggerLevel); |
| for (java.lang.System.Logger.Level l : java.lang.System.Logger.Level.values()) { |
| check(logger, () -> log.apply(logger, l), |
| check, () -> logger.isLoggable(l), |
| () -> adaptor.shouldBeLoggable(l, loggerLevel), |
| l, loggerLevel, nameProducer.apply(l.toString())); |
| } |
| } |
| } |
| |
| private void test(String args, Levels level, java.lang.System.Logger logger, |
| Runnable test, Checker<BackendRecord, Level> check) { |
| if (restrictedTo != null) { |
| if (!level.definingClass.isAssignableFrom(restrictedTo)) { |
| if (VERBOSE) { |
| System.out.println("Skipping method from " |
| + level.definingClass); |
| } |
| return; |
| } |
| } |
| String method = args.contains("bundle") ? "logrb" : "log"; |
| System.out.println("Testing Logger." |
| + method + "(Level." + level.platformLevel |
| + ", "+ args + ")" + " on " + logger); |
| final BackendAdaptor adaptor = adaptor(); |
| for (Level loggerLevel : LEVELS) { |
| adaptor.setLevel(logger, loggerLevel); |
| check(logger, test, check, |
| () -> level.isEnabled(logger), |
| () -> adaptor.shouldBeLoggable(level, loggerLevel), |
| level.platformLevel, loggerLevel, level.method); |
| } |
| } |
| |
| private <L> void check(java.lang.System.Logger logger, |
| Runnable test, Checker<BackendRecord,L> check, |
| BooleanSupplier checkLevelEnabled, |
| BooleanSupplier shouldBeLoggable, |
| L logLevel, L loggerLevel, String logMethod) { |
| final BackendAdaptor adaptor = adaptor(); |
| adaptor.resetBackendRecords(); |
| test.run(); |
| final List<BackendRecord> records = adaptor.getBackendRecords(); |
| if (shouldBeLoggable.getAsBoolean()) { |
| if (!checkLevelEnabled.getAsBoolean()) { |
| throw new RuntimeException("Logger is not enabled for " |
| + logMethod |
| + " although logger level is " + loggerLevel); |
| } |
| if (records.size() != 1) { |
| throw new RuntimeException(loggerLevel + " [" + |
| logLevel + "] : Unexpected record sizes: " |
| + records.toString()); |
| } |
| BackendRecord res = records.get(0); |
| check.apply(res, logLevel); |
| } else { |
| if (checkLevelEnabled.getAsBoolean()) { |
| throw new RuntimeException("Logger is enabled for " |
| + logMethod |
| + " although logger level is " + loggerLevel); |
| } |
| if (!records.isEmpty()) { |
| throw new RuntimeException(loggerLevel + " [" + |
| logLevel + "] : Unexpected record sizes: " |
| + records.toString()); |
| } |
| } |
| } |
| } |
| |
| public static class JULBackendTester extends BackendTester<LogRecord>{ |
| |
| public JULBackendTester(boolean isSystem) { |
| this(isSystem,null,null); |
| } |
| public JULBackendTester(boolean isSystem, ResourceBundle localized) { |
| this(isSystem,null,localized); |
| } |
| public JULBackendTester(boolean isSystem, |
| Class<? extends java.lang.System.Logger> restrictedTo) { |
| this(isSystem, restrictedTo, null); |
| } |
| public JULBackendTester(boolean isSystem, |
| Class<? extends java.lang.System.Logger> restrictedTo, |
| ResourceBundle localized) { |
| super(isSystem, restrictedTo, localized); |
| } |
| |
| Logger getBackendLogger(String name) { |
| if (isSystem) { |
| return LoggingProviderImpl.getLogManagerAccess().demandLoggerFor( |
| LogManager.getLogManager(), name, Thread.class.getModule()); |
| } else { |
| return Logger.getLogger(name); |
| } |
| } |
| |
| class JULBackendAdaptor extends BackendAdaptor { |
| @Override |
| public String getLoggerName(LogRecord res) { |
| return res.getLoggerName(); |
| } |
| @Override |
| public Level getLevel(LogRecord res) { |
| return Level.valueOf(res.getLevel().getName()); |
| } |
| @Override |
| public String getMessage(LogRecord res) { |
| return res.getMessage(); |
| } |
| @Override |
| public String getSourceClassName(LogRecord res) { |
| return res.getSourceClassName(); |
| } |
| @Override |
| public String getSourceMethodName(LogRecord res) { |
| return res.getSourceMethodName(); |
| } |
| @Override |
| public Throwable getThrown(LogRecord res) { |
| return res.getThrown(); |
| } |
| @Override |
| public ResourceBundle getResourceBundle(LogRecord res) { |
| return res.getResourceBundle(); |
| } |
| @Override |
| public void setLevel(java.lang.System.Logger logger, Level level) { |
| Logger backend = getBackendLogger(logger.getName()); |
| backend.setLevel(java.util.logging.Level.parse(level.name())); |
| } |
| @Override |
| public void setLevel(java.lang.System.Logger logger, java.lang.System.Logger.Level level) { |
| setLevel(logger, toJUL(level)); |
| } |
| @Override |
| public List<LogRecord> getBackendRecords() { |
| return handler.records; |
| } |
| @Override |
| public void resetBackendRecords() { |
| handler.reset(); |
| } |
| @Override |
| public Level getMappedLevel(Object level) { |
| if (level instanceof java.lang.System.Logger.Level) { |
| return toJUL((java.lang.System.Logger.Level)level); |
| } |
| return (Level)level; |
| } |
| } |
| |
| final JULBackendAdaptor julAdaptor = new JULBackendAdaptor(); |
| |
| @Override |
| BackendAdaptor adaptor() { |
| return julAdaptor; |
| } |
| |
| } |
| |
| public abstract static class BackendTesterFactory { |
| public abstract BackendTester createBackendTester(boolean isSystem); |
| public abstract BackendTester createBackendTester(boolean isSystem, |
| Class<? extends java.lang.System.Logger> restrictedTo); |
| public abstract BackendTester createBackendTester(boolean isSystem, |
| Class<? extends java.lang.System.Logger> restrictedTo, |
| ResourceBundle bundle); |
| public abstract BackendTester createBackendTester(boolean isSystem, |
| ResourceBundle bundle); |
| } |
| |
| public static class JULBackendTesterFactory extends BackendTesterFactory { |
| |
| @Override |
| public BackendTester createBackendTester(boolean isSystem) { |
| return new JULBackendTester(isSystem); |
| } |
| |
| @Override |
| public BackendTester createBackendTester(boolean isSystem, |
| Class<? extends java.lang.System.Logger> restrictedTo) { |
| return new JULBackendTester(isSystem, restrictedTo); |
| } |
| |
| @Override |
| public BackendTester createBackendTester(boolean isSystem, |
| Class<? extends java.lang.System.Logger> restrictedTo, |
| ResourceBundle bundle) { |
| return new JULBackendTester(isSystem, restrictedTo, bundle); |
| } |
| |
| @Override |
| public BackendTester createBackendTester(boolean isSystem, |
| ResourceBundle bundle) { |
| return new JULBackendTester(isSystem, bundle); |
| } |
| } |
| |
| public static class CustomLoggerFinder extends LoggerFinder { |
| |
| static enum CustomLevel { OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE, ALL }; |
| static CustomLevel[] customLevelMap = { CustomLevel.ALL, |
| CustomLevel.TRACE, CustomLevel.DEBUG, CustomLevel.INFO, |
| CustomLevel.WARN, CustomLevel.ERROR, CustomLevel.OFF |
| }; |
| static class CustomLogRecord { |
| public final CustomLevel logLevel; |
| public final java.lang.System.Logger logger; |
| public final String msg; |
| public final Object[] params; |
| public final Throwable thrown; |
| public final ResourceBundle bundle; |
| |
| CustomLogRecord(java.lang.System.Logger producer, |
| CustomLevel level, String msg) { |
| this(producer, level, msg, (ResourceBundle)null, (Throwable)null, (Object[])null); |
| } |
| |
| CustomLogRecord(java.lang.System.Logger producer, |
| CustomLevel level, String msg, ResourceBundle bundle, |
| Throwable thrown, Object... params) { |
| this.logger = producer; |
| this.logLevel = level; |
| this.msg = msg; |
| this.params = params; |
| this.thrown = thrown; |
| this.bundle = bundle; |
| } |
| } |
| |
| static final List<CustomLogRecord> records = |
| Collections.synchronizedList(new ArrayList<>()); |
| |
| static class CustomLogger implements java.lang.System.Logger { |
| |
| final String name; |
| volatile CustomLevel level; |
| CustomLogger(String name) { |
| this.name = name; |
| this.level = CustomLevel.INFO; |
| } |
| |
| @Override |
| public String getName() { |
| return name; |
| } |
| |
| public void setLevel(CustomLevel level) { |
| this.level = level; |
| } |
| |
| |
| @Override |
| public boolean isLoggable(java.lang.System.Logger.Level level) { |
| |
| return this.level != CustomLevel.OFF && this.level.ordinal() |
| >= customLevelMap[level.ordinal()].ordinal(); |
| } |
| |
| @Override |
| public void log(java.lang.System.Logger.Level level, ResourceBundle bundle, String key, Throwable thrown) { |
| if (isLoggable(level)) { |
| records.add(new CustomLogRecord(this, customLevelMap[level.ordinal()], |
| key, bundle, thrown)); |
| } |
| } |
| |
| @Override |
| public void log(java.lang.System.Logger.Level level, ResourceBundle bundle, String format, Object... params) { |
| if (isLoggable(level)) { |
| records.add(new CustomLogRecord(this, customLevelMap[level.ordinal()], |
| format, bundle, null, params)); |
| } |
| } |
| |
| } |
| |
| final Map<String, java.lang.System.Logger> applicationLoggers = |
| Collections.synchronizedMap(new HashMap<>()); |
| final Map<String, java.lang.System.Logger> systemLoggers = |
| Collections.synchronizedMap(new HashMap<>()); |
| |
| @Override |
| public java.lang.System.Logger getLogger(String name, Module caller) { |
| ClassLoader callerLoader = caller.getClassLoader(); |
| if (callerLoader == null) { |
| systemLoggers.putIfAbsent(name, new CustomLogger(name)); |
| return systemLoggers.get(name); |
| } else { |
| applicationLoggers.putIfAbsent(name, new CustomLogger(name)); |
| return applicationLoggers.get(name); |
| } |
| } |
| |
| CustomLevel fromJul(Level level) { |
| if (level.intValue() == Level.OFF.intValue()) { |
| return CustomLevel.OFF; |
| } else if (level.intValue() > Level.SEVERE.intValue()) { |
| return CustomLevel.ERROR; |
| } else if (level.intValue() > Level.WARNING.intValue()) { |
| return CustomLevel.ERROR; |
| } else if (level.intValue() > Level.INFO.intValue()) { |
| return CustomLevel.WARN; |
| } else if (level.intValue() > Level.CONFIG.intValue()) { |
| return CustomLevel.INFO; |
| } else if (level.intValue() > Level.FINER.intValue()) { |
| return CustomLevel.DEBUG; |
| } else if (level.intValue() > Level.FINEST.intValue()) { |
| return CustomLevel.TRACE; |
| } else if (level.intValue() == Level.ALL.intValue()) { |
| return CustomLevel.ALL; |
| } else { |
| return CustomLevel.TRACE; |
| } |
| } |
| |
| Level toJul(CustomLevel level) { |
| switch(level) { |
| case OFF: return Level.OFF; |
| case FATAL: return Level.SEVERE; |
| case ERROR: return Level.SEVERE; |
| case WARN: return Level.WARNING; |
| case INFO: return Level.INFO; |
| case DEBUG: return Level.FINE; |
| case TRACE: return Level.FINER; |
| case ALL: return Level.ALL; |
| default: throw new InternalError("No such level: "+level); |
| } |
| } |
| |
| } |
| |
| public static class CustomBackendTester extends |
| BackendTester<CustomLoggerFinder.CustomLogRecord> { |
| |
| public final CustomLoggerFinder provider; |
| |
| public CustomBackendTester(boolean isSystem) { |
| this(isSystem, null, null); |
| } |
| |
| public CustomBackendTester(boolean isSystem, |
| Class<? extends java.lang.System.Logger> restrictedTo) { |
| this(isSystem, restrictedTo, null); |
| } |
| |
| public CustomBackendTester(boolean isSystem, |
| ResourceBundle localized) { |
| this(isSystem, null, localized); |
| } |
| |
| public CustomBackendTester(boolean isSystem, |
| Class<? extends java.lang.System.Logger> restrictedTo, |
| ResourceBundle localized) { |
| super(isSystem, restrictedTo, localized); |
| provider = (CustomLoggerFinder)java.lang.System.LoggerFinder.getLoggerFinder(); |
| } |
| |
| @Override |
| public java.lang.System.Logger convert(java.lang.System.Logger logger) { |
| if (restrictedTo != null && restrictedTo.isInstance(logger)) { |
| return logger; |
| } else if (restrictedTo == jdkLoggerClass) { |
| return logger; |
| } else { |
| return java.lang.System.Logger.class.cast( |
| sun.util.logging.PlatformLogger.Bridge.convert(logger)); |
| } |
| } |
| |
| class CustomBackendAdaptor extends BackendAdaptor { |
| |
| @Override |
| public String getLoggerName(CustomLoggerFinder.CustomLogRecord res) { |
| return res.logger.getName(); |
| } |
| |
| @Override |
| public CustomLoggerFinder.CustomLevel getLevel(CustomLoggerFinder.CustomLogRecord res) { |
| return res.logLevel; |
| } |
| |
| @Override |
| public String getMessage(CustomLoggerFinder.CustomLogRecord res) { |
| return res.msg; |
| } |
| |
| @Override // we don't support source class name in our custom provider implementation |
| public String getSourceClassName(CustomLoggerFinder.CustomLogRecord res) { |
| return null; |
| } |
| |
| @Override // we don't support source method name in our custom provider implementation |
| public String getSourceMethodName(CustomLoggerFinder.CustomLogRecord res) { |
| return null; |
| } |
| |
| @Override |
| public Throwable getThrown(CustomLoggerFinder.CustomLogRecord res) { |
| return res.thrown; |
| } |
| |
| @Override |
| public ResourceBundle getResourceBundle(CustomLoggerFinder.CustomLogRecord res) { |
| return res.bundle; |
| } |
| |
| @Override |
| public void setLevel(java.lang.System.Logger logger, Level level) { |
| final CustomLoggerFinder.CustomLogger l = |
| (CustomLoggerFinder.CustomLogger) |
| (isSystem ? provider.getLogger(logger.getName(), Thread.class.getModule()) : |
| provider.getLogger(logger.getName(), LoggerFinderBackendTest.class.getModule())); |
| l.setLevel(provider.fromJul(level)); |
| } |
| @Override |
| public void setLevel(java.lang.System.Logger logger, |
| java.lang.System.Logger.Level level) { |
| setLevel(logger, toJUL(level)); |
| } |
| |
| CustomLoggerFinder.CustomLevel getLevel(java.lang.System.Logger logger) { |
| final CustomLoggerFinder.CustomLogger l = |
| (CustomLoggerFinder.CustomLogger) |
| (isSystem ? provider.getLogger(logger.getName(), Thread.class.getModule()) : |
| provider.getLogger(logger.getName(), LoggerFinderBackendTest.class.getModule())); |
| return l.level; |
| } |
| |
| @Override |
| public List<CustomLoggerFinder.CustomLogRecord> getBackendRecords() { |
| return CustomLoggerFinder.records; |
| } |
| |
| @Override |
| public void resetBackendRecords() { |
| CustomLoggerFinder.records.clear(); |
| } |
| |
| @Override |
| public boolean shouldBeLoggable(Levels level, Level loggerLevel) { |
| return loggerLevel != Level.OFF && |
| fromLevels(level).ordinal() <= provider.fromJul(loggerLevel).ordinal(); |
| } |
| |
| @Override |
| public boolean isLoggable(java.lang.System.Logger logger, Level l) { |
| return super.isLoggable(logger, l); |
| } |
| |
| @Override |
| public boolean shouldBeLoggable(Level logLevel, Level loggerLevel) { |
| return loggerLevel != Level.OFF && |
| provider.fromJul(logLevel).ordinal() <= provider.fromJul(loggerLevel).ordinal(); |
| } |
| |
| @Override // we don't support source class name in our custom provider implementation |
| public String getCallerClassName(Levels level, String clazz) { |
| return null; |
| } |
| |
| @Override // we don't support source method name in our custom provider implementation |
| public String getCallerMethodName(Levels level, String method) { |
| return null; |
| } |
| |
| @Override // we don't support source class name in our custom provider implementation |
| public String getCallerClassName(MethodInvoker<?,?> logMethod, String clazz) { |
| return null; |
| } |
| |
| @Override // we don't support source method name in our custom provider implementation |
| public String getCallerMethodName(MethodInvoker<?,?> logMethod, String method) { |
| return null; |
| } |
| |
| @Override |
| public CustomLoggerFinder.CustomLevel getMappedLevel(Object level) { |
| if (level instanceof java.lang.System.Logger.Level) { |
| final int index = ((java.lang.System.Logger.Level)level).ordinal(); |
| return CustomLoggerFinder.customLevelMap[index]; |
| } else if (level instanceof Level) { |
| return provider.fromJul((Level)level); |
| } |
| return (CustomLoggerFinder.CustomLevel) level; |
| } |
| |
| CustomLoggerFinder.CustomLevel fromLevels(Levels level) { |
| switch(level) { |
| case SEVERE: |
| return CustomLoggerFinder.CustomLevel.ERROR; |
| case WARNING: |
| return CustomLoggerFinder.CustomLevel.WARN; |
| case INFO: |
| return CustomLoggerFinder.CustomLevel.INFO; |
| case CONFIG: case FINE: |
| return CustomLoggerFinder.CustomLevel.DEBUG; |
| case FINER: case FINEST: |
| return CustomLoggerFinder.CustomLevel.TRACE; |
| } |
| throw new InternalError("No such level "+level); |
| } |
| |
| } |
| |
| @Override |
| BackendAdaptor adaptor() { |
| return new CustomBackendAdaptor(); |
| } |
| |
| } |
| |
| public static class CustomBackendTesterFactory extends BackendTesterFactory { |
| |
| @Override |
| public BackendTester createBackendTester(boolean isSystem) { |
| return new CustomBackendTester(isSystem); |
| } |
| |
| @Override |
| public BackendTester createBackendTester(boolean isSystem, |
| Class<? extends java.lang.System.Logger> restrictedTo) { |
| return new CustomBackendTester(isSystem, restrictedTo); |
| } |
| |
| @Override |
| public BackendTester createBackendTester(boolean isSystem, |
| Class<? extends java.lang.System.Logger> restrictedTo, |
| ResourceBundle bundle) { |
| return new CustomBackendTester(isSystem, restrictedTo, bundle); |
| } |
| |
| @Override |
| public BackendTester createBackendTester(boolean isSystem, |
| ResourceBundle bundle) { |
| return new CustomBackendTester(isSystem, bundle); |
| } |
| } |
| |
| static final Method getLazyLogger; |
| static final Method accessLoggerFinder; |
| static { |
| // jdk.internal.logger.LazyLoggers.getLazyLogger(name, caller); |
| try { |
| Class<?> lazyLoggers = jdk.internal.logger.LazyLoggers.class; |
| getLazyLogger = lazyLoggers.getMethod("getLazyLogger", |
| String.class, Module.class); |
| getLazyLogger.setAccessible(true); |
| Class<?> loggerFinderLoader = |
| Class.forName("java.lang.System$LoggerFinder"); |
| accessLoggerFinder = loggerFinderLoader.getDeclaredMethod("accessProvider"); |
| accessLoggerFinder.setAccessible(true); |
| } catch (Throwable ex) { |
| throw new ExceptionInInitializerError(ex); |
| } |
| } |
| |
| static java.lang.System.Logger getSystemLogger(String name, Module caller) throws Exception { |
| try { |
| return java.lang.System.Logger.class.cast(getLazyLogger.invoke(null, name, caller)); |
| } catch (InvocationTargetException x) { |
| Throwable t = x.getTargetException(); |
| if (t instanceof Exception) { |
| throw (Exception)t; |
| } else { |
| throw (Error)t; |
| } |
| } |
| } |
| static java.lang.System.Logger getSystemLogger(String name, |
| ResourceBundle bundle, Module caller) throws Exception { |
| try { |
| LoggerFinder provider = LoggerFinder.class.cast(accessLoggerFinder.invoke(null)); |
| return provider.getLocalizedLogger(name, bundle, caller); |
| } catch (InvocationTargetException x) { |
| Throwable t = x.getTargetException(); |
| if (t instanceof Exception) { |
| throw (Exception)t; |
| } else { |
| throw (Error)t; |
| } |
| } |
| } |
| |
| // Change this to 'true' to get more traces... |
| public static boolean verbose = false; |
| |
| public static void main(String[] argv) throws Exception { |
| |
| final AtomicInteger nb = new AtomicInteger(0); |
| final boolean hidesProvider = Boolean.getBoolean("test.logger.hidesProvider"); |
| System.out.println(ClassLoader.getSystemClassLoader()); |
| final BackendTesterFactory factory; |
| if (java.lang.System.LoggerFinder.getLoggerFinder() instanceof CustomLoggerFinder) { |
| if (hidesProvider) { |
| System.err.println("Custom backend " |
| + java.lang.System.LoggerFinder.getLoggerFinder() |
| + " should have been hidden!"); |
| throw new RuntimeException( |
| "Custom backend should have been hidden: " |
| + "check value of java.system.class.loader property"); |
| } |
| System.out.println("Using custom backend"); |
| factory = new CustomBackendTesterFactory(); |
| } else { |
| if (!hidesProvider) { |
| System.err.println("Default JUL backend " |
| + java.lang.System.LoggerFinder.getLoggerFinder() |
| + " should have been hidden!"); |
| throw new RuntimeException( |
| "Default JUL backend should have been hidden: " |
| + "check value of java.system.class.loader property"); |
| } |
| System.out.println("Using JUL backend"); |
| factory = new JULBackendTesterFactory(); |
| } |
| |
| testBackend(nb, factory); |
| } |
| |
| public static void testBackend(AtomicInteger nb, BackendTesterFactory factory) throws Exception { |
| |
| // Tests all level specifics methods with loggers configured with |
| // all possible levels and loggers obtained with all possible |
| // entry points from LoggerFactory and JdkLoggerFactory, with |
| // JUL as backend. |
| |
| // Test a simple application logger with JUL backend |
| final BackendTester tester = factory.createBackendTester(false); |
| final java.lang.System.Logger logger = |
| java.lang.System.LoggerFinder.getLoggerFinder() |
| .getLogger("foo", LoggerFinderBackendTest.class.getModule()); |
| |
| testLogger(tester, logger, nb); |
| |
| // Test a simple system logger with JUL backend |
| final java.lang.System.Logger system = |
| java.lang.System.LoggerFinder.getLoggerFinder() |
| .getLogger("bar", Thread.class.getModule()); |
| final BackendTester systemTester = factory.createBackendTester(true); |
| testLogger(systemTester, system, nb); |
| |
| // Test a localized application logger with null resource bundle and |
| // JUL backend |
| final java.lang.System.Logger noBundleLogger = |
| java.lang.System.LoggerFinder.getLoggerFinder() |
| .getLocalizedLogger("baz", null, LoggerFinderBackendTest.class.getModule()); |
| final BackendTester noBundleTester = |
| factory.createBackendTester(false, spiLoggerClass); |
| testLogger(noBundleTester, noBundleLogger, nb); |
| |
| // Test a localized system logger with null resource bundle and JUL |
| // backend |
| final java.lang.System.Logger noBundleSysLogger = |
| java.lang.System.LoggerFinder.getLoggerFinder() |
| .getLocalizedLogger("oof", null, Thread.class.getModule()); |
| final BackendTester noBundleSysTester = |
| factory.createBackendTester(true, spiLoggerClass); |
| testLogger(noBundleSysTester, noBundleSysLogger, nb); |
| |
| // Test a localized application logger with null resource bundle and |
| // JUL backend |
| try { |
| System.getLogger("baz", null); |
| throw new RuntimeException("Expected NullPointerException not thrown"); |
| } catch (NullPointerException x) { |
| System.out.println("System.Loggers.getLogger(\"baz\", null): got expected " + x); |
| } |
| final java.lang.System.Logger noBundleExtensionLogger = |
| getSystemLogger("baz", null, LoggerFinderBackendTest.class.getModule()); |
| final BackendTester noBundleExtensionTester = |
| factory.createBackendTester(false, jdkLoggerClass); |
| testLogger(noBundleExtensionTester, noBundleExtensionLogger, nb); |
| |
| // Test a simple system logger with JUL backend |
| final java.lang.System.Logger sysExtensionLogger = |
| getSystemLogger("oof", Thread.class.getModule()); |
| final BackendTester sysExtensionTester = |
| factory.createBackendTester(true, jdkLoggerClass); |
| testLogger(sysExtensionTester, sysExtensionLogger, nb); |
| |
| // Test a localized system logger with null resource bundle and JUL |
| // backend |
| final java.lang.System.Logger noBundleSysExtensionLogger = |
| getSystemLogger("oof", null, Thread.class.getModule()); |
| final BackendTester noBundleSysExtensionTester = |
| factory.createBackendTester(true, jdkLoggerClass); |
| testLogger(noBundleSysExtensionTester, noBundleSysExtensionLogger, nb); |
| |
| // Test a localized application logger converted to JDK with null |
| // resource bundle and JUL backend |
| final java.lang.System.Logger noBundleConvertedLogger = |
| (java.lang.System.Logger) |
| sun.util.logging.PlatformLogger.Bridge.convert(noBundleLogger); |
| final BackendTester noBundleJdkTester = factory.createBackendTester(false); |
| testLogger(noBundleJdkTester, noBundleConvertedLogger, nb); |
| |
| // Test a localized system logger converted to JDK with null resource |
| // bundle and JUL backend |
| final java.lang.System.Logger noBundleConvertedSysLogger = |
| (java.lang.System.Logger) |
| sun.util.logging.PlatformLogger.Bridge.convert(noBundleSysLogger); |
| final BackendTester noBundleJdkSysTester = factory.createBackendTester(true); |
| testLogger(noBundleJdkSysTester, noBundleConvertedSysLogger, nb); |
| |
| // Test a localized application logger with resource bundle and JUL |
| // backend |
| final ResourceBundle bundle = |
| ResourceBundle.getBundle(ResourceBundeLocalized.class.getName()); |
| final java.lang.System.Logger bundleLogger = |
| java.lang.System.LoggerFinder.getLoggerFinder() |
| .getLocalizedLogger("toto", bundle, LoggerFinderBackendTest.class.getModule()); |
| final BackendTester bundleTester = |
| factory.createBackendTester(false, spiLoggerClass, bundle); |
| testLogger(bundleTester, bundleLogger, nb); |
| |
| // Test a localized system logger with resource bundle and JUL backend |
| final java.lang.System.Logger bundleSysLogger = |
| java.lang.System.LoggerFinder.getLoggerFinder() |
| .getLocalizedLogger("titi", bundle, Thread.class.getModule()); |
| final BackendTester bundleSysTester = |
| factory.createBackendTester(true, spiLoggerClass, bundle); |
| testLogger(bundleSysTester, bundleSysLogger, nb); |
| |
| // Test a localized Jdk application logger with resource bundle and JUL |
| // backend |
| final java.lang.System.Logger bundleExtensionLogger = |
| System.getLogger("tita", bundle); |
| final BackendTester bundleExtensionTester = |
| factory.createBackendTester(false, jdkLoggerClass, bundle); |
| testLogger(bundleExtensionTester, bundleExtensionLogger, nb); |
| |
| // Test a localized Jdk system logger with resource bundle and JUL |
| // backend |
| final java.lang.System.Logger bundleExtensionSysLogger = |
| getSystemLogger("titu", bundle, Thread.class.getModule()); |
| final BackendTester bundleExtensionSysTester = |
| factory.createBackendTester(true, jdkLoggerClass, bundle); |
| testLogger(bundleExtensionSysTester, bundleExtensionSysLogger, nb); |
| |
| // Test a localized application logger converted to JDK with resource |
| // bundle and JUL backend |
| final BackendTester bundleJdkTester = |
| factory.createBackendTester(false, bundle); |
| final java.lang.System.Logger bundleConvertedLogger = |
| (java.lang.System.Logger) |
| sun.util.logging.PlatformLogger.Bridge.convert(bundleLogger); |
| testLogger(bundleJdkTester, bundleConvertedLogger, nb); |
| |
| // Test a localized Jdk system logger converted to JDK with resource |
| // bundle and JUL backend |
| final BackendTester bundleJdkSysTester = |
| factory.createBackendTester(true, bundle); |
| final java.lang.System.Logger bundleConvertedSysLogger = |
| (java.lang.System.Logger) |
| sun.util.logging.PlatformLogger.Bridge.convert(bundleSysLogger); |
| testLogger(bundleJdkSysTester, bundleConvertedSysLogger, nb); |
| |
| // Now need to add tests for all the log/logp/logrb methods... |
| |
| } |
| |
| private static class FooObj { |
| final String s; |
| FooObj(String s) { |
| this.s = s; |
| } |
| |
| @Override |
| public String toString() { |
| return super.toString() +": "+s; |
| } |
| |
| } |
| |
| public static void testLogger(BackendTester tester, |
| java.lang.System.Logger spiLogger, AtomicInteger nb) { |
| |
| // Test all level-specific method forms: |
| // fatal(...) error(...) severe(...) etc... |
| java.lang.System.Logger jdkLogger = tester.convert(spiLogger); |
| for (Levels l : Levels.values()) { |
| java.lang.System.Logger logger = |
| l.definingClass.equals(spiLoggerClass) ? spiLogger : jdkLogger; |
| tester.testLevel(l, logger, l.method + "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet()); |
| tester.testLevel(l, logger, l.method + "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet(), |
| bundleParam); |
| final int nbb = nb.incrementAndGet(); |
| tester.testLevel(l, logger, () -> l.method + "[" + logger.getName() |
| + "]-" + nbb); |
| } |
| for (Levels l : Levels.values()) { |
| java.lang.System.Logger logger = |
| l.definingClass.equals(spiLoggerClass) ? spiLogger : jdkLogger; |
| tester.testLevel(l, logger, |
| l.method + "[" + logger.getName()+ "]({0},{1})-" |
| + nb.incrementAndGet(), |
| "One", "Two"); |
| tester.testLevel(l, logger, |
| l.method + "[" + logger.getName()+ "]({0},{1})-" |
| + nb.incrementAndGet(), |
| bundleParam, "One", "Two"); |
| } |
| final Throwable thrown = new RuntimeException("Test"); |
| for (Levels l : Levels.values()) { |
| java.lang.System.Logger logger = |
| l.definingClass.equals(spiLoggerClass) ? spiLogger : jdkLogger; |
| tester.testLevel(l, logger, l.method + "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet(), |
| thrown); |
| tester.testLevel(l, logger, l.method + "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet(), |
| bundleParam, thrown); |
| final int nbb = nb.incrementAndGet(); |
| tester.testLevel(l, logger, ()->l.method + "[" + logger.getName()+ "]-" |
| + nbb, thrown); |
| } |
| |
| java.lang.System.Logger logger = jdkLogger; |
| |
| // test System.Logger methods |
| tester.testSpiLog(logger, "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet()); |
| tester.testSpiLog(logger, bundleParam, "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet()); |
| tester.testSpiLog(logger, "[" + logger.getName()+ "]-({0},{1})" |
| + nb.incrementAndGet(), "One", "Two"); |
| tester.testSpiLog(logger, bundleParam, "[" + logger.getName()+ "]-({0},{1})" |
| + nb.incrementAndGet(), "One", "Two"); |
| tester.testSpiLog(logger, "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet(), thrown); |
| tester.testSpiLog(logger, bundleParam, "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet(), thrown); |
| final int nbb01 = nb.incrementAndGet(); |
| tester.testSpiLog(logger, () -> "[" + logger.getName()+ "]-" + nbb01); |
| final int nbb02 = nb.incrementAndGet(); |
| tester.testSpiLog(logger, thrown, () -> "[" + logger.getName()+ "]-" + nbb02); |
| final int nbb03 = nb.incrementAndGet(); |
| tester.testSpiLog(logger, new FooObj("[" + logger.getName()+ "]-" + nbb03)); |
| |
| // Test all log method forms: |
| // jdk.internal.logging.Logger.log(...) |
| tester.testLog(logger, "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet()); |
| tester.testLogrb(logger, bundleParam, "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet()); |
| tester.testLog(logger, "[" + logger.getName()+ "]-({0},{1})" |
| + nb.incrementAndGet(), "One", "Two"); |
| tester.testLogrb(logger, bundleParam, "[" + logger.getName()+ "]-({0},{1})" |
| + nb.incrementAndGet(), "One", "Two"); |
| tester.testLog(logger, "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet(), thrown); |
| tester.testLogrb(logger, bundleParam, "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet(), thrown); |
| final int nbb1 = nb.incrementAndGet(); |
| tester.testLog(logger, () -> "[" + logger.getName()+ "]-" + nbb1); |
| final int nbb2 = nb.incrementAndGet(); |
| tester.testLog(logger, thrown, () -> "[" + logger.getName()+ "]-" + nbb2); |
| |
| // Test all logp method forms |
| // jdk.internal.logging.Logger.logp(...) |
| tester.testLogp(logger, "clazz" + nb.incrementAndGet(), |
| "method" + nb.incrementAndGet(), |
| "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet()); |
| tester.testLogrb(logger, "clazz" + nb.incrementAndGet(), |
| "method" + nb.incrementAndGet(), bundleParam, |
| "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet()); |
| tester.testLogp(logger, "clazz" + nb.incrementAndGet(), |
| "method" + nb.incrementAndGet(), |
| "[" + logger.getName()+ "]-({0},{1})" |
| + nb.incrementAndGet(), "One", "Two"); |
| tester.testLogrb(logger, "clazz" + nb.incrementAndGet(), |
| "method" + nb.incrementAndGet(), bundleParam, |
| "[" + logger.getName()+ "]-({0},{1})" |
| + nb.incrementAndGet(), "One", "Two"); |
| tester.testLogp(logger, "clazz" + nb.incrementAndGet(), |
| "method" + nb.incrementAndGet(), |
| "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet(), thrown); |
| tester.testLogrb(logger, "clazz" + nb.incrementAndGet(), |
| "method" + nb.incrementAndGet(), bundleParam, |
| "[" + logger.getName()+ "]-" |
| + nb.incrementAndGet(), thrown); |
| final int nbb3 = nb.incrementAndGet(); |
| tester.testLogp(logger, "clazz" + nb.incrementAndGet(), |
| "method" + nb.incrementAndGet(), |
| () -> "[" + logger.getName()+ "]-" + nbb3); |
| final int nbb4 = nb.incrementAndGet(); |
| tester.testLogp(logger, "clazz" + nb.incrementAndGet(), |
| "method" + nb.incrementAndGet(), |
| thrown, () -> "[" + logger.getName()+ "]-" + nbb4); |
| } |
| |
| } |