/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.lang.ref.Reference;
import java.security.Permission;
import java.security.Policy;
import java.security.ProtectionDomain;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Properties;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import sun.util.logging.PlatformLogger;
/**
* @test
* @bug 8159245
* @summary Tests configuration of loggers.
* @modules java.logging/sun.util.logging.internal java.base/sun.util.logging
* @run main/othervm SystemLoggerConfigTest NOSECURITY
* @run main/othervm SystemLoggerConfigTest WITHSECURITY
*
* @author danielfuchs
*/
public class SystemLoggerConfigTest {
static Logger createSystemLogger(String name) {
return sun.util.logging.internal.LoggingProviderImpl.getLogManagerAccess()
.demandLoggerFor(LogManager.getLogManager(), name,
Thread.class.getModule());
}
static PlatformLogger createPlatformLogger(String name) {
return PlatformLogger.getLogger(name);
}
private static void assertFalse(boolean value, String msg) {
assertEquals(false, value, msg);
}
private static void assertEquals(boolean expected, boolean actual, String msg) {
if (expected != actual) {
throw new AssertionError(msg+": expected: " + expected + " actual: " + actual);
}
}
private static void assertEquals(int expected, int actual, String msg) {
if (expected != actual) {
throw new AssertionError(msg+": expected: " + expected + " actual: " + actual);
}
}
private static void assertEquals(long expected, long actual, String msg) {
if (expected != actual) {
throw new AssertionError(msg+": expected: " + expected + " actual: " + actual);
}
}
private static void assertEquals(Object expected, Object actual, String msg) {
if (!Objects.equals(expected, actual)) {
throw new AssertionError(msg+": expected: " + expected + " actual: " + actual);
}
}
static class TestHandler extends Handler {
private final List<LogRecord> records = new CopyOnWriteArrayList<>();
public TestHandler() {
super();
setLevel(Level.ALL);
}
@Override
public void publish(LogRecord lr) {
records.add(lr);
}
public List<LogRecord> drain() {
List<LogRecord> list = new ArrayList<>(records);
records.clear();
return list;
}
public void close() {
records.clear();
}
public void flush() {
}
}
public static class TestHandler1 extends TestHandler {
final static AtomicLong COUNT = new AtomicLong();
public TestHandler1() {
COUNT.incrementAndGet();
}
}
public static class TestHandler2 extends TestHandler {
final static AtomicLong COUNT = new AtomicLong();
public TestHandler2() {
COUNT.incrementAndGet();
}
}
static enum TestCase { WITHSECURITY, NOSECURITY }
public static void main(String[] args) {
if (args == null || args.length == 0) {
args = Stream.of(TestCase.values())
.map(String::valueOf)
.collect(Collectors.toList())
.toArray(new String[0]);
}
Stream.of(args)
.map(TestCase::valueOf)
.forEach(SystemLoggerConfigTest::launch);
}
public static void launch(TestCase test) {
switch(test) {
case WITHSECURITY:
Policy.setPolicy(new Policy() {
@Override
public boolean implies(ProtectionDomain domain, Permission permission) {
return true;
}
});
System.setSecurityManager(new SecurityManager());
break;
case NOSECURITY:
break;
default:
throw new InternalError("Unexpected enum: " + test);
}
try {
test(test.name(), ".1", ".child");
test(test.name(), ".2", "");
testUpdateConfiguration(test.name(), ".3");
testSetPlatformLevel(test.name(), ".4");
} catch (IOException io) {
throw new UncheckedIOException(io);
}
}
public static void test(String name, String step, String ext)
throws IOException {
System.out.println("\n*** Testing " + name + step + ext);
final String systemName1a = "system.logger.one.a." + name + step + ext;
final String systemName1b = "system.logger.one.b." + name + step + ext;
final String appName1a = "system.logger.one.a." + name + step;
final String appName1b = "system.logger.one.b." + name + step;
final String msg1a = "logger name: " + systemName1a;
final String msg1b = "logger name: " + systemName1b;
final String systemName2 = "system.logger.two." + name + step + ext;
final String appName2 = "system.logger.two." + name + step;
final String msg2 = "logger name: " + systemName2;
final String systemName3 = "system.logger.three." + name + step + ext;
final String appName3 = "system.logger.three." + name + step;
final String msg3 = "logger name: " + systemName3;
List<LogRecord> records;
System.out.println("\n[Case #1] Creating platform logger: " + systemName1a);
PlatformLogger system1a = createPlatformLogger(systemName1a);
System.out.println(" Creating platform logger: " + systemName1b);
PlatformLogger system1b = createPlatformLogger(systemName1b);
System.out.println(" Adding handler on root logger...");
TestHandler test1 = new TestHandler();
Logger.getLogger("").addHandler(test1);
System.out.println(" Creating and configuring app logger: " + appName1a
+ ", " + appName1b);
Logger app1a = Logger.getLogger(appName1a);
app1a.setLevel(Level.INFO);
Logger app1b = Logger.getLogger(appName1b);
app1b.setLevel(Level.INFO);
assertFalse(system1a.isLoggable(PlatformLogger.Level.FINEST),
"Unexpected level for " + system1a);
System.out.println(" Configuring root logger...");
Logger.getLogger("").setLevel(Level.FINEST);
System.out.println(" Logging through system logger: " + systemName1a);
system1a.finest(msg1a);
Reference.reachabilityFence(app1a);
records = test1.drain();
assertEquals(0, records.size(), "Unexpected size for " + records.toString());
System.out.println(" Logging through system logger: " + systemName1b);
system1b.finest(msg1b);
Reference.reachabilityFence(app1b);
records = test1.drain();
assertEquals(0, records.size(), "Unexpected size for " + records.toString());
Logger.getLogger("system.logger.one.a").finest("system.logger.one.a");
records = test1.drain();
assertEquals("system.logger.one.a", records.get(0).getMessage(), "Unexpected message: ");
Logger.getLogger("").setLevel(Level.INFO);
Logger.getLogger("system.logger.one.a").finest("system.logger.one.a");
records = test1.drain();
assertEquals(0, records.size(), "Unexpected size for " + records.toString());
Reference.reachabilityFence(system1a);
Reference.reachabilityFence(system1b);
System.out.println("\n[Case #2] Creating system logger: " + systemName2);
Logger system2 = createSystemLogger(systemName2);
System.out.println(" Creating app logger: " + appName2);
Logger app2 = Logger.getLogger(appName2);
System.out.println(" Configuring app logger...");
TestHandler test2 = new TestHandler();
app2.setLevel(Level.ALL);
app2.setUseParentHandlers(false);
app2.addHandler(test2);
System.out.println(" Logging through system logger: " + systemName2);
system2.finest(msg2);
records = test2.drain();
assertEquals(1, records.size(), "Unexpected size for " + records.toString());
assertEquals(msg2, records.get(0).getMessage(), "Unexpected message: ");
records = test1.drain();
assertEquals(0, records.size(), "Unexpected size for " + records.toString());
Reference.reachabilityFence(app2);
Reference.reachabilityFence(system2);
System.out.println("\n[Case #3] Creating app logger: " + appName3);
Logger app3 = Logger.getLogger(appName3);
System.out.println(" Configuring app logger...");
TestHandler test3 = new TestHandler();
app3.setLevel(Level.ALL);
app3.setUseParentHandlers(false);
app3.addHandler(test3);
System.out.println(" Creating system logger: " + systemName3);
Logger system3 = createSystemLogger(systemName3);
System.out.println(" Logging through system logger: " + systemName3);
system3.finest(msg3);
records = test3.drain();
assertEquals(1, records.size(), "Unexpected size for " + records.toString());
assertEquals(msg3, records.get(0).getMessage(), "Unexpected message: ");
records = test1.drain();
assertEquals(0, records.size(), "Unexpected size for " + records.toString());
Reference.reachabilityFence(app3);
Reference.reachabilityFence(system3);
System.gc();
}
@SuppressWarnings("deprecated")
static void setPlatformLevel(PlatformLogger logger, PlatformLogger.Level level) {
logger.setLevel(level);
}
public static void testSetPlatformLevel(String name, String step) {
System.out.println("\n*** Testing PlatformLogger.setLevel " + name + step);
System.out.println("\n[Case #5] Creating app logger: " + name + step);
// this should return named logger in the global context
Logger foo = Logger.getLogger(name + step);
foo.setLevel(Level.FINE);
System.out.println(" Creating platform logger: " + name + step);
PlatformLogger foo1 = PlatformLogger.getLogger(name + step);
System.out.println(" Configuring platform logger...");
setPlatformLevel(foo1, PlatformLogger.Level.INFO);
System.out.println(" Checking levels...");
assertEquals(foo.getName(), foo1.getName(), "Bad logger names");
// both logger share the same config
assertEquals(foo.getLevel(), Level.INFO, "Bad level for user logger");
assertEquals(foo1.level(), PlatformLogger.Level.INFO,
"Bad level for platform logger");
}
static void updateConfiguration(Properties props) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
props.store(baos, "");
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
LogManager.getLogManager().updateConfiguration(bais, (k) -> (o,n) -> n != null ? n : o);
}
static void readConfiguration(Properties props) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
props.store(baos, "");
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
LogManager.getLogManager().readConfiguration(bais);
}
// Tests that though two loggers exist, only one handler is created for the
// pair when reading configuration.
//
public static void testUpdateConfiguration(String name, String step) throws IOException {
System.out.println("\n*** Testing LogManager.updateConfiguration " + name + step);
final String name1a = "system.logger.one.a." + name + step;
final String name1b = "system.logger.one.b." + name + step;
final String msg1a = "logger name: " + name1a;
final String msg1b = "logger name: " + name1b;
List<LogRecord> records;
TestHandler1.COUNT.set(0);
TestHandler2.COUNT.set(0);
Properties props = new Properties();
props.setProperty(name1a+".handlers", TestHandler1.class.getName());
updateConfiguration(props);
assertEquals(0, TestHandler1.COUNT.get(), "Bad instance count for "
+ TestHandler1.class.getName());
assertEquals(0, TestHandler2.COUNT.get(), "Bad instance count for "
+ TestHandler2.class.getName());
System.out.println("\n[Case #4] Creating app logger: " + name1a);
Logger app1a = Logger.getLogger(name1a);
System.out.println(" Configuring app logger...");
TestHandler test1 = new TestHandler();
app1a.setLevel(Level.ALL);
app1a.setUseParentHandlers(false);
app1a.addHandler(test1);
assertEquals(1, TestHandler1.COUNT.get(), "Bad instance count for "
+ TestHandler1.class.getName());
assertEquals(0, TestHandler2.COUNT.get(), "Bad instance count for "
+ TestHandler2.class.getName());
System.out.println(" Creating system logger: " + name1a);
Logger system1a = createSystemLogger(name1a);
assertEquals(Level.ALL, system1a.getLevel(), "Bad level for system logger " + name1a);
System.out.println(" Logging through system logger: " + name1a);
system1a.finest(msg1a);
records = test1.drain();
assertEquals(1, records.size(), "Unexpected size for " + records.toString());
assertEquals(msg1a, records.get(0).getMessage(), "Unexpected message: ");
records = test1.drain();
assertEquals(0, records.size(), "Unexpected size for " + records.toString());
assertEquals(1, TestHandler1.COUNT.get(), "Bad instance count for "
+ TestHandler1.class.getName());
assertEquals(0, TestHandler2.COUNT.get(), "Bad instance count for "
+ TestHandler2.class.getName());
props.setProperty(name1a+".handlers", TestHandler2.class.getName());
updateConfiguration(props);
assertEquals(1, TestHandler1.COUNT.get(), "Bad instance count for "
+ TestHandler1.class.getName());
assertEquals(1, TestHandler2.COUNT.get(), "Bad instance count for "
+ TestHandler2.class.getName());
updateConfiguration(props);
assertEquals(1, TestHandler1.COUNT.get(), "Bad instance count for "
+ TestHandler1.class.getName());
assertEquals(1, TestHandler2.COUNT.get(), "Bad instance count for "
+ TestHandler2.class.getName());
readConfiguration(props);
assertEquals(1, TestHandler1.COUNT.get(), "Bad instance count for "
+ TestHandler1.class.getName());
// readConfiguration reset handlers but does not recreate them
assertEquals(1, TestHandler2.COUNT.get(), "Bad instance count for "
+ TestHandler2.class.getName());
updateConfiguration(props);
assertEquals(1, TestHandler1.COUNT.get(), "Bad instance count for "
+ TestHandler1.class.getName());
assertEquals(1, TestHandler2.COUNT.get(), "Bad instance count for "
+ TestHandler2.class.getName());
LogManager.getLogManager().reset();
updateConfiguration(props);
assertEquals(1, TestHandler1.COUNT.get(), "Bad instance count for "
+ TestHandler1.class.getName());
assertEquals(2, TestHandler2.COUNT.get(), "Bad instance count for "
+ TestHandler2.class.getName());
props.setProperty(name1a+".handlers",
TestHandler2.class.getName() + "," + TestHandler1.class.getName());
updateConfiguration(props);
assertEquals(2, TestHandler1.COUNT.get(), "Bad instance count for "
+ TestHandler1.class.getName());
assertEquals(3, TestHandler2.COUNT.get(), "Bad instance count for "
+ TestHandler2.class.getName());
Reference.reachabilityFence(app1a);
Reference.reachabilityFence(system1a);
LogManager.getLogManager().readConfiguration();
System.gc();
}
}