test/jdk/java/util/logging/SystemLoggerConfigTest.java - platform/libcore - Git at Google

 /*
  * 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();
     }


 }
	/*
	* 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();
	}



	}