java.lang.System.LoggerFinder Java Examples

static Logger getLogger(LoggerFinder provider, String name, Module caller) {
    Logger logger;
    try {
        logger = Logger.class.cast(lazyGetLogger.invoke(null, name, caller));
    } catch (Throwable x) {
        Throwable t = (x instanceof InvocationTargetException) ?
                ((InvocationTargetException)x).getTargetException() : x;
        if (t instanceof RuntimeException) {
            throw (RuntimeException)t;
        } else if (t instanceof Exception) {
            throw new RuntimeException(t);
        } else {
            throw (Error)t;
        }
    }
    // The method above does not throw exception...
    // call the provider here to verify that an exception would have
    // been thrown by the provider.
    if (logger != null && caller == Thread.class.getModule()) {
        Logger log = provider.getLogger(name, caller);
    }
    return logger;
}
 

private static LoggerFinder accessLoggerFinder() {
    LoggerFinder prov = provider;
    if (prov == null) {
        // no need to lock: it doesn't matter if we call
        // getLoggerFinder() twice - since LoggerFinder already caches
        // the result.
        // This is just an optimization to avoid the cost of calling
        // doPrivileged every time.
        final SecurityManager sm = System.getSecurityManager();
        prov = sm == null ? LoggerFinder.getLoggerFinder() :
            AccessController.doPrivileged(
                    (PrivilegedAction<LoggerFinder>)LoggerFinder::getLoggerFinder);
        provider = prov;
    }
    return prov;
}
 

static void checkLogEvent(LoggerFinder provider, String desc,
        LogEvent expected, boolean expectNotNull) {
    LogEvent actual =  eventQueue.poll();
    if (actual == null && !expectNotNull) return;
    if (actual != null && !expectNotNull) {
        throw new RuntimeException("Unexpected log event found for " + desc
            + "\n\tgot: " + actual);
    }
    if (!expected.equals(actual)) {
        throw new RuntimeException("mismatch for " + desc
                + "\n\texpected=" + expected
                + "\n\t  actual=" + actual);
    } else {
        verbose("Got expected results for "
                + desc + "\n\t" + expected);
    }
}
 

static void checkLogEvent(LoggerFinder provider, String desc,
        LogEvent expected, boolean expectNotNull) {
    LogEvent actual =  eventQueue.poll();
    if (actual == null && !expectNotNull) return;
    if (actual != null && !expectNotNull) {
        throw new RuntimeException("Unexpected log event found for " + desc
            + "\n\tgot: " + actual);
    }
    if (!expected.equals(actual)) {
        throw new RuntimeException("mismatch for " + desc
                + "\n\texpected=" + expected
                + "\n\t  actual=" + actual);
    } else {
        verbose("Got expected results for "
                + desc + "\n\t" + expected);
    }
}
 

static void checkLogEvent(LoggerFinder provider, String desc,
        LogEvent expected, boolean expectNotNull) {
    LogEvent actual =  eventQueue.poll();
    if (actual == null && !expectNotNull) return;
    if (actual != null && !expectNotNull) {
        throw new RuntimeException("Unexpected log event found for " + desc
            + "\n\tgot: " + actual);
    }
    if (!expected.equals(actual)) {
        throw new RuntimeException("mismatch for " + desc
                + "\n\texpected=" + expected
                + "\n\t  actual=" + actual);
    } else {
        verbose("Got expected results for "
                + desc + "\n\t" + expected);
    }
}
 

public static void test(LoggerFinder provider, boolean hasRequiredPermissions) {

        ResourceBundle loggerBundle = ResourceBundle.getBundle(MyLoggerBundle.class.getName());
        final Map<Logger, String> loggerDescMap = new HashMap<>();

        System.Logger sysLogger = accessSystemLogger.getLogger("foo");
        loggerDescMap.put(sysLogger, "accessSystemLogger.getLogger(\"foo\")");
        System.Logger localizedSysLogger = accessSystemLogger.getLogger("fox", loggerBundle);
        loggerDescMap.put(localizedSysLogger, "accessSystemLogger.getLogger(\"fox\", loggerBundle)");
        System.Logger appLogger = System.getLogger("bar");
        loggerDescMap.put(appLogger,"System.getLogger(\"bar\")");
        System.Logger localizedAppLogger = System.getLogger("baz", loggerBundle);
        loggerDescMap.put(localizedAppLogger,"System.getLogger(\"baz\", loggerBundle)");

        testLogger(provider, loggerDescMap, "foo", null, sysLogger);
        testLogger(provider, loggerDescMap, "foo", loggerBundle, localizedSysLogger);
        testLogger(provider, loggerDescMap, "foo", null, appLogger);
        testLogger(provider, loggerDescMap, "foo", loggerBundle, localizedAppLogger);
    }
 

static void checkLogEvent(LoggerFinder provider, String desc,
        LogEvent expected, boolean expectNotNull) {
    LogEvent actual =  eventQueue.poll();
    if (actual == null && !expectNotNull) return;
    if (actual != null && !expectNotNull) {
        throw new RuntimeException("Unexpected log event found for " + desc
            + "\n\tgot: " + actual);
    }
    if (!expected.equals(actual)) {
        throw new RuntimeException("mismatch for " + desc
                + "\n\texpected=" + expected
                + "\n\t  actual=" + actual);
    } else {
        verbose("Got expected results for "
                + desc + "\n\t" + expected);
    }
}
 

private static LoggerFinder accessLoggerFinder() {
    LoggerFinder prov = provider;
    if (prov == null) {
        // no need to lock: it doesn't matter if we call
        // getLoggerFinder() twice - since LoggerFinder already caches
        // the result.
        // This is just an optimization to avoid the cost of calling
        // doPrivileged every time.
        final SecurityManager sm = System.getSecurityManager();
        prov = sm == null ? LoggerFinder.getLoggerFinder() :
            AccessController.doPrivileged(
                    (PrivilegedAction<LoggerFinder>)LoggerFinder::getLoggerFinder);
        provider = prov;
    }
    return prov;
}
 

void testGetLocalizedLogger(String desc, String name, ResourceBundle bundle,
                            Module mod, Class<? extends Throwable> thrown) {
    try {
        LoggerFinder finder = System.LoggerFinder.getLoggerFinder();
        Logger logger = finder.getLocalizedLogger(name, bundle, mod);
        if (thrown != null) {
            throw new AssertionError("Exception " + thrown.getName()
                    + " not thrown for "
                    + "LoggerFinder.getLocalizedLogger"
                    + " with " + desc);
        }
        // Make sure we don't fail if tests are run in parallel
        synchronized(RecordStream.LOCK) {
            LOG_STREAM.startRecording();
            try {
                logger.log(Level.INFO, "{0} with {1}: PASSED",
                          "LoggerFinder.getLocalizedLogger",
                          desc);
            } finally {
                byte[] logged = LOG_STREAM.stopRecording();
                check(logged, "testGetLocalizedLogger", desc, bundle,
                      "LoggerFinder.getLocalizedLogger");
            }
        }
    } catch (Throwable x) {
        if (thrown != null && thrown.isInstance(x)) {
            System.out.printf("Got expected exception for %s with %s: %s\n",
                    "LoggerFinder.getLocalizedLogger", desc, String.valueOf(x));
        } else throw x;
    }
}
 

void testGetLogger(String desc, String name, Module mod, Class<? extends Throwable> thrown) {
    try {
        LoggerFinder finder = System.LoggerFinder.getLoggerFinder();
        Logger logger = finder.getLogger(name, mod);
        if (thrown != null) {
            throw new AssertionError("Exception " + thrown.getName()
                    + " not thrown for "
                    + "LoggerFinder.getLogger"
                    + " with " + desc);
        }
        // Make sure we don't fail if tests are run in parallel
        synchronized(RecordStream.LOCK) {
            LOG_STREAM.startRecording();
            try {
                logger.log(Level.INFO, "{0} with {1}: PASSED",
                           "LoggerFinder.getLogger",
                           desc);
            } finally {
                byte[] logged = LOG_STREAM.stopRecording();
                check(logged, "testGetLogger", desc, null,
                      "LoggerFinder.getLogger");
            }
        }
    } catch (Throwable x) {
        if (thrown != null && thrown.isInstance(x)) {
            System.out.printf("Got expected exception for %s with %s: %s\n",
                    "LoggerFinder.getLogger", desc, String.valueOf(x));
        } else throw x;
    }
}
 

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);
    }
 

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;
        }
    }
}
 

boolean accept(String name) {
    final boolean res = !name.endsWith(LoggerFinder.class.getName());
    if (res == false) {
        System.out.println("Hiding " + name);
    }
    return res;
}
 

static TestLoggerFinder getLoggerFinder(Class<?> expectedClass) {
    LoggerFinder provider = null;
    try {
        TestLoggerFinder.sequencer.incrementAndGet();
        provider = LoggerFinder.getLoggerFinder();
    } catch(AccessControlException a) {
        throw a;
    }
    ErrorStream.errorStream.store();
    System.out.println("*** Actual LoggerFinder class is: " + provider.getClass().getName());
    expectedClass.cast(provider);
    return TestLoggerFinder.class.cast(provider);
}
 

static void checkLogEvent(LoggerFinder provider, String desc,
        LogEvent expected) {
    LogEvent actual =  eventQueue.poll();
    if (!expected.equals(actual)) {
        throw new RuntimeException("mismatch for " + desc
                + "\n\texpected=" + expected
                + "\n\t  actual=" + actual);
    } else {
        verbose("Got expected results for "
                + desc + "\n\t" + expected);
    }
}
 

static void checkLogEvent(LoggerFinder provider, String desc,
        LogEvent expected) {
    LogEvent actual =  eventQueue.poll();
    if (!expected.equals(actual)) {
        throw new RuntimeException("mismatch for " + desc
                + "\n\texpected=" + expected
                + "\n\t  actual=" + actual);
    } else {
        verbose("Got expected results for "
                + desc + "\n\t" + expected);
    }
}
 

static Logger getLogger(LoggerFinder provider, String name, ResourceBundle bundle, Module caller) {
    if (getClassLoader(caller) != null) {
        return System.getLogger(name,bundle);
    } else {
        return provider.getLocalizedLogger(name, bundle, caller);
    }
}
 

static void checkLogEvent(LoggerFinder provider, String desc,
        LogEvent expected) {
    LogEvent actual =  eventQueue.poll();
    if (!expected.equals(actual)) {
        throw new RuntimeException("mismatch for " + desc
                + "\n\texpected=" + expected
                + "\n\t  actual=" + actual);
    } else {
        verbose("Got expected results for "
                + desc + "\n\t" + expected);
    }
}
 

static void checkLogEvent(LoggerFinder provider, String desc,
        LogEvent expected) {
    LogEvent actual =  eventQueue.poll();
    if (!expected.equals(actual)) {
        throw new RuntimeException("mismatch for " + desc
                + "\n\texpected=" + expected
                + "\n\t  actual=" + actual);
    } else {
        verbose("Got expected results for "
                + desc + "\n\t" + expected);
    }
}
 

public static void test(LoggerFinder provider, boolean hasRequiredPermissions,
        java.util.logging.Logger appSink, java.util.logging.Logger sysSink) throws Exception {

    // No way to give a resource bundle to a platform logger.
    // ResourceBundle loggerBundle = ResourceBundle.getBundle(MyLoggerBundle.class.getName());
    final Map<PlatformLogger, String> loggerDescMap = new HashMap<>();

    PlatformLogger platform = PlatformLogger.getLogger("foo");
    loggerDescMap.put(platform, "PlatformLogger.getLogger(\"foo\")");

    testLogger(provider, loggerDescMap, "foo", null, platform, sysSink);
}
 

public static void main(String[] args) throws Exception {
    LoggerFinder provider = LoggerFinder.getLoggerFinder();
    java.util.logging.Logger appSink = LoggingProviderImpl.getLogManagerAccess()
            .demandLoggerFor(LogManager.getLogManager(), "foo",
                    DefaultPlatformLoggerTest.class.getModule());
    java.util.logging.Logger sysSink = LoggingProviderImpl.getLogManagerAccess()
            .demandLoggerFor(LogManager.getLogManager(),"foo", Thread.class.getModule());
    java.util.logging.Logger sink = Logger.getLogger("foo");
    sink.addHandler(new MyHandler());
    sink.setUseParentHandlers(VERBOSE);

    System.out.println("\n*** Without Security Manager\n");
    test(provider, true, appSink, sysSink);
    System.out.println("Tetscase count: " + sequencer.get());

    Policy.setPolicy(new SimplePolicy(allowAll, allowControl));
    System.setSecurityManager(new SecurityManager());

    System.out.println("\n*** With Security Manager, without permissions\n");
    test(provider, false, appSink, sysSink);
    System.out.println("Tetscase count: " + sequencer.get());

    System.out.println("\n*** With Security Manager, with control permission\n");
    allowControl.get().set(true);
    test(provider, true, appSink, sysSink);

    System.out.println("\nPASSED: Tested " + sequencer.get() + " cases.");
}
 

@Override
public LoggingBackend run() {
    final Iterator<LoggerFinder> iterator =
        ServiceLoader.load(LoggerFinder.class, ClassLoader.getSystemClassLoader())
        .iterator();
    if (iterator.hasNext()) {
        return LoggingBackend.CUSTOM; // Custom Logger Provider is registered
    }
    // No custom logger provider: we will be using the default
    // backend.
    final Iterator<DefaultLoggerFinder> iterator2 =
        ServiceLoader.loadInstalled(DefaultLoggerFinder.class)
        .iterator();
    if (iterator2.hasNext()) {
        // LoggingProviderImpl is registered. The default
        // implementation is java.util.logging
        String cname = System.getProperty("java.util.logging.config.class");
        String fname = System.getProperty("java.util.logging.config.file");
        return (cname != null || fname != null)
            ? LoggingBackend.JUL_WITH_CONFIG
            : LoggingBackend.JUL_DEFAULT;
    } else {
        // SimpleConsoleLogger is used
        return LoggingBackend.NONE;
    }
}
 

@Override
public LoggingBackend run() {
    final Iterator<LoggerFinder> iterator =
        ServiceLoader.load(LoggerFinder.class, ClassLoader.getSystemClassLoader())
        .iterator();
    if (iterator.hasNext()) {
        return LoggingBackend.CUSTOM; // Custom Logger Provider is registered
    }
    // No custom logger provider: we will be using the default
    // backend.
    final Iterator<DefaultLoggerFinder> iterator2 =
        ServiceLoader.loadInstalled(DefaultLoggerFinder.class)
        .iterator();
    if (iterator2.hasNext()) {
        // LoggingProviderImpl is registered. The default
        // implementation is java.util.logging
        String cname = System.getProperty("java.util.logging.config.class");
        String fname = System.getProperty("java.util.logging.config.file");
        return (cname != null || fname != null)
            ? LoggingBackend.JUL_WITH_CONFIG
            : LoggingBackend.JUL_DEFAULT;
    } else {
        // SimpleConsoleLogger is used
        return LoggingBackend.NONE;
    }
}
 

public CustomBackendTester(boolean isSystem,
        Class<? extends java.lang.System.Logger> restrictedTo,
        ResourceBundle localized) {
    super(isSystem, restrictedTo, localized);
    provider = (CustomLoggerFinder)java.lang.System.LoggerFinder.getLoggerFinder();
}
 

public static void main(String[] args) {
    if (args.length == 0)
        args = new String[] {
            "NOSECURITY",
            "NOPERMISSIONS",
            "WITHPERMISSIONS"
        };

    // 1. Obtain destination loggers directly from the LoggerFinder
    //   - LoggerFinder.getLogger("foo", type)
    BaseLoggerFinder provider =
            BaseLoggerFinder.class.cast(LoggerFinder.getLoggerFinder());
    BaseLoggerFinder.LoggerImpl appSink =
            BaseLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", CustomLoggerTest.class.getModule()));
    BaseLoggerFinder.LoggerImpl sysSink =
            BaseLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class.getModule()));


    Stream.of(args).map(TestCases::valueOf).forEach((testCase) -> {
        switch (testCase) {
            case NOSECURITY:
                System.out.println("\n*** Without Security Manager\n");
                test(provider, true, appSink, sysSink);
                System.out.println("Tetscase count: " + sequencer.get());
                break;
            case NOPERMISSIONS:
                System.out.println("\n*** With Security Manager, without permissions\n");
                setSecurityManager();
                test(provider, false, appSink, sysSink);
                System.out.println("Tetscase count: " + sequencer.get());
                break;
            case WITHPERMISSIONS:
                System.out.println("\n*** With Security Manager, with control permission\n");
                setSecurityManager();
                final boolean control = allowControl.get().get();
                try {
                    allowControl.get().set(true);
                    test(provider, true, appSink, sysSink);
                } finally {
                    allowControl.get().set(control);
                }
                break;
            default:
                throw new RuntimeException("Unknown test case: " + testCase);
        }
    });
    System.out.println("\nPASSED: Tested " + sequencer.get() + " cases.");
}
 

@Override
protected LoggerContext getContext() {
    return getContext(StackLocatorUtil.getCallerClass(LoggerFinder.class));
}