test/jdk/java/util/logging/LogManager/Configuration/ParentLoggerWithHandlerGC.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2014, 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.FilePermission;
 import java.io.IOException;
 import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.WeakReference;
 import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.security.CodeSource;
 import java.security.Permission;
 import java.security.PermissionCollection;
 import java.security.Permissions;
 import java.security.Policy;
 import java.security.ProtectionDomain;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Properties;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.Callable;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.logging.FileHandler;
 import java.util.logging.Handler;
 import java.util.logging.LogManager;
 import java.util.logging.Logger;
 import java.util.logging.LoggingPermission;

 /**
  * @test
  * @bug 8060132
  * @summary tests that FileHandlers configured on abstract nodes in logging.properties
  *          will be closed by reset().
  * @run main/othervm ParentLoggerWithHandlerGC UNSECURE
  * @run main/othervm ParentLoggerWithHandlerGC SECURE
  * @author danielfuchs
  * @key randomness
  */
 public class ParentLoggerWithHandlerGC {

     /**
      * We will test the handling of abstract logger nodes with file handlers in
      * two configurations:
      * UNSECURE: No security manager.
      * SECURE: With the security manager present - and the required
      *         permissions granted.
      */
     public static enum TestCase {
         UNSECURE, SECURE;
         public void run(Properties propertyFile) throws Exception {
             System.out.println("Running test case: " + name());
             Configure.setUp(this, propertyFile);
             test(this.name() + " " + propertyFile.getProperty("test.name"), propertyFile);
         }
     }


     private static final String PREFIX =
             "FileHandler-" + UUID.randomUUID() + ".log";
     private static final String userDir = System.getProperty("user.dir", ".");
     private static final boolean userDirWritable = Files.isWritable(Paths.get(userDir));

     static enum ConfigMode { DEFAULT, ENSURE_CLOSE_ON_RESET_TRUE, ENSURE_CLOSE_ON_RESET_FALSE }

     private static final List<Properties> properties;
     static {
         Properties props1 = new Properties();
         props1.setProperty("test.name", "parent logger with handler");
         props1.setProperty("test.config.mode", ConfigMode.DEFAULT.name());
         props1.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
         props1.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
         props1.setProperty(FileHandler.class.getName() + ".level", "ALL");
         props1.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
         props1.setProperty("com.foo.handlers", FileHandler.class.getName());
         props1.setProperty("com.bar.level", "FINEST");

         Properties props2 = new Properties();
         props2.setProperty("test.name", "parent logger with handler");
         props2.setProperty("test.config.mode", ConfigMode.ENSURE_CLOSE_ON_RESET_TRUE.name());
         props2.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
         props2.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
         props2.setProperty(FileHandler.class.getName() + ".level", "ALL");
         props2.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
         props2.setProperty("com.foo.handlers", FileHandler.class.getName());
         props2.setProperty("com.foo.handlers.ensureCloseOnReset", "true");
         props2.setProperty("com.bar.level", "FINEST");

         Properties props3 = new Properties();
         props3.setProperty("test.name", "parent logger with handler");
         props3.setProperty("test.config.mode", ConfigMode.ENSURE_CLOSE_ON_RESET_FALSE.name());
         props3.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
         props3.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
         props3.setProperty(FileHandler.class.getName() + ".level", "ALL");
         props3.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
         props3.setProperty("com.foo.handlers", FileHandler.class.getName());
         props3.setProperty("com.foo.handlers.ensureCloseOnReset", "false");
         props3.setProperty("com.bar.level", "FINEST");

         properties = Collections.unmodifiableList(Arrays.asList(
                     props1, props2, props3));
     }

     public static void main(String... args) throws Exception {


         if (args == null || args.length == 0) {
             args = new String[] {
                 TestCase.UNSECURE.name(),
                 TestCase.SECURE.name(),
             };
         }

         try {
             for (String testName : args) {
                 for (Properties propertyFile : properties) {
                     TestCase test = TestCase.valueOf(testName);
                     test.run(propertyFile);
                 }
             }
         } finally {
             if (userDirWritable) {
                 Configure.doPrivileged(() -> {
                     // cleanup - delete files that have been created
                     try {
                         Files.list(Paths.get(userDir))
                             .filter((f) -> f.toString().contains(PREFIX))
                             .forEach((f) -> {
                                 try {
                                     System.out.println("deleting " + f);
                                     Files.delete(f);
                                 } catch(Throwable t) {
                                     System.err.println("Failed to delete " + f + ": " + t);
                                 }
                             });
                     } catch(Throwable t) {
                         System.err.println("Cleanup failed to list files: " + t);
                         t.printStackTrace();
                     }
                 });
             }
         }
     }

     static class Configure {
         static Policy policy = null;
         static final AtomicBoolean allowAll = new AtomicBoolean(false);
         static void setUp(TestCase test, Properties propertyFile) {
             switch (test) {
                 case SECURE:
                     if (policy == null && System.getSecurityManager() != null) {
                         throw new IllegalStateException("SecurityManager already set");
                     } else if (policy == null) {
                         policy = new SimplePolicy(TestCase.SECURE, allowAll);
                         Policy.setPolicy(policy);
                         System.setSecurityManager(new SecurityManager());
                     }
                     if (System.getSecurityManager() == null) {
                         throw new IllegalStateException("No SecurityManager.");
                     }
                     if (policy == null) {
                         throw new IllegalStateException("policy not configured");
                     }
                     break;
                 case UNSECURE:
                     if (System.getSecurityManager() != null) {
                         throw new IllegalStateException("SecurityManager already set");
                     }
                     break;
                 default:
                     new InternalError("No such testcase: " + test);
             }
             doPrivileged(() -> {
                 try {
                     ByteArrayOutputStream bytes = new ByteArrayOutputStream();
                     propertyFile.store(bytes, propertyFile.getProperty("test.name"));
                     ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());
                     LogManager.getLogManager().readConfiguration(bais);
                 } catch (IOException ex) {
                     throw new RuntimeException(ex);
                 }
             });
         }
         static void doPrivileged(Runnable run) {
             allowAll.set(true);
             try {
                 run.run();
             } finally {
                 allowAll.set(false);
             }
         }
         static <T> T callPrivileged(Callable<T> call) throws Exception {
             allowAll.set(true);
             try {
                 return call.call();
             } finally {
                 allowAll.set(false);
             }
         }
     }

     @FunctionalInterface
     public static interface FileHandlerSupplier {
         public FileHandler test() throws Exception;
     }

     static final class TestAssertException extends RuntimeException {
         TestAssertException(String msg) {
             super(msg);
         }
     }

     private static void assertEquals(long expected, long received, String msg) {
         if (expected != received) {
             throw new TestAssertException("Unexpected result for " + msg
                     + ".\n\texpected: " + expected
                     +  "\n\tactual:   " + received);
         } else {
             System.out.println("Got expected " + msg + ": " + received);
         }
     }


     public static void test(String name, Properties props) throws Exception {
         ConfigMode configMode = ConfigMode.valueOf(props.getProperty("test.config.mode"));
         System.out.println("\nTesting: " + name + " mode=" + configMode);
         if (!userDirWritable) {
             throw new RuntimeException("Not writable: "+userDir);
         }
         switch(configMode) {
             case DEFAULT:
             case ENSURE_CLOSE_ON_RESET_TRUE:
                 testCloseOnResetTrue(name, props); break;
             case ENSURE_CLOSE_ON_RESET_FALSE:
                 testCloseOnResetFalse(name, props); break;
             default:
                 throw new RuntimeException("Unknwown mode: " + configMode);
         }
     }


     // Test a configuration which has either
     // com.foo.handlers.ensureCloseOnReset=true, or where
     // com.foo.handlers.ensureCloseOnReset is not specified.
     public static void testCloseOnResetTrue(String name, Properties props)
             throws Exception {
         Logger fooChild = Logger.getLogger("com.foo.child");
         fooChild.info("hello world");
         Logger barChild = Logger.getLogger("com.bar.child");
         barChild.info("hello world");

         ReferenceQueue<Logger> queue = new ReferenceQueue();
         WeakReference<Logger> fooRef = new WeakReference<>(Logger.getLogger("com.foo"), queue);
         if (fooRef.get() != fooChild.getParent()) {
             throw new RuntimeException("Unexpected parent logger: "
                     + fooChild.getParent() +"\n\texpected: " + fooRef.get());
         }
         WeakReference<Logger> barRef = new WeakReference<>(Logger.getLogger("com.bar"), queue);
         if (barRef.get() != barChild.getParent()) {
             throw new RuntimeException("Unexpected parent logger: "
                     + barChild.getParent() +"\n\texpected: " + barRef.get());
         }
         fooChild = barChild = null;
         Reference<? extends Logger> ref2 = null;
         while ((ref2 = queue.poll()) == null) {
             System.gc();
             Thread.sleep(1000);
         }
         Throwable failed = null;
         try {
             do {
                 if (ref2 != barRef) {
                     throw new RuntimeException("Unexpected reference: "
                             + ref2 +"\n\texpected: " + barRef);
                 }
                 if (ref2.get() != null) {
                     throw new RuntimeException("Referent not cleared: "
                             + ref2.get());
                 }
                 System.out.println("Got barRef");
                 System.gc();
                 Thread.sleep(1000);
             } while( (ref2 = queue.poll()) != null);
             System.out.println("Parent logger GCed");
         } catch(Throwable t) {
             failed = t;
         } finally {
             final Throwable suppressed = failed;
             Configure.doPrivileged(() -> LogManager.getLogManager().reset());
             Configure.doPrivileged(() -> {
                 try {
                     StringBuilder builder = new StringBuilder();
                     Files.list(Paths.get(userDir))
                         .filter((f) -> f.toString().contains(PREFIX))
                         .filter((f) -> f.toString().endsWith(".lck"))
                         .forEach((f) -> {
                                 builder.append(f.toString()).append('\n');
                         });
                     if (!builder.toString().isEmpty()) {
                         throw new RuntimeException("Lock files not cleaned:\n"
                                 + builder.toString());
                     }
                 } catch(RuntimeException | Error x) {
                     if (suppressed != null) x.addSuppressed(suppressed);
                     throw x;
                 } catch(Exception x) {
                     if (suppressed != null) x.addSuppressed(suppressed);
                     throw new RuntimeException(x);
                 }
             });
             while ((ref2 = queue.poll()) == null) {
                 System.gc();
                 Thread.sleep(1000);
             }
             if (ref2 != fooRef) {
                 throw new RuntimeException("Unexpected reference: "
                         + ref2 +"\n\texpected: " + fooRef);
             }
             if (ref2.get() != null) {
                 throw new RuntimeException("Referent not cleared: " + ref2.get());
             }
             System.out.println("Got fooRef after reset()");

         }
         if (failed != null) {
             // should rarely happen...
             throw new RuntimeException(failed);
         }

     }

     private static Handler getHandlerToClose() throws Exception {
         return Configure.callPrivileged(
                 () -> Logger.getLogger("com.foo.child").getParent().getHandlers()[0]);
     }

     // Test a configuration which has com.foo.handlers.ensureCloseOnReset=false
     public static void testCloseOnResetFalse(String name, Properties props)
             throws Exception {
         Logger fooChild = Logger.getLogger("com.foo.child");
         fooChild.info("hello world");
         Logger barChild = Logger.getLogger("com.bar.child");
         barChild.info("hello world");

         Handler toClose = getHandlerToClose();

         ReferenceQueue<Logger> queue = new ReferenceQueue();
         WeakReference<Logger> fooRef = new WeakReference<>(Logger.getLogger("com.foo"), queue);
         if (fooRef.get() != fooChild.getParent()) {
             throw new RuntimeException("Unexpected parent logger: "
                     + fooChild.getParent() +"\n\texpected: " + fooRef.get());
         }
         WeakReference<Logger> barRef = new WeakReference<>(Logger.getLogger("com.bar"), queue);
         if (barRef.get() != barChild.getParent()) {
             throw new RuntimeException("Unexpected parent logger: "
                     + barChild.getParent() +"\n\texpected: " + barRef.get());
         }
         fooChild = barChild = null;
         Reference<? extends Logger> ref2 = null;
         Set<WeakReference<Logger>> expectedRefs = new HashSet<>(Arrays.asList(fooRef, barRef));
         Throwable failed = null;
         try {
             int l=0;
             while (failed == null && !expectedRefs.isEmpty()) {
                 int max = 60;
                 while ((ref2 = queue.poll()) == null) {
                     if (l > 0 && max-- <= 0) {
                         throw new RuntimeException("Logger #2 not GC'ed!"
                                 + " max too short (max=60) or "
                                 + "com.foo.handlers.ensureCloseOnReset=false"
                                 + " does not work");
                     }
                     System.gc();
                     Thread.sleep(1000);
                 }
                 do {
                     if (!expectedRefs.contains(ref2)) {
                         throw new RuntimeException("Unexpected reference: "
                                 + ref2 +"\n\texpected: " + expectedRefs);
                     }
                     if (ref2.get() != null) {
                         throw new RuntimeException("Referent not cleared: "
                                 + ref2.get());
                     }
                     expectedRefs.remove(ref2);
                     System.out.println("Got "+
                             (ref2 == barRef ? "barRef"
                                     : (ref2 == fooRef ? "fooRef"
                                             : ref2.toString())));
                     System.gc();
                     Thread.sleep(1000);
                     System.out.println("Logger #" + (++l) + " GCed");
                 } while( (ref2 = queue.poll()) != null);
             }
         } catch(Throwable t) {
             failed = t;
         } finally {
             final Throwable suppressed = failed;
             Configure.doPrivileged(() -> LogManager.getLogManager().reset());
             Configure.doPrivileged(() -> {
                 try {
                     toClose.close();
                     StringBuilder builder = new StringBuilder();
                     Files.list(Paths.get(userDir))
                         .filter((f) -> f.toString().contains(PREFIX))
                         .filter((f) -> f.toString().endsWith(".lck"))
                         .forEach((f) -> {
                                 builder.append(f.toString()).append('\n');
                         });
                     if (!builder.toString().isEmpty()) {
                         throw new RuntimeException("Lock files not cleaned:\n" + builder.toString());
                     }
                 } catch(RuntimeException | Error x) {
                     if (suppressed != null) x.addSuppressed(suppressed);
                     throw x;
                 } catch(Exception x) {
                     if (suppressed != null) x.addSuppressed(suppressed);
                     throw new RuntimeException(x);
                 }
             });
         }
         if (failed != null) {
             // should rarely happen...
             throw new RuntimeException(failed);
         }

     }


     static final class PermissionsBuilder {
         final Permissions perms;
         public PermissionsBuilder() {
             this(new Permissions());
         }
         public PermissionsBuilder(Permissions perms) {
             this.perms = perms;
         }
         public PermissionsBuilder add(Permission p) {
             perms.add(p);
             return this;
         }
         public PermissionsBuilder addAll(PermissionCollection col) {
             if (col != null) {
                 for (Enumeration<Permission> e = col.elements(); e.hasMoreElements(); ) {
                     perms.add(e.nextElement());
                 }
             }
             return this;
         }
         public Permissions toPermissions() {
             final PermissionsBuilder builder = new PermissionsBuilder();
             builder.addAll(perms);
             return builder.perms;
         }
     }

     public static class SimplePolicy extends Policy {

         final Permissions permissions;
         final Permissions allPermissions;
         final AtomicBoolean allowAll;
         public SimplePolicy(TestCase test, AtomicBoolean allowAll) {
             this.allowAll = allowAll;
             permissions = new Permissions();
             permissions.add(new LoggingPermission("control", null));
             permissions.add(new FilePermission(PREFIX+".lck", "read,write,delete"));
             permissions.add(new FilePermission(PREFIX, "read,write"));

             // these are used for configuring the test itself...
             allPermissions = new Permissions();
             allPermissions.add(new java.security.AllPermission());

         }

         @Override
         public boolean implies(ProtectionDomain domain, Permission permission) {
             if (allowAll.get()) return allPermissions.implies(permission);
             return permissions.implies(permission);
         }

         @Override
         public PermissionCollection getPermissions(CodeSource codesource) {
             return new PermissionsBuilder().addAll(allowAll.get()
                     ? allPermissions : permissions).toPermissions();
         }

         @Override
         public PermissionCollection getPermissions(ProtectionDomain domain) {
             return new PermissionsBuilder().addAll(allowAll.get()
                     ? allPermissions : permissions).toPermissions();
         }
     }

 }
	/*
	* Copyright (c) 2014, 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.FilePermission;
	import java.io.IOException;
	import java.lang.ref.Reference;
	import java.lang.ref.ReferenceQueue;
	import java.lang.ref.WeakReference;
	import java.nio.file.Files;
	import java.nio.file.Paths;
	import java.security.CodeSource;
	import java.security.Permission;
	import java.security.PermissionCollection;
	import java.security.Permissions;
	import java.security.Policy;
	import java.security.ProtectionDomain;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.Enumeration;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Properties;
	import java.util.Set;
	import java.util.UUID;
	import java.util.concurrent.Callable;
	import java.util.concurrent.atomic.AtomicBoolean;
	import java.util.logging.FileHandler;
	import java.util.logging.Handler;
	import java.util.logging.LogManager;
	import java.util.logging.Logger;
	import java.util.logging.LoggingPermission;

	/**
	* @test
	* @bug 8060132
	* @summary tests that FileHandlers configured on abstract nodes in logging.properties
	* will be closed by reset().
	* @run main/othervm ParentLoggerWithHandlerGC UNSECURE
	* @run main/othervm ParentLoggerWithHandlerGC SECURE
	* @author danielfuchs
	* @key randomness
	*/
	public class ParentLoggerWithHandlerGC {

	/**
	* We will test the handling of abstract logger nodes with file handlers in
	* two configurations:
	* UNSECURE: No security manager.
	* SECURE: With the security manager present - and the required
	* permissions granted.
	*/
	public static enum TestCase {
	UNSECURE, SECURE;
	public void run(Properties propertyFile) throws Exception {
	System.out.println("Running test case: " + name());
	Configure.setUp(this, propertyFile);
	test(this.name() + " " + propertyFile.getProperty("test.name"), propertyFile);
	}
	}


	private static final String PREFIX =
	"FileHandler-" + UUID.randomUUID() + ".log";
	private static final String userDir = System.getProperty("user.dir", ".");
	private static final boolean userDirWritable = Files.isWritable(Paths.get(userDir));

	static enum ConfigMode { DEFAULT, ENSURE_CLOSE_ON_RESET_TRUE, ENSURE_CLOSE_ON_RESET_FALSE }

	private static final List<Properties> properties;
	static {
	Properties props1 = new Properties();
	props1.setProperty("test.name", "parent logger with handler");
	props1.setProperty("test.config.mode", ConfigMode.DEFAULT.name());
	props1.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
	props1.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
	props1.setProperty(FileHandler.class.getName() + ".level", "ALL");
	props1.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
	props1.setProperty("com.foo.handlers", FileHandler.class.getName());
	props1.setProperty("com.bar.level", "FINEST");

	Properties props2 = new Properties();
	props2.setProperty("test.name", "parent logger with handler");
	props2.setProperty("test.config.mode", ConfigMode.ENSURE_CLOSE_ON_RESET_TRUE.name());
	props2.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
	props2.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
	props2.setProperty(FileHandler.class.getName() + ".level", "ALL");
	props2.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
	props2.setProperty("com.foo.handlers", FileHandler.class.getName());
	props2.setProperty("com.foo.handlers.ensureCloseOnReset", "true");
	props2.setProperty("com.bar.level", "FINEST");

	Properties props3 = new Properties();
	props3.setProperty("test.name", "parent logger with handler");
	props3.setProperty("test.config.mode", ConfigMode.ENSURE_CLOSE_ON_RESET_FALSE.name());
	props3.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
	props3.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
	props3.setProperty(FileHandler.class.getName() + ".level", "ALL");
	props3.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
	props3.setProperty("com.foo.handlers", FileHandler.class.getName());
	props3.setProperty("com.foo.handlers.ensureCloseOnReset", "false");
	props3.setProperty("com.bar.level", "FINEST");

	properties = Collections.unmodifiableList(Arrays.asList(
	props1, props2, props3));
	}

	public static void main(String... args) throws Exception {


	if (args == null \|\| args.length == 0) {
	args = new String[] {
	TestCase.UNSECURE.name(),
	TestCase.SECURE.name(),
	};
	}

	try {
	for (String testName : args) {
	for (Properties propertyFile : properties) {
	TestCase test = TestCase.valueOf(testName);
	test.run(propertyFile);
	}
	}
	} finally {
	if (userDirWritable) {
	Configure.doPrivileged(() -> {
	// cleanup - delete files that have been created
	try {
	Files.list(Paths.get(userDir))
	.filter((f) -> f.toString().contains(PREFIX))
	.forEach((f) -> {
	try {
	System.out.println("deleting " + f);
	Files.delete(f);
	} catch(Throwable t) {
	System.err.println("Failed to delete " + f + ": " + t);
	}
	});
	} catch(Throwable t) {
	System.err.println("Cleanup failed to list files: " + t);
	t.printStackTrace();
	}
	});
	}
	}
	}

	static class Configure {
	static Policy policy = null;
	static final AtomicBoolean allowAll = new AtomicBoolean(false);
	static void setUp(TestCase test, Properties propertyFile) {
	switch (test) {
	case SECURE:
	if (policy == null && System.getSecurityManager() != null) {
	throw new IllegalStateException("SecurityManager already set");
	} else if (policy == null) {
	policy = new SimplePolicy(TestCase.SECURE, allowAll);
	Policy.setPolicy(policy);
	System.setSecurityManager(new SecurityManager());
	}
	if (System.getSecurityManager() == null) {
	throw new IllegalStateException("No SecurityManager.");
	}
	if (policy == null) {
	throw new IllegalStateException("policy not configured");
	}
	break;
	case UNSECURE:
	if (System.getSecurityManager() != null) {
	throw new IllegalStateException("SecurityManager already set");
	}
	break;
	default:
	new InternalError("No such testcase: " + test);
	}
	doPrivileged(() -> {
	try {
	ByteArrayOutputStream bytes = new ByteArrayOutputStream();
	propertyFile.store(bytes, propertyFile.getProperty("test.name"));
	ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());
	LogManager.getLogManager().readConfiguration(bais);
	} catch (IOException ex) {
	throw new RuntimeException(ex);
	}
	});
	}
	static void doPrivileged(Runnable run) {
	allowAll.set(true);
	try {
	run.run();
	} finally {
	allowAll.set(false);
	}
	}
	static <T> T callPrivileged(Callable<T> call) throws Exception {
	allowAll.set(true);
	try {
	return call.call();
	} finally {
	allowAll.set(false);
	}
	}
	}

	@FunctionalInterface
	public static interface FileHandlerSupplier {
	public FileHandler test() throws Exception;
	}

	static final class TestAssertException extends RuntimeException {
	TestAssertException(String msg) {
	super(msg);
	}
	}

	private static void assertEquals(long expected, long received, String msg) {
	if (expected != received) {
	throw new TestAssertException("Unexpected result for " + msg
	+ ".\n\texpected: " + expected
	+ "\n\tactual: " + received);
	} else {
	System.out.println("Got expected " + msg + ": " + received);
	}
	}


	public static void test(String name, Properties props) throws Exception {
	ConfigMode configMode = ConfigMode.valueOf(props.getProperty("test.config.mode"));
	System.out.println("\nTesting: " + name + " mode=" + configMode);
	if (!userDirWritable) {
	throw new RuntimeException("Not writable: "+userDir);
	}
	switch(configMode) {
	case DEFAULT:
	case ENSURE_CLOSE_ON_RESET_TRUE:
	testCloseOnResetTrue(name, props); break;
	case ENSURE_CLOSE_ON_RESET_FALSE:
	testCloseOnResetFalse(name, props); break;
	default:
	throw new RuntimeException("Unknwown mode: " + configMode);
	}
	}


	// Test a configuration which has either
	// com.foo.handlers.ensureCloseOnReset=true, or where
	// com.foo.handlers.ensureCloseOnReset is not specified.
	public static void testCloseOnResetTrue(String name, Properties props)
	throws Exception {
	Logger fooChild = Logger.getLogger("com.foo.child");
	fooChild.info("hello world");
	Logger barChild = Logger.getLogger("com.bar.child");
	barChild.info("hello world");

	ReferenceQueue<Logger> queue = new ReferenceQueue();
	WeakReference<Logger> fooRef = new WeakReference<>(Logger.getLogger("com.foo"), queue);
	if (fooRef.get() != fooChild.getParent()) {
	throw new RuntimeException("Unexpected parent logger: "
	+ fooChild.getParent() +"\n\texpected: " + fooRef.get());
	}
	WeakReference<Logger> barRef = new WeakReference<>(Logger.getLogger("com.bar"), queue);
	if (barRef.get() != barChild.getParent()) {
	throw new RuntimeException("Unexpected parent logger: "
	+ barChild.getParent() +"\n\texpected: " + barRef.get());
	}
	fooChild = barChild = null;
	Reference<? extends Logger> ref2 = null;
	while ((ref2 = queue.poll()) == null) {
	System.gc();
	Thread.sleep(1000);
	}
	Throwable failed = null;
	try {
	do {
	if (ref2 != barRef) {
	throw new RuntimeException("Unexpected reference: "
	+ ref2 +"\n\texpected: " + barRef);
	}
	if (ref2.get() != null) {
	throw new RuntimeException("Referent not cleared: "
	+ ref2.get());
	}
	System.out.println("Got barRef");
	System.gc();
	Thread.sleep(1000);
	} while( (ref2 = queue.poll()) != null);
	System.out.println("Parent logger GCed");
	} catch(Throwable t) {
	failed = t;
	} finally {
	final Throwable suppressed = failed;
	Configure.doPrivileged(() -> LogManager.getLogManager().reset());
	Configure.doPrivileged(() -> {
	try {
	StringBuilder builder = new StringBuilder();
	Files.list(Paths.get(userDir))
	.filter((f) -> f.toString().contains(PREFIX))
	.filter((f) -> f.toString().endsWith(".lck"))
	.forEach((f) -> {
	builder.append(f.toString()).append('\n');
	});
	if (!builder.toString().isEmpty()) {
	throw new RuntimeException("Lock files not cleaned:\n"
	+ builder.toString());
	}
	} catch(RuntimeException \| Error x) {
	if (suppressed != null) x.addSuppressed(suppressed);
	throw x;
	} catch(Exception x) {
	if (suppressed != null) x.addSuppressed(suppressed);
	throw new RuntimeException(x);
	}
	});
	while ((ref2 = queue.poll()) == null) {
	System.gc();
	Thread.sleep(1000);
	}
	if (ref2 != fooRef) {
	throw new RuntimeException("Unexpected reference: "
	+ ref2 +"\n\texpected: " + fooRef);
	}
	if (ref2.get() != null) {
	throw new RuntimeException("Referent not cleared: " + ref2.get());
	}
	System.out.println("Got fooRef after reset()");

	}
	if (failed != null) {
	// should rarely happen...
	throw new RuntimeException(failed);
	}

	}

	private static Handler getHandlerToClose() throws Exception {
	return Configure.callPrivileged(
	() -> Logger.getLogger("com.foo.child").getParent().getHandlers()[0]);
	}

	// Test a configuration which has com.foo.handlers.ensureCloseOnReset=false
	public static void testCloseOnResetFalse(String name, Properties props)
	throws Exception {
	Logger fooChild = Logger.getLogger("com.foo.child");
	fooChild.info("hello world");
	Logger barChild = Logger.getLogger("com.bar.child");
	barChild.info("hello world");

	Handler toClose = getHandlerToClose();

	ReferenceQueue<Logger> queue = new ReferenceQueue();
	WeakReference<Logger> fooRef = new WeakReference<>(Logger.getLogger("com.foo"), queue);
	if (fooRef.get() != fooChild.getParent()) {
	throw new RuntimeException("Unexpected parent logger: "
	+ fooChild.getParent() +"\n\texpected: " + fooRef.get());
	}
	WeakReference<Logger> barRef = new WeakReference<>(Logger.getLogger("com.bar"), queue);
	if (barRef.get() != barChild.getParent()) {
	throw new RuntimeException("Unexpected parent logger: "
	+ barChild.getParent() +"\n\texpected: " + barRef.get());
	}
	fooChild = barChild = null;
	Reference<? extends Logger> ref2 = null;
	Set<WeakReference<Logger>> expectedRefs = new HashSet<>(Arrays.asList(fooRef, barRef));
	Throwable failed = null;
	try {
	int l=0;
	while (failed == null && !expectedRefs.isEmpty()) {
	int max = 60;
	while ((ref2 = queue.poll()) == null) {
	if (l > 0 && max-- <= 0) {
	throw new RuntimeException("Logger #2 not GC'ed!"
	+ " max too short (max=60) or "
	+ "com.foo.handlers.ensureCloseOnReset=false"
	+ " does not work");
	}
	System.gc();
	Thread.sleep(1000);
	}
	do {
	if (!expectedRefs.contains(ref2)) {
	throw new RuntimeException("Unexpected reference: "
	+ ref2 +"\n\texpected: " + expectedRefs);
	}
	if (ref2.get() != null) {
	throw new RuntimeException("Referent not cleared: "
	+ ref2.get());
	}
	expectedRefs.remove(ref2);
	System.out.println("Got "+
	(ref2 == barRef ? "barRef"
	: (ref2 == fooRef ? "fooRef"
	: ref2.toString())));
	System.gc();
	Thread.sleep(1000);
	System.out.println("Logger #" + (++l) + " GCed");
	} while( (ref2 = queue.poll()) != null);
	}
	} catch(Throwable t) {
	failed = t;
	} finally {
	final Throwable suppressed = failed;
	Configure.doPrivileged(() -> LogManager.getLogManager().reset());
	Configure.doPrivileged(() -> {
	try {
	toClose.close();
	StringBuilder builder = new StringBuilder();
	Files.list(Paths.get(userDir))
	.filter((f) -> f.toString().contains(PREFIX))
	.filter((f) -> f.toString().endsWith(".lck"))
	.forEach((f) -> {
	builder.append(f.toString()).append('\n');
	});
	if (!builder.toString().isEmpty()) {
	throw new RuntimeException("Lock files not cleaned:\n" + builder.toString());
	}
	} catch(RuntimeException \| Error x) {
	if (suppressed != null) x.addSuppressed(suppressed);
	throw x;
	} catch(Exception x) {
	if (suppressed != null) x.addSuppressed(suppressed);
	throw new RuntimeException(x);
	}
	});
	}
	if (failed != null) {
	// should rarely happen...
	throw new RuntimeException(failed);
	}

	}


	static final class PermissionsBuilder {
	final Permissions perms;
	public PermissionsBuilder() {
	this(new Permissions());
	}
	public PermissionsBuilder(Permissions perms) {
	this.perms = perms;
	}
	public PermissionsBuilder add(Permission p) {
	perms.add(p);
	return this;
	}
	public PermissionsBuilder addAll(PermissionCollection col) {
	if (col != null) {
	for (Enumeration<Permission> e = col.elements(); e.hasMoreElements(); ) {
	perms.add(e.nextElement());
	}
	}
	return this;
	}
	public Permissions toPermissions() {
	final PermissionsBuilder builder = new PermissionsBuilder();
	builder.addAll(perms);
	return builder.perms;
	}
	}

	public static class SimplePolicy extends Policy {

	final Permissions permissions;
	final Permissions allPermissions;
	final AtomicBoolean allowAll;
	public SimplePolicy(TestCase test, AtomicBoolean allowAll) {
	this.allowAll = allowAll;
	permissions = new Permissions();
	permissions.add(new LoggingPermission("control", null));
	permissions.add(new FilePermission(PREFIX+".lck", "read,write,delete"));
	permissions.add(new FilePermission(PREFIX, "read,write"));

	// these are used for configuring the test itself...
	allPermissions = new Permissions();
	allPermissions.add(new java.security.AllPermission());

	}

	@Override
	public boolean implies(ProtectionDomain domain, Permission permission) {
	if (allowAll.get()) return allPermissions.implies(permission);
	return permissions.implies(permission);
	}

	@Override
	public PermissionCollection getPermissions(CodeSource codesource) {
	return new PermissionsBuilder().addAll(allowAll.get()
	? allPermissions : permissions).toPermissions();
	}

	@Override
	public PermissionCollection getPermissions(ProtectionDomain domain) {
	return new PermissionsBuilder().addAll(allowAll.get()
	? allPermissions : permissions).toPermissions();
	}
	}

	}