60 import java.util.HashMap;
61 import java.util.LinkedHashMap;
62 import java.util.LinkedHashSet;
63 import java.util.List;
64 import java.util.Map;
65 import java.util.Objects;
66 import java.util.ResourceBundle;
67 import java.util.concurrent.atomic.AtomicInteger;
68 import java.util.function.BiFunction;
69 import java.util.function.BooleanSupplier;
70 import java.util.function.Function;
71 import java.util.function.Supplier;
72 import java.lang.System.LoggerFinder;
73 import java.util.logging.ConsoleHandler;
74 import java.util.logging.Handler;
75 import sun.util.logging.PlatformLogger.Level;
76 import java.util.logging.LogManager;
77 import java.util.logging.LogRecord;
78 import java.util.logging.Logger;
79 import sun.util.logging.internal.LoggingProviderImpl;
80
81 /**
82 * @author danielfuchs
83 */
84 public class LoggerFinderBackendTest {
85
86 // whether the implementation of Logger try to do a best
87 // effort for logp... If the provider is not hidden, then
88 // the logp() implementation comes from LoggerWrapper - which does a
89 // best effort. Otherwise, it comes from the default provider
90 // which does support logp.
91 static final boolean BEST_EFFORT_FOR_LOGP =
92 !Boolean.getBoolean("test.logger.hidesProvider");
93 static final boolean VERBOSE = false;
94
95 static final Class<java.lang.System.Logger> spiLoggerClass =
96 java.lang.System.Logger.class;
97 static final Class<java.lang.System.Logger> jdkLoggerClass =
98 java.lang.System.Logger.class;
99 static final Class<sun.util.logging.PlatformLogger.Bridge> bridgeLoggerClass =
1489
1490 public JULBackendTester(boolean isSystem) {
1491 this(isSystem,null,null);
1492 }
1493 public JULBackendTester(boolean isSystem, ResourceBundle localized) {
1494 this(isSystem,null,localized);
1495 }
1496 public JULBackendTester(boolean isSystem,
1497 Class<? extends java.lang.System.Logger> restrictedTo) {
1498 this(isSystem, restrictedTo, null);
1499 }
1500 public JULBackendTester(boolean isSystem,
1501 Class<? extends java.lang.System.Logger> restrictedTo,
1502 ResourceBundle localized) {
1503 super(isSystem, restrictedTo, localized);
1504 }
1505
1506 Logger getBackendLogger(String name) {
1507 if (isSystem) {
1508 return LoggingProviderImpl.getLogManagerAccess().demandLoggerFor(
1509 LogManager.getLogManager(), name, Thread.class);
1510 } else {
1511 return Logger.getLogger(name);
1512 }
1513 }
1514
1515 class JULBackendAdaptor extends BackendAdaptor {
1516 @Override
1517 public String getLoggerName(LogRecord res) {
1518 return res.getLoggerName();
1519 }
1520 @Override
1521 public Level getLevel(LogRecord res) {
1522 return Level.valueOf(res.getLevel().getName());
1523 }
1524 @Override
1525 public String getMessage(LogRecord res) {
1526 return res.getMessage();
1527 }
1528 @Override
1529 public String getSourceClassName(LogRecord res) {
1682 key, bundle, thrown));
1683 }
1684 }
1685
1686 @Override
1687 public void log(java.lang.System.Logger.Level level, ResourceBundle bundle, String format, Object... params) {
1688 if (isLoggable(level)) {
1689 records.add(new CustomLogRecord(this, customLevelMap[level.ordinal()],
1690 format, bundle, null, params));
1691 }
1692 }
1693
1694 }
1695
1696 final Map<String, java.lang.System.Logger> applicationLoggers =
1697 Collections.synchronizedMap(new HashMap<>());
1698 final Map<String, java.lang.System.Logger> systemLoggers =
1699 Collections.synchronizedMap(new HashMap<>());
1700
1701 @Override
1702 public java.lang.System.Logger getLogger(String name, Class<?> caller) {
1703 ClassLoader callerLoader = caller.getClassLoader();
1704 if (callerLoader == null) {
1705 systemLoggers.putIfAbsent(name, new CustomLogger(name));
1706 return systemLoggers.get(name);
1707 } else {
1708 applicationLoggers.putIfAbsent(name, new CustomLogger(name));
1709 return applicationLoggers.get(name);
1710 }
1711 }
1712
1713 CustomLevel fromJul(Level level) {
1714 if (level.intValue() == Level.OFF.intValue()) {
1715 return CustomLevel.OFF;
1716 } else if (level.intValue() > Level.SEVERE.intValue()) {
1717 return CustomLevel.ERROR;
1718 } else if (level.intValue() > Level.WARNING.intValue()) {
1719 return CustomLevel.ERROR;
1720 } else if (level.intValue() > Level.INFO.intValue()) {
1721 return CustomLevel.WARN;
1722 } else if (level.intValue() > Level.CONFIG.intValue()) {
1810
1811 @Override // we don't support source method name in our custom provider implementation
1812 public String getSourceMethodName(CustomLoggerFinder.CustomLogRecord res) {
1813 return null;
1814 }
1815
1816 @Override
1817 public Throwable getThrown(CustomLoggerFinder.CustomLogRecord res) {
1818 return res.thrown;
1819 }
1820
1821 @Override
1822 public ResourceBundle getResourceBundle(CustomLoggerFinder.CustomLogRecord res) {
1823 return res.bundle;
1824 }
1825
1826 @Override
1827 public void setLevel(java.lang.System.Logger logger, Level level) {
1828 final CustomLoggerFinder.CustomLogger l =
1829 (CustomLoggerFinder.CustomLogger)
1830 (isSystem ? provider.getLogger(logger.getName(), Thread.class) :
1831 provider.getLogger(logger.getName(), LoggerFinderBackendTest.class));
1832 l.setLevel(provider.fromJul(level));
1833 }
1834 @Override
1835 public void setLevel(java.lang.System.Logger logger,
1836 java.lang.System.Logger.Level level) {
1837 setLevel(logger, toJUL(level));
1838 }
1839
1840 CustomLoggerFinder.CustomLevel getLevel(java.lang.System.Logger logger) {
1841 final CustomLoggerFinder.CustomLogger l =
1842 (CustomLoggerFinder.CustomLogger)
1843 (isSystem ? provider.getLogger(logger.getName(), Thread.class) :
1844 provider.getLogger(logger.getName(), LoggerFinderBackendTest.class));
1845 return l.level;
1846 }
1847
1848 @Override
1849 public List<CustomLoggerFinder.CustomLogRecord> getBackendRecords() {
1850 return CustomLoggerFinder.records;
1851 }
1852
1853 @Override
1854 public void resetBackendRecords() {
1855 CustomLoggerFinder.records.clear();
1856 }
1857
1858 @Override
1859 public boolean shouldBeLoggable(Levels level, Level loggerLevel) {
1860 return loggerLevel != Level.OFF &&
1861 fromLevels(level).ordinal() <= provider.fromJul(loggerLevel).ordinal();
1862 }
1863
1864 @Override
1945 public BackendTester createBackendTester(boolean isSystem,
1946 Class<? extends java.lang.System.Logger> restrictedTo,
1947 ResourceBundle bundle) {
1948 return new CustomBackendTester(isSystem, restrictedTo, bundle);
1949 }
1950
1951 @Override
1952 public BackendTester createBackendTester(boolean isSystem,
1953 ResourceBundle bundle) {
1954 return new CustomBackendTester(isSystem, bundle);
1955 }
1956 }
1957
1958 static final Method getLazyLogger;
1959 static final Method accessLoggerFinder;
1960 static {
1961 // jdk.internal.logger.LazyLoggers.getLazyLogger(name, caller);
1962 try {
1963 Class<?> lazyLoggers = jdk.internal.logger.LazyLoggers.class;
1964 getLazyLogger = lazyLoggers.getMethod("getLazyLogger",
1965 String.class, Class.class);
1966 getLazyLogger.setAccessible(true);
1967 Class<?> loggerFinderLoader =
1968 Class.forName("java.lang.System$LoggerFinder");
1969 accessLoggerFinder = loggerFinderLoader.getDeclaredMethod("accessProvider");
1970 accessLoggerFinder.setAccessible(true);
1971 } catch (Throwable ex) {
1972 throw new ExceptionInInitializerError(ex);
1973 }
1974 }
1975
1976 static java.lang.System.Logger getSystemLogger(String name, Class<?> caller) throws Exception {
1977 try {
1978 return java.lang.System.Logger.class.cast(getLazyLogger.invoke(null, name, caller));
1979 } catch (InvocationTargetException x) {
1980 Throwable t = x.getTargetException();
1981 if (t instanceof Exception) {
1982 throw (Exception)t;
1983 } else {
1984 throw (Error)t;
1985 }
1986 }
1987 }
1988 static java.lang.System.Logger getSystemLogger(String name,
1989 ResourceBundle bundle, Class<?> caller) throws Exception {
1990 try {
1991 LoggerFinder provider = LoggerFinder.class.cast(accessLoggerFinder.invoke(null));
1992 return provider.getLocalizedLogger(name, bundle, caller);
1993 } catch (InvocationTargetException x) {
1994 Throwable t = x.getTargetException();
1995 if (t instanceof Exception) {
1996 throw (Exception)t;
1997 } else {
1998 throw (Error)t;
1999 }
2000 }
2001 }
2002
2003 // Change this to 'true' to get more traces...
2004 public static boolean verbose = false;
2005
2006 public static void main(String[] argv) throws Exception {
2007
2008 final AtomicInteger nb = new AtomicInteger(0);
2009 final boolean hidesProvider = Boolean.getBoolean("test.logger.hidesProvider");
2030 + "check value of java.system.class.loader property");
2031 }
2032 System.out.println("Using JUL backend");
2033 factory = new JULBackendTesterFactory();
2034 }
2035
2036 testBackend(nb, factory);
2037 }
2038
2039 public static void testBackend(AtomicInteger nb, BackendTesterFactory factory) throws Exception {
2040
2041 // Tests all level specifics methods with loggers configured with
2042 // all possible levels and loggers obtained with all possible
2043 // entry points from LoggerFactory and JdkLoggerFactory, with
2044 // JUL as backend.
2045
2046 // Test a simple application logger with JUL backend
2047 final BackendTester tester = factory.createBackendTester(false);
2048 final java.lang.System.Logger logger =
2049 java.lang.System.LoggerFinder.getLoggerFinder()
2050 .getLogger("foo", LoggerFinderBackendTest.class);
2051
2052 testLogger(tester, logger, nb);
2053
2054 // Test a simple system logger with JUL backend
2055 final java.lang.System.Logger system =
2056 java.lang.System.LoggerFinder.getLoggerFinder()
2057 .getLogger("bar", Thread.class);
2058 final BackendTester systemTester = factory.createBackendTester(true);
2059 testLogger(systemTester, system, nb);
2060
2061 // Test a localized application logger with null resource bundle and
2062 // JUL backend
2063 final java.lang.System.Logger noBundleLogger =
2064 java.lang.System.LoggerFinder.getLoggerFinder()
2065 .getLocalizedLogger("baz", null, LoggerFinderBackendTest.class);
2066 final BackendTester noBundleTester =
2067 factory.createBackendTester(false, spiLoggerClass);
2068 testLogger(noBundleTester, noBundleLogger, nb);
2069
2070 // Test a localized system logger with null resource bundle and JUL
2071 // backend
2072 final java.lang.System.Logger noBundleSysLogger =
2073 java.lang.System.LoggerFinder.getLoggerFinder()
2074 .getLocalizedLogger("oof", null, Thread.class);
2075 final BackendTester noBundleSysTester =
2076 factory.createBackendTester(true, spiLoggerClass);
2077 testLogger(noBundleSysTester, noBundleSysLogger, nb);
2078
2079 // Test a localized application logger with null resource bundle and
2080 // JUL backend
2081 try {
2082 System.getLogger("baz", null);
2083 throw new RuntimeException("Expected NullPointerException not thrown");
2084 } catch (NullPointerException x) {
2085 System.out.println("System.Loggers.getLogger(\"baz\", null): got expected " + x);
2086 }
2087 final java.lang.System.Logger noBundleExtensionLogger =
2088 getSystemLogger("baz", null, LoggerFinderBackendTest.class);
2089 final BackendTester noBundleExtensionTester =
2090 factory.createBackendTester(false, jdkLoggerClass);
2091 testLogger(noBundleExtensionTester, noBundleExtensionLogger, nb);
2092
2093 // Test a simple system logger with JUL backend
2094 final java.lang.System.Logger sysExtensionLogger =
2095 getSystemLogger("oof", Thread.class);
2096 final BackendTester sysExtensionTester =
2097 factory.createBackendTester(true, jdkLoggerClass);
2098 testLogger(sysExtensionTester, sysExtensionLogger, nb);
2099
2100 // Test a localized system logger with null resource bundle and JUL
2101 // backend
2102 final java.lang.System.Logger noBundleSysExtensionLogger =
2103 getSystemLogger("oof", null, Thread.class);
2104 final BackendTester noBundleSysExtensionTester =
2105 factory.createBackendTester(true, jdkLoggerClass);
2106 testLogger(noBundleSysExtensionTester, noBundleSysExtensionLogger, nb);
2107
2108 // Test a localized application logger converted to JDK with null
2109 // resource bundle and JUL backend
2110 final java.lang.System.Logger noBundleConvertedLogger =
2111 (java.lang.System.Logger)
2112 sun.util.logging.PlatformLogger.Bridge.convert(noBundleLogger);
2113 final BackendTester noBundleJdkTester = factory.createBackendTester(false);
2114 testLogger(noBundleJdkTester, noBundleConvertedLogger, nb);
2115
2116 // Test a localized system logger converted to JDK with null resource
2117 // bundle and JUL backend
2118 final java.lang.System.Logger noBundleConvertedSysLogger =
2119 (java.lang.System.Logger)
2120 sun.util.logging.PlatformLogger.Bridge.convert(noBundleSysLogger);
2121 final BackendTester noBundleJdkSysTester = factory.createBackendTester(true);
2122 testLogger(noBundleJdkSysTester, noBundleConvertedSysLogger, nb);
2123
2124 // Test a localized application logger with resource bundle and JUL
2125 // backend
2126 final ResourceBundle bundle =
2127 ResourceBundle.getBundle(ResourceBundeLocalized.class.getName());
2128 final java.lang.System.Logger bundleLogger =
2129 java.lang.System.LoggerFinder.getLoggerFinder()
2130 .getLocalizedLogger("toto", bundle, LoggerFinderBackendTest.class);
2131 final BackendTester bundleTester =
2132 factory.createBackendTester(false, spiLoggerClass, bundle);
2133 testLogger(bundleTester, bundleLogger, nb);
2134
2135 // Test a localized system logger with resource bundle and JUL backend
2136 final java.lang.System.Logger bundleSysLogger =
2137 java.lang.System.LoggerFinder.getLoggerFinder()
2138 .getLocalizedLogger("titi", bundle, Thread.class);
2139 final BackendTester bundleSysTester =
2140 factory.createBackendTester(true, spiLoggerClass, bundle);
2141 testLogger(bundleSysTester, bundleSysLogger, nb);
2142
2143 // Test a localized Jdk application logger with resource bundle and JUL
2144 // backend
2145 final java.lang.System.Logger bundleExtensionLogger =
2146 System.getLogger("tita", bundle);
2147 final BackendTester bundleExtensionTester =
2148 factory.createBackendTester(false, jdkLoggerClass, bundle);
2149 testLogger(bundleExtensionTester, bundleExtensionLogger, nb);
2150
2151 // Test a localized Jdk system logger with resource bundle and JUL
2152 // backend
2153 final java.lang.System.Logger bundleExtensionSysLogger =
2154 getSystemLogger("titu", bundle, Thread.class);
2155 final BackendTester bundleExtensionSysTester =
2156 factory.createBackendTester(true, jdkLoggerClass, bundle);
2157 testLogger(bundleExtensionSysTester, bundleExtensionSysLogger, nb);
2158
2159 // Test a localized application logger converted to JDK with resource
2160 // bundle and JUL backend
2161 final BackendTester bundleJdkTester =
2162 factory.createBackendTester(false, bundle);
2163 final java.lang.System.Logger bundleConvertedLogger =
2164 (java.lang.System.Logger)
2165 sun.util.logging.PlatformLogger.Bridge.convert(bundleLogger);
2166 testLogger(bundleJdkTester, bundleConvertedLogger, nb);
2167
2168 // Test a localized Jdk system logger converted to JDK with resource
2169 // bundle and JUL backend
2170 final BackendTester bundleJdkSysTester =
2171 factory.createBackendTester(true, bundle);
2172 final java.lang.System.Logger bundleConvertedSysLogger =
2173 (java.lang.System.Logger)
2174 sun.util.logging.PlatformLogger.Bridge.convert(bundleSysLogger);
|
60 import java.util.HashMap;
61 import java.util.LinkedHashMap;
62 import java.util.LinkedHashSet;
63 import java.util.List;
64 import java.util.Map;
65 import java.util.Objects;
66 import java.util.ResourceBundle;
67 import java.util.concurrent.atomic.AtomicInteger;
68 import java.util.function.BiFunction;
69 import java.util.function.BooleanSupplier;
70 import java.util.function.Function;
71 import java.util.function.Supplier;
72 import java.lang.System.LoggerFinder;
73 import java.util.logging.ConsoleHandler;
74 import java.util.logging.Handler;
75 import sun.util.logging.PlatformLogger.Level;
76 import java.util.logging.LogManager;
77 import java.util.logging.LogRecord;
78 import java.util.logging.Logger;
79 import sun.util.logging.internal.LoggingProviderImpl;
80 import java.lang.reflect.Module;
81
82 /**
83 * @author danielfuchs
84 */
85 public class LoggerFinderBackendTest {
86
87 // whether the implementation of Logger try to do a best
88 // effort for logp... If the provider is not hidden, then
89 // the logp() implementation comes from LoggerWrapper - which does a
90 // best effort. Otherwise, it comes from the default provider
91 // which does support logp.
92 static final boolean BEST_EFFORT_FOR_LOGP =
93 !Boolean.getBoolean("test.logger.hidesProvider");
94 static final boolean VERBOSE = false;
95
96 static final Class<java.lang.System.Logger> spiLoggerClass =
97 java.lang.System.Logger.class;
98 static final Class<java.lang.System.Logger> jdkLoggerClass =
99 java.lang.System.Logger.class;
100 static final Class<sun.util.logging.PlatformLogger.Bridge> bridgeLoggerClass =
1490
1491 public JULBackendTester(boolean isSystem) {
1492 this(isSystem,null,null);
1493 }
1494 public JULBackendTester(boolean isSystem, ResourceBundle localized) {
1495 this(isSystem,null,localized);
1496 }
1497 public JULBackendTester(boolean isSystem,
1498 Class<? extends java.lang.System.Logger> restrictedTo) {
1499 this(isSystem, restrictedTo, null);
1500 }
1501 public JULBackendTester(boolean isSystem,
1502 Class<? extends java.lang.System.Logger> restrictedTo,
1503 ResourceBundle localized) {
1504 super(isSystem, restrictedTo, localized);
1505 }
1506
1507 Logger getBackendLogger(String name) {
1508 if (isSystem) {
1509 return LoggingProviderImpl.getLogManagerAccess().demandLoggerFor(
1510 LogManager.getLogManager(), name, Thread.class.getModule());
1511 } else {
1512 return Logger.getLogger(name);
1513 }
1514 }
1515
1516 class JULBackendAdaptor extends BackendAdaptor {
1517 @Override
1518 public String getLoggerName(LogRecord res) {
1519 return res.getLoggerName();
1520 }
1521 @Override
1522 public Level getLevel(LogRecord res) {
1523 return Level.valueOf(res.getLevel().getName());
1524 }
1525 @Override
1526 public String getMessage(LogRecord res) {
1527 return res.getMessage();
1528 }
1529 @Override
1530 public String getSourceClassName(LogRecord res) {
1683 key, bundle, thrown));
1684 }
1685 }
1686
1687 @Override
1688 public void log(java.lang.System.Logger.Level level, ResourceBundle bundle, String format, Object... params) {
1689 if (isLoggable(level)) {
1690 records.add(new CustomLogRecord(this, customLevelMap[level.ordinal()],
1691 format, bundle, null, params));
1692 }
1693 }
1694
1695 }
1696
1697 final Map<String, java.lang.System.Logger> applicationLoggers =
1698 Collections.synchronizedMap(new HashMap<>());
1699 final Map<String, java.lang.System.Logger> systemLoggers =
1700 Collections.synchronizedMap(new HashMap<>());
1701
1702 @Override
1703 public java.lang.System.Logger getLogger(String name, Module caller) {
1704 ClassLoader callerLoader = caller.getClassLoader();
1705 if (callerLoader == null) {
1706 systemLoggers.putIfAbsent(name, new CustomLogger(name));
1707 return systemLoggers.get(name);
1708 } else {
1709 applicationLoggers.putIfAbsent(name, new CustomLogger(name));
1710 return applicationLoggers.get(name);
1711 }
1712 }
1713
1714 CustomLevel fromJul(Level level) {
1715 if (level.intValue() == Level.OFF.intValue()) {
1716 return CustomLevel.OFF;
1717 } else if (level.intValue() > Level.SEVERE.intValue()) {
1718 return CustomLevel.ERROR;
1719 } else if (level.intValue() > Level.WARNING.intValue()) {
1720 return CustomLevel.ERROR;
1721 } else if (level.intValue() > Level.INFO.intValue()) {
1722 return CustomLevel.WARN;
1723 } else if (level.intValue() > Level.CONFIG.intValue()) {
1811
1812 @Override // we don't support source method name in our custom provider implementation
1813 public String getSourceMethodName(CustomLoggerFinder.CustomLogRecord res) {
1814 return null;
1815 }
1816
1817 @Override
1818 public Throwable getThrown(CustomLoggerFinder.CustomLogRecord res) {
1819 return res.thrown;
1820 }
1821
1822 @Override
1823 public ResourceBundle getResourceBundle(CustomLoggerFinder.CustomLogRecord res) {
1824 return res.bundle;
1825 }
1826
1827 @Override
1828 public void setLevel(java.lang.System.Logger logger, Level level) {
1829 final CustomLoggerFinder.CustomLogger l =
1830 (CustomLoggerFinder.CustomLogger)
1831 (isSystem ? provider.getLogger(logger.getName(), Thread.class.getModule()) :
1832 provider.getLogger(logger.getName(), LoggerFinderBackendTest.class.getModule()));
1833 l.setLevel(provider.fromJul(level));
1834 }
1835 @Override
1836 public void setLevel(java.lang.System.Logger logger,
1837 java.lang.System.Logger.Level level) {
1838 setLevel(logger, toJUL(level));
1839 }
1840
1841 CustomLoggerFinder.CustomLevel getLevel(java.lang.System.Logger logger) {
1842 final CustomLoggerFinder.CustomLogger l =
1843 (CustomLoggerFinder.CustomLogger)
1844 (isSystem ? provider.getLogger(logger.getName(), Thread.class.getModule()) :
1845 provider.getLogger(logger.getName(), LoggerFinderBackendTest.class.getModule()));
1846 return l.level;
1847 }
1848
1849 @Override
1850 public List<CustomLoggerFinder.CustomLogRecord> getBackendRecords() {
1851 return CustomLoggerFinder.records;
1852 }
1853
1854 @Override
1855 public void resetBackendRecords() {
1856 CustomLoggerFinder.records.clear();
1857 }
1858
1859 @Override
1860 public boolean shouldBeLoggable(Levels level, Level loggerLevel) {
1861 return loggerLevel != Level.OFF &&
1862 fromLevels(level).ordinal() <= provider.fromJul(loggerLevel).ordinal();
1863 }
1864
1865 @Override
1946 public BackendTester createBackendTester(boolean isSystem,
1947 Class<? extends java.lang.System.Logger> restrictedTo,
1948 ResourceBundle bundle) {
1949 return new CustomBackendTester(isSystem, restrictedTo, bundle);
1950 }
1951
1952 @Override
1953 public BackendTester createBackendTester(boolean isSystem,
1954 ResourceBundle bundle) {
1955 return new CustomBackendTester(isSystem, bundle);
1956 }
1957 }
1958
1959 static final Method getLazyLogger;
1960 static final Method accessLoggerFinder;
1961 static {
1962 // jdk.internal.logger.LazyLoggers.getLazyLogger(name, caller);
1963 try {
1964 Class<?> lazyLoggers = jdk.internal.logger.LazyLoggers.class;
1965 getLazyLogger = lazyLoggers.getMethod("getLazyLogger",
1966 String.class, Module.class);
1967 getLazyLogger.setAccessible(true);
1968 Class<?> loggerFinderLoader =
1969 Class.forName("java.lang.System$LoggerFinder");
1970 accessLoggerFinder = loggerFinderLoader.getDeclaredMethod("accessProvider");
1971 accessLoggerFinder.setAccessible(true);
1972 } catch (Throwable ex) {
1973 throw new ExceptionInInitializerError(ex);
1974 }
1975 }
1976
1977 static java.lang.System.Logger getSystemLogger(String name, Module caller) throws Exception {
1978 try {
1979 return java.lang.System.Logger.class.cast(getLazyLogger.invoke(null, name, caller));
1980 } catch (InvocationTargetException x) {
1981 Throwable t = x.getTargetException();
1982 if (t instanceof Exception) {
1983 throw (Exception)t;
1984 } else {
1985 throw (Error)t;
1986 }
1987 }
1988 }
1989 static java.lang.System.Logger getSystemLogger(String name,
1990 ResourceBundle bundle, Module caller) throws Exception {
1991 try {
1992 LoggerFinder provider = LoggerFinder.class.cast(accessLoggerFinder.invoke(null));
1993 return provider.getLocalizedLogger(name, bundle, caller);
1994 } catch (InvocationTargetException x) {
1995 Throwable t = x.getTargetException();
1996 if (t instanceof Exception) {
1997 throw (Exception)t;
1998 } else {
1999 throw (Error)t;
2000 }
2001 }
2002 }
2003
2004 // Change this to 'true' to get more traces...
2005 public static boolean verbose = false;
2006
2007 public static void main(String[] argv) throws Exception {
2008
2009 final AtomicInteger nb = new AtomicInteger(0);
2010 final boolean hidesProvider = Boolean.getBoolean("test.logger.hidesProvider");
2031 + "check value of java.system.class.loader property");
2032 }
2033 System.out.println("Using JUL backend");
2034 factory = new JULBackendTesterFactory();
2035 }
2036
2037 testBackend(nb, factory);
2038 }
2039
2040 public static void testBackend(AtomicInteger nb, BackendTesterFactory factory) throws Exception {
2041
2042 // Tests all level specifics methods with loggers configured with
2043 // all possible levels and loggers obtained with all possible
2044 // entry points from LoggerFactory and JdkLoggerFactory, with
2045 // JUL as backend.
2046
2047 // Test a simple application logger with JUL backend
2048 final BackendTester tester = factory.createBackendTester(false);
2049 final java.lang.System.Logger logger =
2050 java.lang.System.LoggerFinder.getLoggerFinder()
2051 .getLogger("foo", LoggerFinderBackendTest.class.getModule());
2052
2053 testLogger(tester, logger, nb);
2054
2055 // Test a simple system logger with JUL backend
2056 final java.lang.System.Logger system =
2057 java.lang.System.LoggerFinder.getLoggerFinder()
2058 .getLogger("bar", Thread.class.getModule());
2059 final BackendTester systemTester = factory.createBackendTester(true);
2060 testLogger(systemTester, system, nb);
2061
2062 // Test a localized application logger with null resource bundle and
2063 // JUL backend
2064 final java.lang.System.Logger noBundleLogger =
2065 java.lang.System.LoggerFinder.getLoggerFinder()
2066 .getLocalizedLogger("baz", null, LoggerFinderBackendTest.class.getModule());
2067 final BackendTester noBundleTester =
2068 factory.createBackendTester(false, spiLoggerClass);
2069 testLogger(noBundleTester, noBundleLogger, nb);
2070
2071 // Test a localized system logger with null resource bundle and JUL
2072 // backend
2073 final java.lang.System.Logger noBundleSysLogger =
2074 java.lang.System.LoggerFinder.getLoggerFinder()
2075 .getLocalizedLogger("oof", null, Thread.class.getModule());
2076 final BackendTester noBundleSysTester =
2077 factory.createBackendTester(true, spiLoggerClass);
2078 testLogger(noBundleSysTester, noBundleSysLogger, nb);
2079
2080 // Test a localized application logger with null resource bundle and
2081 // JUL backend
2082 try {
2083 System.getLogger("baz", null);
2084 throw new RuntimeException("Expected NullPointerException not thrown");
2085 } catch (NullPointerException x) {
2086 System.out.println("System.Loggers.getLogger(\"baz\", null): got expected " + x);
2087 }
2088 final java.lang.System.Logger noBundleExtensionLogger =
2089 getSystemLogger("baz", null, LoggerFinderBackendTest.class.getModule());
2090 final BackendTester noBundleExtensionTester =
2091 factory.createBackendTester(false, jdkLoggerClass);
2092 testLogger(noBundleExtensionTester, noBundleExtensionLogger, nb);
2093
2094 // Test a simple system logger with JUL backend
2095 final java.lang.System.Logger sysExtensionLogger =
2096 getSystemLogger("oof", Thread.class.getModule());
2097 final BackendTester sysExtensionTester =
2098 factory.createBackendTester(true, jdkLoggerClass);
2099 testLogger(sysExtensionTester, sysExtensionLogger, nb);
2100
2101 // Test a localized system logger with null resource bundle and JUL
2102 // backend
2103 final java.lang.System.Logger noBundleSysExtensionLogger =
2104 getSystemLogger("oof", null, Thread.class.getModule());
2105 final BackendTester noBundleSysExtensionTester =
2106 factory.createBackendTester(true, jdkLoggerClass);
2107 testLogger(noBundleSysExtensionTester, noBundleSysExtensionLogger, nb);
2108
2109 // Test a localized application logger converted to JDK with null
2110 // resource bundle and JUL backend
2111 final java.lang.System.Logger noBundleConvertedLogger =
2112 (java.lang.System.Logger)
2113 sun.util.logging.PlatformLogger.Bridge.convert(noBundleLogger);
2114 final BackendTester noBundleJdkTester = factory.createBackendTester(false);
2115 testLogger(noBundleJdkTester, noBundleConvertedLogger, nb);
2116
2117 // Test a localized system logger converted to JDK with null resource
2118 // bundle and JUL backend
2119 final java.lang.System.Logger noBundleConvertedSysLogger =
2120 (java.lang.System.Logger)
2121 sun.util.logging.PlatformLogger.Bridge.convert(noBundleSysLogger);
2122 final BackendTester noBundleJdkSysTester = factory.createBackendTester(true);
2123 testLogger(noBundleJdkSysTester, noBundleConvertedSysLogger, nb);
2124
2125 // Test a localized application logger with resource bundle and JUL
2126 // backend
2127 final ResourceBundle bundle =
2128 ResourceBundle.getBundle(ResourceBundeLocalized.class.getName());
2129 final java.lang.System.Logger bundleLogger =
2130 java.lang.System.LoggerFinder.getLoggerFinder()
2131 .getLocalizedLogger("toto", bundle, LoggerFinderBackendTest.class.getModule());
2132 final BackendTester bundleTester =
2133 factory.createBackendTester(false, spiLoggerClass, bundle);
2134 testLogger(bundleTester, bundleLogger, nb);
2135
2136 // Test a localized system logger with resource bundle and JUL backend
2137 final java.lang.System.Logger bundleSysLogger =
2138 java.lang.System.LoggerFinder.getLoggerFinder()
2139 .getLocalizedLogger("titi", bundle, Thread.class.getModule());
2140 final BackendTester bundleSysTester =
2141 factory.createBackendTester(true, spiLoggerClass, bundle);
2142 testLogger(bundleSysTester, bundleSysLogger, nb);
2143
2144 // Test a localized Jdk application logger with resource bundle and JUL
2145 // backend
2146 final java.lang.System.Logger bundleExtensionLogger =
2147 System.getLogger("tita", bundle);
2148 final BackendTester bundleExtensionTester =
2149 factory.createBackendTester(false, jdkLoggerClass, bundle);
2150 testLogger(bundleExtensionTester, bundleExtensionLogger, nb);
2151
2152 // Test a localized Jdk system logger with resource bundle and JUL
2153 // backend
2154 final java.lang.System.Logger bundleExtensionSysLogger =
2155 getSystemLogger("titu", bundle, Thread.class.getModule());
2156 final BackendTester bundleExtensionSysTester =
2157 factory.createBackendTester(true, jdkLoggerClass, bundle);
2158 testLogger(bundleExtensionSysTester, bundleExtensionSysLogger, nb);
2159
2160 // Test a localized application logger converted to JDK with resource
2161 // bundle and JUL backend
2162 final BackendTester bundleJdkTester =
2163 factory.createBackendTester(false, bundle);
2164 final java.lang.System.Logger bundleConvertedLogger =
2165 (java.lang.System.Logger)
2166 sun.util.logging.PlatformLogger.Bridge.convert(bundleLogger);
2167 testLogger(bundleJdkTester, bundleConvertedLogger, nb);
2168
2169 // Test a localized Jdk system logger converted to JDK with resource
2170 // bundle and JUL backend
2171 final BackendTester bundleJdkSysTester =
2172 factory.createBackendTester(true, bundle);
2173 final java.lang.System.Logger bundleConvertedSysLogger =
2174 (java.lang.System.Logger)
2175 sun.util.logging.PlatformLogger.Bridge.convert(bundleSysLogger);
|