changeset 12869:d1aa33d3720c

8033661: readConfiguration does not cleanly reinitialize the logging system Summary: two new updateConfiguration methods have been added to LogManager: call updateConfiguration to update a configuration *after* the LogManager is initialized. Reviewed-by: mchung
author dfuchs
date Mon, 12 Oct 2015 20:13:22 +0200
parents de8723d4d615
children 640d543aea86
files src/java.logging/share/classes/java/util/logging/LogManager.java test/java/util/logging/LogManager/Configuration/updateConfiguration/HandlersOnComplexResetUpdate.java test/java/util/logging/LogManager/Configuration/updateConfiguration/HandlersOnComplexUpdate.java test/java/util/logging/LogManager/Configuration/updateConfiguration/SimpleUpdateConfigWithInputStreamTest.java test/java/util/logging/LogManager/Configuration/updateConfiguration/SimpleUpdateConfigurationTest.java test/java/util/logging/LogManager/Configuration/updateConfiguration/UpdateConfigurationTest.java
diffstat 6 files changed, 3892 insertions(+), 88 deletions(-) [+]
line wrap: on
line diff
--- a/src/java.logging/share/classes/java/util/logging/LogManager.java	Mon Oct 12 17:07:40 2015 +0800
+++ b/src/java.logging/share/classes/java/util/logging/LogManager.java	Mon Oct 12 20:13:22 2015 +0200
@@ -32,8 +32,14 @@
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.WeakReference;
 import java.util.concurrent.ConcurrentHashMap;
+import java.nio.file.Paths;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import jdk.internal.misc.JavaAWTAccess;
 import jdk.internal.misc.SharedSecrets;
 import sun.misc.ManagedLocalsThread;
@@ -57,37 +63,28 @@
  * <p>
  * At startup the LogManager class is located using the
  * java.util.logging.manager system property.
+ *
+ * <h3>LogManager Configuration</h3>
+ *
+ * A LogManager initializes the logging configuration via
+ * the {@link #readConfiguration()} method during LogManager initialization.
+ * By default, LogManager default configuration is used.
+ * The logging configuration read by LogManager must be in the
+ * {@linkplain Properties properties file} format.
  * <p>
  * The LogManager defines two optional system properties that allow control over
- * the initial configuration:
+ * the initial configuration, as specified in the {@link #readConfiguration()}
+ * method:
  * <ul>
  * <li>"java.util.logging.config.class"
  * <li>"java.util.logging.config.file"
  * </ul>
- * These two properties may be specified on the command line to the "java"
+ * <p>
+ * These two system properties may be specified on the command line to the "java"
  * command, or as system property definitions passed to JNI_CreateJavaVM.
  * <p>
- * If the "java.util.logging.config.class" property is set, then the
- * property value is treated as a class name.  The given class will be
- * loaded, an object will be instantiated, and that object's constructor
- * is responsible for reading in the initial configuration.  (That object
- * may use other system properties to control its configuration.)  The
- * alternate configuration class can use {@code readConfiguration(InputStream)}
- * to define properties in the LogManager.
- * <p>
- * If "java.util.logging.config.class" property is <b>not</b> set,
- * then the "java.util.logging.config.file" system property can be used
- * to specify a properties file (in java.util.Properties format). The
- * initial logging configuration will be read from this file.
- * <p>
- * If neither of these properties is defined then the LogManager uses its
- * default configuration. The default configuration is typically loaded from the
- * properties file "{@code conf/logging.properties}" in the Java installation
- * directory.
- * <p>
- * The properties for loggers and Handlers will have names starting
- * with the dot-separated name for the handler or logger.
- * <p>
+ * The {@linkplain Properties properties} for loggers and Handlers will have
+ * names starting with the dot-separated name for the handler or logger.<br>
  * The global logging properties may include:
  * <ul>
  * <li>A property "handlers".  This defines a whitespace or comma separated
@@ -788,7 +785,7 @@
             // instantiation of the handler is done in the LogManager.addLogger
             // implementation as a handler class may be only visible to LogManager
             // subclass for the custom log manager case
-            processParentHandlers(logger, name);
+            processParentHandlers(logger, name, VisitedLoggers.NEVER);
 
             // Find the new node and its parent.
             LogNode node = getNode(name);
@@ -836,7 +833,8 @@
 
         // If logger.getUseParentHandlers() returns 'true' and any of the logger's
         // parents have levels or handlers defined, make sure they are instantiated.
-        private void processParentHandlers(final Logger logger, final String name) {
+        private void processParentHandlers(final Logger logger, final String name,
+               Predicate<Logger> visited) {
             final LogManager owner = getOwner();
             AccessController.doPrivileged(new PrivilegedAction<Void>() {
                 @Override
@@ -862,7 +860,9 @@
                     owner.getProperty(pname + ".handlers") != null) {
                     // This pname has a level/handlers definition.
                     // Make sure it exists.
-                    demandLogger(pname, null, null);
+                    if (visited.test(demandLogger(pname, null, null))) {
+                        break;
+                    }
                 }
                 ix = ix2+1;
             }
@@ -942,48 +942,64 @@
     private void loadLoggerHandlers(final Logger logger, final String name,
                                     final String handlersPropertyName)
     {
-        AccessController.doPrivileged(new PrivilegedAction<Object>() {
+        AccessController.doPrivileged(new PrivilegedAction<Void>() {
             @Override
-            public Object run() {
-                String names[] = parseClassNames(handlersPropertyName);
-                final boolean ensureCloseOnReset = names.length > 0
-                    && getBooleanProperty(handlersPropertyName + ".ensureCloseOnReset",true);
-
-                int count = 0;
-                for (String type : names) {
-                    try {
-                        Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(type);
-                        Handler hdl = (Handler) clz.newInstance();
-                        // Check if there is a property defining the
-                        // this handler's level.
-                        String levs = getProperty(type + ".level");
-                        if (levs != null) {
-                            Level l = Level.findLevel(levs);
-                            if (l != null) {
-                                hdl.setLevel(l);
-                            } else {
-                                // Probably a bad level. Drop through.
-                                System.err.println("Can't set level for " + type);
-                            }
-                        }
-                        // Add this Handler to the logger
-                        logger.addHandler(hdl);
-                        if (++count == 1 && ensureCloseOnReset) {
-                            // add this logger to the closeOnResetLoggers list.
-                            closeOnResetLoggers.addIfAbsent(CloseOnReset.create(logger));
-                        }
-                    } catch (Exception ex) {
-                        System.err.println("Can't load log handler \"" + type + "\"");
-                        System.err.println("" + ex);
-                        ex.printStackTrace();
-                    }
-                }
-
+            public Void run() {
+                setLoggerHandlers(logger, name, handlersPropertyName,
+                    createLoggerHandlers(name, handlersPropertyName));
                 return null;
             }
         });
     }
 
+    private void setLoggerHandlers(final Logger logger, final String name,
+                                   final String handlersPropertyName,
+                                   List<Handler> handlers)
+    {
+        final boolean ensureCloseOnReset = ! handlers.isEmpty()
+                    && getBooleanProperty(handlersPropertyName + ".ensureCloseOnReset",true);
+        int count = 0;
+        for (Handler hdl : handlers) {
+            logger.addHandler(hdl);
+            if (++count == 1 && ensureCloseOnReset) {
+                // add this logger to the closeOnResetLoggers list.
+                closeOnResetLoggers.addIfAbsent(CloseOnReset.create(logger));
+            }
+        }
+    }
+
+    private List<Handler> createLoggerHandlers(final String name, final String handlersPropertyName)
+    {
+        String names[] = parseClassNames(handlersPropertyName);
+        List<Handler> handlers = new ArrayList<>(names.length);
+        for (String type : names) {
+            try {
+                Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(type);
+                Handler hdl = (Handler) clz.newInstance();
+                // Check if there is a property defining the
+                // this handler's level.
+                String levs = getProperty(type + ".level");
+                if (levs != null) {
+                    Level l = Level.findLevel(levs);
+                    if (l != null) {
+                        hdl.setLevel(l);
+                    } else {
+                        // Probably a bad level. Drop through.
+                        System.err.println("Can't set level for " + type);
+                    }
+                }
+                // Add this Handler to the logger
+                handlers.add(hdl);
+            } catch (Exception ex) {
+                System.err.println("Can't load log handler \"" + type + "\"");
+                System.err.println("" + ex);
+                ex.printStackTrace();
+            }
+        }
+
+        return handlers;
+    }
+
 
     // loggerRefQueue holds LoggerWeakRef objects for Logger objects
     // that have been GC'ed.
@@ -1242,21 +1258,48 @@
     }
 
     /**
-     * Reinitialize the logging properties and reread the logging configuration.
+     * Reads and initializes the logging configuration.
      * <p>
-     * The same rules are used for locating the configuration properties
-     * as are used at startup.  So normally the logging properties will
-     * be re-read from the same file that was used at startup.
-     * <P>
-     * Any log level definitions in the new configuration file will be
-     * applied using Logger.setLevel(), if the target Logger exists.
+     * If the "java.util.logging.config.class" system property is set, then the
+     * property value is treated as a class name.  The given class will be
+     * loaded, an object will be instantiated, and that object's constructor
+     * is responsible for reading in the initial configuration.  (That object
+     * may use other system properties to control its configuration.)  The
+     * alternate configuration class can use {@code readConfiguration(InputStream)}
+     * to define properties in the LogManager.
+     * <p>
+     * If "java.util.logging.config.class" system property is <b>not</b> set,
+     * then this method will read the initial configuration from a properties
+     * file and calls the {@link #readConfiguration(InputStream)} method to initialize
+     * the configuration. The "java.util.logging.config.file" system property can be used
+     * to specify the properties file that will be read as the initial configuration;
+     * if not set, then the LogManager default configuration is used.
+     * The default configuration is typically loaded from the
+     * properties file "{@code conf/logging.properties}" in the Java installation
+     * directory.
+     *
      * <p>
      * Any {@linkplain #addConfigurationListener registered configuration
      * listener} will be invoked after the properties are read.
      *
-     * @exception  SecurityException  if a security manager exists and if
-     *             the caller does not have LoggingPermission("control").
-     * @exception  IOException if there are IO problems reading the configuration.
+     * @apiNote This {@code readConfiguration} method should only be used for
+     * initializing the configuration during LogManager initialization or
+     * used with the "java.util.logging.config.class" property.
+     * When this method is called after loggers have been created, and
+     * the "java.util.logging.config.class" system property is not set, all
+     * existing loggers will be {@linkplain #reset() reset}. Then any
+     * existing loggers that have a level property specified in the new
+     * configuration stream will be {@linkplain
+     * Logger#setLevel(java.util.logging.Level) set} to the specified log level.
+     * <p>
+     * To properly update the logging configuration, use the
+     * {@link #updateConfiguration(java.util.function.Function)} or
+     * {@link #updateConfiguration(java.io.InputStream, java.util.function.Function)}
+     * methods instead.
+     *
+     * @throws   SecurityException  if a security manager exists and if
+     *              the caller does not have LoggingPermission("control").
+     * @throws   IOException if there are IO problems reading the configuration.
      */
     public void readConfiguration() throws IOException, SecurityException {
         checkPermission();
@@ -1284,20 +1327,24 @@
             }
         }
 
+        String fname = getConfigurationFileName();
+        try (final InputStream in = new FileInputStream(fname)) {
+            final BufferedInputStream bin = new BufferedInputStream(in);
+            readConfiguration(bin);
+        }
+    }
+
+    String getConfigurationFileName() throws IOException {
         String fname = System.getProperty("java.util.logging.config.file");
         if (fname == null) {
             fname = System.getProperty("java.home");
             if (fname == null) {
                 throw new Error("Can't find java.home ??");
             }
-            File f = new File(fname, "conf");
-            f = new File(f, "logging.properties");
-            fname = f.getCanonicalPath();
+            fname = Paths.get(fname, "conf", "logging.properties")
+                    .toAbsolutePath().normalize().toString();
         }
-        try (final InputStream in = new FileInputStream(fname)) {
-            final BufferedInputStream bin = new BufferedInputStream(in);
-            readConfiguration(bin);
-        }
+        return fname;
     }
 
     /**
@@ -1305,9 +1352,17 @@
      * <p>
      * For all named loggers, the reset operation removes and closes
      * all Handlers and (except for the root logger) sets the level
-     * to null.  The root logger's level is set to Level.INFO.
+     * to {@code null}. The root logger's level is set to {@code Level.INFO}.
      *
-     * @exception  SecurityException  if a security manager exists and if
+     * @apiNote Calling this method also clears the LogManager {@linkplain
+     * #getProperty(java.lang.String) properties}. The {@link
+     * #updateConfiguration(java.util.function.Function)
+     * updateConfiguration(Function)} or
+     * {@link #updateConfiguration(java.io.InputStream, java.util.function.Function)
+     * updateConfiguration(InputStream, Function)} method can be used to
+     * properly update to a new configuration.
+     *
+     * @throws  SecurityException  if a security manager exists and if
      *             the caller does not have LoggingPermission("control").
      */
 
@@ -1421,18 +1476,32 @@
     }
 
     /**
-     * Reinitialize the logging properties and reread the logging configuration
-     * from the given stream, which should be in java.util.Properties format.
+     * Reads and initializes the logging configuration from the given input stream.
+     *
+     * <p>
      * Any {@linkplain #addConfigurationListener registered configuration
      * listener} will be invoked after the properties are read.
      * <p>
-     * Any log level definitions in the new configuration file will be
-     * applied using Logger.setLevel(), if the target Logger exists.
+     * @apiNote This {@code readConfiguration} method should only be used for
+     * initializing the configuration during LogManager initialization or
+     * used with the "java.util.logging.config.class" property.
+     * When this method is called after loggers have been created, all
+     * existing loggers will be {@linkplain #reset() reset}. Then any
+     * existing loggers that have a level property specified in the
+     * given input stream will be {@linkplain
+     * Logger#setLevel(java.util.logging.Level) set} to the specified log level.
+     * <p>
+     * To properly update the logging configuration, use the
+     * {@link #updateConfiguration(java.util.function.Function)} or
+     * {@link #updateConfiguration(java.io.InputStream, java.util.function.Function)}
+     * method instead.
      *
-     * @param ins       stream to read properties from
-     * @exception  SecurityException  if a security manager exists and if
+     * @param ins  stream to read properties from
+     * @throws  SecurityException  if a security manager exists and if
      *             the caller does not have LoggingPermission("control").
-     * @exception  IOException if there are problems reading from the stream.
+     * @throws  IOException if there are problems reading from the stream,
+     *             or the given stream is not in the
+     *             {@linkplain java.util.Properties properties file} format.
      */
     public void readConfiguration(InputStream ins) throws IOException, SecurityException {
         checkPermission();
@@ -1506,6 +1575,633 @@
         invokeConfigurationListeners();
     }
 
+    // This enum enumerate the configuration properties that will be
+    // updated on existing loggers when the configuration is updated
+    // with LogManager.updateConfiguration().
+    //
+    // Note that this works properly only for the global LogManager - as
+    // Handler and its subclasses get their configuration from
+    // LogManager.getLogManager().
+    //
+    static enum ConfigProperty {
+        LEVEL(".level"), HANDLERS(".handlers"), USEPARENT(".useParentHandlers");
+        final String suffix;
+        final int length;
+        private ConfigProperty(String suffix) {
+            this.suffix = Objects.requireNonNull(suffix);
+            length = suffix.length();
+        }
+
+        public boolean handleKey(String key) {
+            if (this == HANDLERS && suffix.substring(1).equals(key)) return true;
+            if (this == HANDLERS && suffix.equals(key)) return false;
+            return key.endsWith(suffix);
+        }
+        String key(String loggerName) {
+            if (this == HANDLERS && (loggerName == null || loggerName.isEmpty())) {
+                return suffix.substring(1);
+            }
+            return loggerName + suffix;
+        }
+        String loggerName(String key) {
+            assert key.equals(suffix.substring(1)) && this == HANDLERS || key.endsWith(suffix);
+            if (this == HANDLERS && suffix.substring(1).equals(key)) return "";
+            return key.substring(0, key.length() - length);
+        }
+
+        /**
+         * If the property is one that should be updated on existing loggers by
+         * updateConfiguration, returns the name of the logger for which the
+         * property is configured. Otherwise, returns null.
+         * @param property a property key in 'props'
+         * @return the name of the logger on which the property is to be set,
+         *         if the property is one that should be updated on existing
+         *         loggers, {@code null} otherwise.
+         */
+        static String getLoggerName(String property) {
+            for (ConfigProperty p : ConfigProperty.ALL) {
+                if (p.handleKey(property)) {
+                    return p.loggerName(property);
+                }
+            }
+            return null; // Not a property that should be updated.
+        }
+
+        /**
+         * Find the ConfigProperty corresponding to the given
+         * property key (may find none).
+         * @param property a property key in 'props'
+         * @return An optional containing a ConfigProperty object,
+         *         if the property is one that should be updated on existing
+         *         loggers, empty otherwise.
+         */
+        static Optional<ConfigProperty> find(String property) {
+            return ConfigProperty.ALL.stream()
+                    .filter(p -> p.handleKey(property))
+                    .findFirst();
+         }
+
+        /**
+         * Returns true if the given property is one that should be updated
+         * on existing loggers.
+         * Used to filter property name streams.
+         * @param property a property key from the configuration.
+         * @return true if this property is of interest for updateConfiguration.
+         */
+        static boolean matches(String property) {
+            return find(property).isPresent();
+        }
+
+        /**
+         * Returns true if the new property value is different from the old,
+         * and therefore needs to be updated on existing loggers.
+         * @param k a property key in the configuration
+         * @param previous the old configuration
+         * @param next the new configuration
+         * @return true if the property is changing value between the two
+         *         configurations.
+         */
+        static boolean needsUpdating(String k, Properties previous, Properties next) {
+            final String p = trim(previous.getProperty(k, null));
+            final String n = trim(next.getProperty(k, null));
+            return ! Objects.equals(p,n);
+        }
+
+        /**
+         * Applies the mapping function for the given key to the next
+         * configuration.
+         * If the mapping function is null then this method does nothing.
+         * Otherwise, it calls the mapping function to compute the value
+         * that should be associated with {@code key} in the resulting
+         * configuration, and applies it to {@code next}.
+         * If the mapping function returns {@code null} the key is removed
+         * from {@code next}.
+         *
+         * @param k a property key in the configuration
+         * @param previous the old configuration
+         * @param next the new configuration (modified by this function)
+         * @param remappingFunction the mapping function.
+         */
+        static void merge(String k, Properties previous, Properties next,
+                          BiFunction<String, String, String> mappingFunction) {
+            String p = trim(previous.getProperty(k, null));
+            String n = trim(next.getProperty(k, null));
+            String mapped = trim(mappingFunction.apply(p,n));
+            if (!Objects.equals(n, mapped)) {
+                if (mapped == null) {
+                    next.remove(k);
+                } else {
+                    next.setProperty(k, mapped);
+                }
+            }
+        }
+
+        private static final EnumSet<ConfigProperty> ALL =
+                EnumSet.allOf(ConfigProperty.class);
+    }
+
+    // trim the value if not null.
+    private static String trim(String value) {
+        return value == null ? null : value.trim();
+    }
+
+    /**
+     * An object that keep track of loggers we have already visited.
+     * Used when updating configuration, to avoid processing the same logger
+     * twice.
+     */
+    static final class VisitedLoggers implements Predicate<Logger> {
+        final IdentityHashMap<Logger,Boolean> visited;
+        private VisitedLoggers(IdentityHashMap<Logger,Boolean> visited) {
+            this.visited = visited;
+        }
+        VisitedLoggers() {
+            this(new IdentityHashMap<>());
+        }
+        @Override
+        public boolean test(Logger logger) {
+            return visited != null && visited.put(logger, Boolean.TRUE) != null;
+        }
+        public void clear() {
+            if (visited != null) visited.clear();
+        }
+
+        // An object that considers that no logger has ever been visited.
+        // This is used when processParentHandlers is called from
+        // LoggerContext.addLocalLogger
+        static final VisitedLoggers NEVER = new VisitedLoggers(null);
+    }
+
+
+    /**
+     * Type of the modification for a given property. One of SAME, ADDED, CHANGED,
+     * or REMOVED.
+     */
+    static enum ModType {
+        SAME,    // property had no value in the old and new conf, or had the
+                 // same value in both.
+        ADDED,   // property had no value in the old conf, but has one in the new.
+        CHANGED, // property has a different value in the old conf and the new conf.
+        REMOVED; // property has no value in the new conf, but had one in the old.
+        static ModType of(String previous, String next) {
+            if (previous == null && next != null) {
+                return ADDED;
+            }
+            if (next == null && previous != null) {
+                return REMOVED;
+            }
+            if (!Objects.equals(trim(previous), trim(next))) {
+                return CHANGED;
+            }
+            return SAME;
+        }
+    }
+
+    /**
+     * Updates the logging configuration.
+     * <p>
+     * If the "java.util.logging.config.file" system property is set,
+     * then the property value specifies the properties file to be read
+     * as the new configuration. Otherwise, the LogManager default
+     * configuration is used.
+     * <br>The default configuration is typically loaded from the
+     * properties file "{@code conf/logging.properties}" in the
+     * Java installation directory.
+     * <p>
+     * This method reads the new configuration and calls the {@link
+     * #updateConfiguration(java.io.InputStream, java.util.function.Function)
+     * updateConfiguration(ins, mapper)} method to
+     * update the configuration.
+     *
+     * @apiNote
+     * This method updates the logging configuration from reading
+     * a properties file and ignores the "java.util.logging.config.class"
+     * system property.  The "java.util.logging.config.class" property is
+     * only used by the {@link #readConfiguration()}  method to load a custom
+     * configuration class as an initial configuration.
+     *
+     * @param mapper a functional interface that takes a configuration
+     *   key <i>k</i> and returns a function <i>f(o,n)</i> whose returned
+     *   value will be applied to the resulting configuration. The
+     *   function <i>f</i> may return {@code null} to indicate that the property
+     *   <i>k</i> will not be added to the resulting configuration.
+     *   <br>
+     *   If {@code mapper} is {@code null} then {@code (k) -> ((o, n) -> n)} is
+     *   assumed.
+     *   <br>
+     *   For each <i>k</i>, the mapped function <i>f</i> will
+     *   be invoked with the value associated with <i>k</i> in the old
+     *   configuration (i.e <i>o</i>) and the value associated with
+     *   <i>k</i> in the new configuration (i.e. <i>n</i>).
+     *   <br>A {@code null} value for <i>o</i> or <i>n</i> indicates that no
+     *   value was present for <i>k</i> in the corresponding configuration.
+     *
+     * @throws  SecurityException  if a security manager exists and if
+     *          the caller does not have LoggingPermission("control"), or
+     *          does not have the permissions required to set up the
+     *          configuration (e.g. open file specified for FileHandlers
+     *          etc...)
+     *
+     * @throws  NullPointerException  if {@code mapper} returns a {@code null}
+     *         function when invoked.
+     *
+     * @throws  IOException if there are problems reading from the
+     *          logging configuration file.
+     *
+     * @see #updateConfiguration(java.io.InputStream, java.util.function.Function)
+     */
+    public void updateConfiguration(Function<String, BiFunction<String,String,String>> mapper)
+            throws IOException {
+        checkPermission();
+        ensureLogManagerInitialized();
+        drainLoggerRefQueueBounded();
+
+        String fname = getConfigurationFileName();
+        try (final InputStream in = new FileInputStream(fname)) {
+            final BufferedInputStream bin = new BufferedInputStream(in);
+            updateConfiguration(bin, mapper);
+        }
+    }
+
+    /**
+     * Updates the logging configuration.
+     * <p>
+     * For each configuration key in the {@linkplain
+     * #getProperty(java.lang.String) existing configuration} and
+     * the given input stream configuration, the given {@code mapper} function
+     * is invoked to map from the configuration key to a function,
+     * <i>f(o,n)</i>, that takes the old value and new value and returns
+     * the resulting value to be applied in the resulting configuration,
+     * as specified in the table below.
+     * <p>Let <i>k</i> be a configuration key in the old or new configuration,
+     * <i>o</i> be the old value (i.e. the value associated
+     * with <i>k</i> in the old configuration), <i>n</i> be the
+     * new value (i.e. the value associated with <i>k</i> in the new
+     * configuration), and <i>f</i> be the function returned
+     * by {@code mapper.apply(}<i>k</i>{@code )}: then <i>v = f(o,n)</i> is the
+     * resulting value. If <i>v</i> is not {@code null}, then a property
+     * <i>k</i> with value <i>v</i> will be added to the resulting configuration.
+     * Otherwise, it will be omitted.
+     * <br>A {@code null} value may be passed to function
+     * <i>f</i> to indicate that the corresponding configuration has no
+     * configuration key <i>k</i>.
+     * The function <i>f</i> may return {@code null} to indicate that
+     * there will be no value associated with <i>k</i> in the resulting
+     * configuration.
+     * <p>
+     * If {@code mapper} is {@code null}, then <i>v</i> will be set to
+     * <i>n</i>.
+     * <p>
+     * LogManager {@linkplain #getProperty(java.lang.String) properties} are
+     * updated with the resulting value in the resulting configuration.
+     * <p>
+     * The registered {@linkplain #addConfigurationListener configuration
+     * listeners} will be invoked after the configuration is successfully updated.
+     * <br><br>
+     * <table summary="Updating configuration properties">
+     * <tr>
+     * <th>Property</th>
+     * <th>Resulting Behavior</th>
+     * </tr>
+     * <tr>
+     * <td valign="top">{@code <logger>.level}</td>
+     * <td>
+     * <ul>
+     *   <li>If the resulting configuration defines a level for a logger and
+     *       if the resulting level is different than the level specified in the
+     *       the old configuration, or not specified in
+     *       the old configuration, then if the logger exists or if children for
+     *       that logger exist, the level for that logger will be updated,
+     *       and the change propagated to any existing logger children.
+     *       This may cause the logger to be created, if necessary.
+     *   </li>
+     *   <li>If the old configuration defined a level for a logger, and the
+     *       resulting configuration doesn't, then this change will not be
+     *       propagated to existing loggers, if any.
+     *       To completely replace a configuration - the caller should therefore
+     *       call {@link #reset() reset} to empty the current configuration,
+     *       before calling {@code updateConfiguration}.
+     *   </li>
+     * </ul>
+     * </td>
+     * <tr>
+     * <td valign="top">{@code <logger>.useParentHandlers}</td>
+     * <td>
+     * <ul>
+     *   <li>If either the resulting or the old value for the useParentHandlers
+     *       property is not null, then if the logger exists or if children for
+     *       that logger exist, that logger will be updated to the resulting
+     *       value.
+     *       The value of the useParentHandlers property is the value specified
+     *       in the configuration; if not specified, the default is true.
+     *   </li>
+     * </ul>
+     * </td>
+     * </tr>
+     * <tr>
+     * <td valign="top">{@code <logger>.handlers}</td>
+     * <td>
+     * <ul>
+     *   <li>If the resulting configuration defines a list of handlers for a
+     *       logger, and if the resulting list is different than the list
+     *       specified in the old configuration for that logger (that could be
+     *       empty), then if the logger exists or its children exist, the
+     *       handlers associated with that logger are closed and removed and
+     *       the new handlers will be created per the resulting configuration
+     *       and added to that logger, creating that logger if necessary.
+     *   </li>
+     *   <li>If the old configuration defined some handlers for a logger, and
+     *       the resulting configuration doesn't, if that logger exists,
+     *       its handlers will be removed and closed.
+     *   </li>
+     *   <li>Changing the list of handlers on an existing logger will cause all
+     *       its previous handlers to be removed and closed, regardless of whether
+     *       they had been created from the configuration or programmatically.
+     *       The old handlers will be replaced by new handlers, if any.
+     *   </li>
+     * </ul>
+     * </td>
+     * </tr>
+     * <tr>
+     * <td valign="top">{@code <handler-name>.*}</td>
+     * <td>
+     * <ul>
+     *   <li>Properties configured/changed on handler classes will only affect
+     *       newly created handlers. If a node is configured with the same list
+     *       of handlers in the old and the resulting configuration, then these
+     *       handlers will remain unchanged.
+     *   </li>
+     * </ul>
+     * </td>
+     * </tr>
+     * <tr>
+     * <td valign="top">{@code config} and any other property</td>
+     * <td>
+     * <ul>
+     *   <li>The resulting value for these property will be stored in the
+     *   LogManager properties, but {@code updateConfiguration} will not parse
+     *   or process their values.
+     *   </li>
+     * </ul>
+     * </td>
+     * </tr>
+     * </table>
+     * <p>
+     * <em>Example mapper functions:</em>
+     * <br><br>
+     * <ul>
+     * <li>Replace all logging properties with the new configuration:
+     * <br><br>{@code     (k) -> ((o, n) -> n)}:
+     * <br><br>this is equivalent to passing a null {@code mapper} parameter.
+     * </li>
+     * <li>Merge the new configuration and old configuration and use the
+     * new value if <i>k</i> exists in the new configuration:
+     * <br><br>{@code     (k) -> ((o, n) -> n == null ? o : n)}:
+     * <br><br>as if merging two collections as follows:
+     * {@code result.putAll(oldc); result.putAll(newc)}.<br></li>
+     * <li>Merge the new configuration and old configuration and use the old
+     * value if <i>k</i> exists in the old configuration:
+     * <br><br>{@code     (k) -> ((o, n) -> o == null ? n : o)}:
+     * <br><br>as if merging two collections as follows:
+     * {@code result.putAll(newc); result.putAll(oldc)}.<br></li>
+     * <li>Replace all properties with the new configuration except the handler
+     * property to configure Logger's handler that is not root logger:
+     * <br>
+     * <pre>{@code (k) -> k.endsWith(".handlers")}
+     *      {@code     ? ((o, n) -> (o == null ? n : o))}
+     *      {@code     : ((o, n) -> n)}</pre>
+     * </li>
+     * </ul>
+     * <p>
+     * To completely reinitialize a configuration, an application can first call
+     * {@link #reset() reset} to fully remove the old configuration, followed by
+     * {@code updateConfiguration} to initialize the new configuration.
+     *
+     * @param ins    a stream to read properties from
+     * @param mapper a functional interface that takes a configuration
+     *   key <i>k</i> and returns a function <i>f(o,n)</i> whose returned
+     *   value will be applied to the resulting configuration. The
+     *   function <i>f</i> may return {@code null} to indicate that the property
+     *   <i>k</i> will not be added to the resulting configuration.
+     *   <br>
+     *   If {@code mapper} is {@code null} then {@code (k) -> ((o, n) -> n)} is
+     *   assumed.
+     *   <br>
+     *   For each <i>k</i>, the mapped function <i>f</i> will
+     *   be invoked with the value associated with <i>k</i> in the old
+     *   configuration (i.e <i>o</i>) and the value associated with
+     *   <i>k</i> in the new configuration (i.e. <i>n</i>).
+     *   <br>A {@code null} value for <i>o</i> or <i>n</i> indicates that no
+     *   value was present for <i>k</i> in the corresponding configuration.
+     *
+     * @throws  SecurityException if a security manager exists and if
+     *          the caller does not have LoggingPermission("control"), or
+     *          does not have the permissions required to set up the
+     *          configuration (e.g. open files specified for FileHandlers)
+     *
+     * @throws  NullPointerException if {@code ins} is null or if
+     *          {@code mapper} returns a null function when invoked.
+     *
+     * @throws  IOException if there are problems reading from the stream,
+     *          or the given stream is not in the
+     *          {@linkplain java.util.Properties properties file} format.
+     */
+    public void updateConfiguration(InputStream ins,
+            Function<String, BiFunction<String,String,String>> mapper)
+            throws IOException {
+        checkPermission();
+        ensureLogManagerInitialized();
+        drainLoggerRefQueueBounded();
+
+        final Properties previous;
+        final Set<String> updatePropertyNames;
+        List<LoggerContext> cxs = Collections.emptyList();
+        final VisitedLoggers visited = new VisitedLoggers();
+        final Properties next = new Properties();
+
+        try {
+            // Load the properties
+            next.load(ins);
+        } catch (IllegalArgumentException x) {
+            // props.load may throw an IllegalArgumentException if the stream
+            // contains malformed Unicode escape sequences.
+            // We wrap that in an IOException as updateConfiguration is
+            // specified to throw IOException if there are problems reading
+            // from the stream.
+            // Note: new IOException(x.getMessage(), x) allow us to get a more
+            // concise error message than new IOException(x);
+            throw new IOException(x.getMessage(), x);
+        }
+
+        if (globalHandlersState == STATE_SHUTDOWN) return;
+
+        // exclusive lock: readConfiguration/reset/updateConfiguration can't
+        //           run concurrently.
+        // configurationLock.writeLock().lock();
+        configurationLock.lock();
+        try {
+            if (globalHandlersState == STATE_SHUTDOWN) return;
+            previous = props;
+
+            // Builds a TreeSet of all (old and new) property names.
+            updatePropertyNames =
+                    Stream.concat(previous.stringPropertyNames().stream(),
+                                  next.stringPropertyNames().stream())
+                        .collect(Collectors.toCollection(TreeSet::new));
+
+            if (mapper != null) {
+                // mapper will potentially modify the content of
+                // 'next', so we need to call it before affecting props=next.
+                // give a chance to the mapper to control all
+                // properties - not just those we will reset.
+                updatePropertyNames.stream()
+                        .forEachOrdered(k -> ConfigProperty
+                                .merge(k, previous, next,
+                                       Objects.requireNonNull(mapper.apply(k))));
+            }
+
+            props = next;
+
+            // allKeys will contain all keys:
+            //    - which correspond to a configuration property we are interested in
+            //      (first filter)
+            //    - whose value needs to be updated (because it's new, removed, or
+            //      different) in the resulting configuration (second filter)
+            final Stream<String> allKeys = updatePropertyNames.stream()
+                    .filter(ConfigProperty::matches)
+                    .filter(k -> ConfigProperty.needsUpdating(k, previous, next));
+
+            // Group configuration properties by logger name
+            // We use a TreeMap so that parent loggers will be visited before
+            // child loggers.
+            final Map<String, TreeSet<String>> loggerConfigs =
+                    allKeys.collect(Collectors.groupingBy(ConfigProperty::getLoggerName,
+                                    TreeMap::new,
+                                    Collectors.toCollection(TreeSet::new)));
+
+            if (!loggerConfigs.isEmpty()) {
+                cxs = contexts();
+            }
+            final List<Logger> loggers = cxs.isEmpty()
+                    ? Collections.emptyList() : new ArrayList<>(cxs.size());
+            for (Map.Entry<String, TreeSet<String>> e : loggerConfigs.entrySet()) {
+                // This can be a logger name, or something else...
+                // The only thing we know is that we found a property
+                //    we are interested in.
+                // For instance, if we found x.y.z.level, then x.y.z could be
+                // a logger, but it could also be a handler class...
+                // Anyway...
+                final String name = e.getKey();
+                final Set<String> properties = e.getValue();
+                loggers.clear();
+                for (LoggerContext cx : cxs) {
+                    Logger l = cx.findLogger(name);
+                    if (l != null && !visited.test(l)) {
+                        loggers.add(l);
+                    }
+                }
+                if (loggers.isEmpty()) continue;
+                for (String pk : properties) {
+                    ConfigProperty cp = ConfigProperty.find(pk).get();
+                    String p = previous.getProperty(pk, null);
+                    String n = next.getProperty(pk, null);
+
+                    // Determines the type of modification.
+                    ModType mod = ModType.of(p, n);
+
+                    // mod == SAME means that the two values are equals, there
+                    // is nothing to do. Usually, this should not happen as such
+                    // properties should have been filtered above.
+                    // It could happen however if the properties had
+                    // trailing/leading whitespaces.
+                    if (mod == ModType.SAME) continue;
+
+                    switch (cp) {
+                        case LEVEL:
+                            if (mod == ModType.REMOVED) continue;
+                            Level level = Level.findLevel(trim(n));
+                            if (level != null) {
+                                if (name.isEmpty()) {
+                                    rootLogger.setLevel(level);
+                                }
+                                for (Logger l : loggers) {
+                                    if (!name.isEmpty() || l != rootLogger) {
+                                        l.setLevel(level);
+                                    }
+                                }
+                            }
+                            break;
+                        case USEPARENT:
+                            if (!name.isEmpty()) {
+                                boolean useParent = getBooleanProperty(pk, true);
+                                if (n != null || p != null) {
+                                    // reset the flag only if the previous value
+                                    // or the new value are not null.
+                                    for (Logger l : loggers) {
+                                        l.setUseParentHandlers(useParent);
+                                    }
+                                }
+                            }
+                            break;
+                        case HANDLERS:
+                            List<Handler> hdls = null;
+                            if (name.isEmpty()) {
+                                // special handling for the root logger.
+                                globalHandlersState = STATE_READING_CONFIG;
+                                try {
+                                    closeHandlers(rootLogger);
+                                    globalHandlersState = STATE_UNINITIALIZED;
+                                } catch (Throwable t) {
+                                    globalHandlersState = STATE_INITIALIZED;
+                                    throw t;
+                                }
+                            }
+                            for (Logger l : loggers) {
+                                if (l == rootLogger) continue;
+                                closeHandlers(l);
+                                if (mod == ModType.REMOVED) {
+                                    closeOnResetLoggers.removeIf(c -> c.logger == l);
+                                    continue;
+                                }
+                                if (hdls == null) {
+                                    hdls = name.isEmpty()
+                                            ? Arrays.asList(rootLogger.getHandlers())
+                                            : createLoggerHandlers(name, pk);
+                                }
+                                setLoggerHandlers(l, name, pk, hdls);
+                            }
+                            break;
+                        default: break;
+                    }
+                }
+            }
+        } finally {
+            configurationLock.unlock();
+            visited.clear();
+        }
+
+        // Now ensure that if an existing logger has acquired a new parent
+        // in the configuration, this new parent will be created - if needed,
+        // and added to the context of the existing child.
+        //
+        drainLoggerRefQueueBounded();
+        for (LoggerContext cx : cxs) {
+            for (Enumeration<String> names = cx.getLoggerNames() ; names.hasMoreElements();) {
+                String name = names.nextElement();
+                if (name.isEmpty()) continue;  // don't need to process parents on root.
+                Logger l = cx.findLogger(name);
+                if (l != null && !visited.test(l)) {
+                    // should pass visited here to cut the processing when
+                    // reaching a logger already visited.
+                    cx.processParentHandlers(l, name, visited);
+                }
+            }
+        }
+
+        // We changed the configuration: invoke configuration listeners
+        invokeConfigurationListeners();
+    }
+
     /**
      * Get the value of a logging property.
      * The method returns null if the property is not found.
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/util/logging/LogManager/Configuration/updateConfiguration/HandlersOnComplexResetUpdate.java	Mon Oct 12 20:13:22 2015 +0200
@@ -0,0 +1,548 @@
+/*
+ * Copyright (c) 2015, 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.List;
+import java.util.Properties;
+import java.util.UUID;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.logging.FileHandler;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+import java.util.logging.LoggingPermission;
+
+/**
+ * @test
+ * @bug 8033661
+ * @summary tests that FileHandlers configured on abstract nodes in logging.properties
+ *          will be closed on reset and reopened on updateConfiguration().
+ *          Test a complex reconfiguration where a logger with handlers
+ *          suddenly appears in the hierarchy between a child logger and the
+ *          root logger.
+ * @run main/othervm HandlersOnComplexResetUpdate UNSECURE
+ * @run main/othervm HandlersOnComplexResetUpdate SECURE
+ * @author danielfuchs
+ */
+public class HandlersOnComplexResetUpdate {
+
+    /**
+     * 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(List<Properties> properties) throws Exception {
+            System.out.println("Running test case: " + name());
+            Configure.setUp(this, properties.get(0));
+            test(this.name(), properties);
+        }
+    }
+
+
+    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));
+
+    private static final List<Properties> properties;
+    static {
+        // The test will call reset() and updateConfiguration() with each of these
+        // properties in sequence. The child logger is not released between each
+        // configuration. What is interesting here is mostly what happens between
+        // props4 and props5:
+        //
+        // In step 4 (props4) the configuration defines a handler for the
+        // logger com.foo (the direct parent of com.foo.child - which is the
+        // logger we hold on to).
+        //
+        // In step 5 (props5) the configuration has nothing concerning
+        // 'com.foo', but the handler has been migrated to 'com'.
+        // Since there doesn't exist any logger for 'com' (the previous
+        // configuration didn't have any configuration for 'com'), then
+        // 'com' will not be found when we process the existing loggers named
+        // in the configuration.
+        //
+        // So if we didn't also process the existing loggers not named in the
+        // configuration (such as com.foo.child) then no logger for 'com'
+        // would be created, which means that com.foo.child would not be
+        // able to inherit its configuration for 'com' until someone explicitely
+        // creates a logger for 'com'.
+        //
+        // This test check that a logger for 'com' will be created because
+        // 'com.foo.child' still exists when updateConfiguration() is called.
+
+        Properties props1 = new Properties();
+        props1.setProperty("test.name", "parent logger with handler");
+        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("test.checkHandlersOnParent", "true");
+        props1.setProperty("test.checkHandlersOn", "com.foo");
+        props1.setProperty("com.bar.level", "FINEST");
+
+        Properties props2 = new Properties();
+        props2.setProperty("java.util.logging.LogManager.reconfigureHandlers", "true");
+        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("test.checkHandlersOnParent", "true");
+        props2.setProperty("test.checkHandlersOn", "com.foo");
+        props2.setProperty("com.bar.level", "FINEST");
+
+        Properties props3 = new Properties();
+        props3.setProperty("test.name", "parent logger with handler");
+        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("test.checkHandlersOnParent", "true");
+        props3.setProperty("test.checkHandlersOn", "com.foo");
+        props3.setProperty("com.bar.level", "FINEST");
+
+        Properties props4 = new Properties();
+        props4.setProperty("java.util.logging.LogManager.reconfigureHandlers", "true");
+        props4.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
+        props4.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
+        props4.setProperty(FileHandler.class.getName() + ".level", "ALL");
+        props4.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
+        props4.setProperty("test.checkHandlersOnParent", "true");
+        props4.setProperty("test.checkHandlersOn", "com.foo");
+        props4.setProperty("com.foo.handlers", FileHandler.class.getName());
+
+        Properties props5 = new Properties();
+        props5.setProperty("test.name", "parent logger with handler");
+        props5.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
+        props5.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
+        props5.setProperty(FileHandler.class.getName() + ".level", "ALL");
+        props5.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
+        props5.setProperty("test.checkHandlersOnParent", "false");
+        props5.setProperty("test.checkHandlersOn", "com");
+        props5.setProperty("com.handlers", FileHandler.class.getName());
+
+        properties = Collections.unmodifiableList(Arrays.asList(
+                    props1, props2, props3, props4, props5));
+    }
+
+    /**
+     * This is the main test method. The rest is infrastructure.
+     * Creates a child of the 'com.foo' logger (com.foo.child) and holds on to
+     * it.
+     * <p>
+     * Then applies all given configurations in sequence and verifies assumptions
+     * about the handlers that com.foo should have, or not have.
+     * In the last configuration (props5) it also verifies that the
+     * logger 'com' has been created and has now the expected handler.
+     * <p>
+     * Finally releases the child logger after all configurations have been
+     * applied.
+     *
+     * @param name
+     * @param properties
+     * @throws Exception
+     */
+    static void test(String name, List<Properties> properties)
+            throws Exception {
+
+        System.out.println("\nTesting: " + name);
+        if (!userDirWritable) {
+            throw new RuntimeException("Not writable: "+userDir);
+        }
+
+        // Then create a child of the com.foo logger.
+        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());
+        }
+        Reference<? extends Logger> ref2;
+        int max = 3;
+        barChild = null;
+        while ((ref2 = queue.poll()) == null) {
+            System.gc();
+            Thread.sleep(100);
+            if (--max == 0) break;
+        }
+
+        Throwable failed = null;
+        try {
+            if (ref2 != null) {
+                String refName = ref2 == fooRef ? "fooRef" : ref2 == barRef ? "barRef" : "unknown";
+                if (ref2 != barRef) {
+                    throw new RuntimeException("Unexpected logger reference cleared: " + refName);
+                } else {
+                    System.out.println("Reference " + refName + " cleared as expected");
+                }
+            } else if (ref2 == null) {
+                throw new RuntimeException("Expected 'barRef' to be cleared");
+            }
+            // Now lets try to reset, check that ref2 has no handlers, and
+            // attempt to configure again.
+            Properties previousProps  = properties.get(0);
+            int expectedHandlersCount = 1;
+            boolean checkHandlersOnParent = Boolean.parseBoolean(
+                    previousProps.getProperty("test.checkHandlersOnParent", "true"));
+            String checkHandlersOn = previousProps.getProperty("test.checkHandlersOn", null);
+            for (int i=1; i<properties.size(); i++) {
+                System.out.println("\n*** Reconfiguration with properties["+i+"]\n");
+                Properties nextProps = properties.get(i);
+                boolean reconfigureHandlers = true;
+
+                if (checkHandlersOnParent) {
+                    assertEquals(expectedHandlersCount,
+                            fooChild.getParent().getHandlers().length,
+                            "fooChild.getParent().getHandlers().length");
+                }
+                if (checkHandlersOn != null) {
+                    Logger loggerWithHandlers = LogManager.getLogManager().getLogger(checkHandlersOn);
+                    if (loggerWithHandlers == null) {
+                        throw new RuntimeException("Logger with handlers not found: " + checkHandlersOn);
+                    }
+                    assertEquals(expectedHandlersCount,
+                            loggerWithHandlers.getHandlers().length,
+                            checkHandlersOn + ".getHandlers().length");
+                }
+
+                // Reset
+                Configure.doPrivileged(() -> LogManager.getLogManager().reset());
+                assertEquals(0, fooChild.getParent().getHandlers().length, "fooChild.getParent().getHandlers().length");
+                if (checkHandlersOn != null) {
+                    Logger loggerWithHandlers = LogManager.getLogManager().getLogger(checkHandlersOn);
+                    if (loggerWithHandlers == null) {
+                        throw new RuntimeException("Logger with handlers not found: " + checkHandlersOn);
+                    }
+                    assertEquals(0, loggerWithHandlers.getHandlers().length,
+                            checkHandlersOn + ".getHandlers().length");
+                }
+
+                if (i == 4) {
+                    System.out.println("Last configuration...");
+                }
+                // Read configuration
+                Configure.doPrivileged(() -> Configure.updateConfigurationWith(nextProps, false));
+
+                expectedHandlersCount = reconfigureHandlers ? 1 : 0;
+                checkHandlersOnParent = Boolean.parseBoolean(
+                    nextProps.getProperty("test.checkHandlersOnParent", "true"));
+                checkHandlersOn = nextProps.getProperty("test.checkHandlersOn", null);
+
+                if (checkHandlersOnParent) {
+                    assertEquals(expectedHandlersCount,
+                        fooChild.getParent().getHandlers().length,
+                        "fooChild.getParent().getHandlers().length");
+                } else {
+                    assertEquals(0,
+                        fooChild.getParent().getHandlers().length,
+                        "fooChild.getParent().getHandlers().length");
+                }
+                if (checkHandlersOn != null) {
+                    Logger loggerWithHandlers = LogManager.getLogManager().getLogger(checkHandlersOn);
+                    if (loggerWithHandlers == null) {
+                        throw new RuntimeException("Logger with handlers not found: " + checkHandlersOn);
+                    }
+                    assertEquals(expectedHandlersCount,
+                            loggerWithHandlers.getHandlers().length,
+                            checkHandlersOn + ".getHandlers().length");
+                }
+            }
+        } 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);
+                }
+            });
+            fooChild = null;
+            System.out.println("Setting fooChild to: " + fooChild);
+            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(), fooChild is " + fooChild);
+
+        }
+        if (failed != null) {
+            // should rarely happen...
+            throw new RuntimeException(failed);
+        }
+
+    }
+
+    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) {
+                TestCase test = TestCase.valueOf(testName);
+                test.run(properties);
+            }
+        } 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 ThreadLocal<AtomicBoolean> allowAll = new ThreadLocal<AtomicBoolean>() {
+            @Override
+            protected AtomicBoolean initialValue() {
+                return  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(() -> {
+                updateConfigurationWith(propertyFile, false);
+            });
+        }
+
+        static void updateConfigurationWith(Properties propertyFile, boolean append) {
+            try {
+                ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+                propertyFile.store(bytes, propertyFile.getProperty("test.name"));
+                ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());
+                Function<String, BiFunction<String,String,String>> remapper =
+                        append ? (x) -> ((o, n) -> n == null ? o : n)
+                               : (x) -> ((o, n) -> n);
+                LogManager.getLogManager().updateConfiguration(bais, remapper);
+            } catch (IOException ex) {
+                throw new RuntimeException(ex);
+            }
+        }
+
+        static void doPrivileged(Runnable run) {
+            final boolean old = allowAll.get().getAndSet(true);
+            try {
+                run.run();
+            } finally {
+                allowAll.get().set(old);
+            }
+        }
+        static <T> T callPrivileged(Callable<T> call) throws Exception {
+            final boolean old = allowAll.get().getAndSet(true);
+            try {
+                return call.call();
+            } finally {
+                allowAll.get().set(old);
+            }
+        }
+    }
+
+    @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);
+        }
+    }
+
+    final static 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 ThreadLocal<AtomicBoolean> allowAll; // actually: this should be in a thread locale
+        public SimplePolicy(TestCase test, ThreadLocal<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().get()) return allPermissions.implies(permission);
+            return permissions.implies(permission);
+        }
+
+        @Override
+        public PermissionCollection getPermissions(CodeSource codesource) {
+            return new PermissionsBuilder().addAll(allowAll.get().get()
+                    ? allPermissions : permissions).toPermissions();
+        }
+
+        @Override
+        public PermissionCollection getPermissions(ProtectionDomain domain) {
+            return new PermissionsBuilder().addAll(allowAll.get().get()
+                    ? allPermissions : permissions).toPermissions();
+        }
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/util/logging/LogManager/Configuration/updateConfiguration/HandlersOnComplexUpdate.java	Mon Oct 12 20:13:22 2015 +0200
@@ -0,0 +1,547 @@
+/*
+ * Copyright (c) 2015, 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.List;
+import java.util.Properties;
+import java.util.UUID;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.logging.FileHandler;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+import java.util.logging.LoggingPermission;
+
+/**
+ * @test
+ * @bug 8033661
+ * @summary tests that FileHandlers configured on abstract nodes in logging.properties
+ *          will be properly closed and reopened on updateConfiguration().
+ *          Test a complex reconfiguration where a logger with handlers
+ *          suddenly appears in the hierarchy between a child logger and the
+ *          root logger.
+ * @run main/othervm HandlersOnComplexUpdate UNSECURE
+ * @run main/othervm HandlersOnComplexUpdate SECURE
+ * @author danielfuchs
+ */
+public class HandlersOnComplexUpdate {
+
+    /**
+     * 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(List<Properties> properties) throws Exception {
+            System.out.println("Running test case: " + name());
+            Configure.setUp(this, properties.get(0));
+            test(this.name(), properties);
+        }
+    }
+
+
+    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));
+
+    private static final List<Properties> properties;
+    static {
+        // The test will call updateConfiguration() with each of these
+        // properties in sequence. The child logger is not released between each
+        // configuration. What is interesting here is mostly what happens between
+        // props4 and props5:
+        //
+        // In step 4 (props4) the configuration defines a handler for the
+        // logger com.foo (the direct parent of com.foo.child - which is the
+        // logger we hold on to).
+        //
+        // In step 5 (props5) the configuration has nothing concerning
+        // 'com.foo', but the handler has been migrated to 'com'.
+        // Since there doesn't exist any logger for 'com' (the previous
+        // configuration didn't have any configuration for 'com'), then
+        // 'com' will not be found when we process the existing loggers named
+        // in the configuration.
+        //
+        // So if we didn't also process the existing loggers not named in the
+        // configuration (such as com.foo.child) then no logger for 'com'
+        // would be created, which means that com.foo.child would not be
+        // able to inherit its configuration for 'com' until someone explicitely
+        // creates a logger for 'com'.
+        //
+        // This test check that a logger for 'com' will be created because
+        // 'com.foo.child' still exists when updateConfiguration() is called.
+
+        Properties props1 = new Properties();
+        props1.setProperty("test.name", "parent logger with handler");
+        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("test.checkHandlersOnParent", "true");
+        props1.setProperty("test.checkHandlersOn", "com.foo");
+        props1.setProperty("com.bar.level", "FINEST");
+
+        Properties props2 = new Properties();
+        props2.setProperty("test.name", "parent logger with handler");
+        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("test.checkHandlersOnParent", "true");
+        props2.setProperty("test.checkHandlersOn", "com.foo");
+        props2.setProperty("com.bar.level", "FINEST");
+
+        Properties props3 = new Properties();
+        props3.setProperty("test.name", "parent logger with handler");
+        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("test.checkHandlersOnParent", "true");
+        props3.setProperty("test.checkHandlersOn", "com.foo");
+        props3.setProperty("com.bar.level", "FINEST");
+
+        Properties props4 = new Properties();
+        props4.setProperty("test.name", "parent logger with handler");
+        props4.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
+        props4.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
+        props4.setProperty(FileHandler.class.getName() + ".level", "ALL");
+        props4.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
+        props4.setProperty("test.checkHandlersOnParent", "true");
+        props4.setProperty("test.checkHandlersOn", "com.foo");
+        props4.setProperty("com.foo.handlers", FileHandler.class.getName());
+
+        Properties props5 = new Properties();
+        props5.setProperty("test.name", "parent logger with handler");
+        props5.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
+        props5.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
+        props5.setProperty(FileHandler.class.getName() + ".level", "ALL");
+        props5.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
+        props5.setProperty("test.checkHandlersOnParent", "false");
+        props5.setProperty("test.checkHandlersOn", "com");
+        props5.setProperty("com.handlers", FileHandler.class.getName());
+
+        properties = Collections.unmodifiableList(Arrays.asList(
+                    props1, props2, props3, props4, props5));
+    }
+
+    /**
+     * This is the main test method. The rest is infrastructure.
+     * Creates a child of the 'com.foo' logger (com.foo.child) and holds on to
+     * it.
+     * <p>
+     * Then applies all given configurations in sequence and verifies assumptions
+     * about the handlers that com.foo should have, or not have.
+     * In the last configuration (props5) it also verifies that the
+     * logger 'com' has been created and has now the expected handler.
+     * <p>
+     * Finally releases the child logger after all configurations have been
+     * applied.
+     *
+     * @param name
+     * @param properties
+     * @throws Exception
+     */
+    static void test(String name, List<Properties> properties)
+            throws Exception {
+
+        System.out.println("\nTesting: " + name);
+        if (!userDirWritable) {
+            throw new RuntimeException("Not writable: "+userDir);
+        }
+
+        // Then create a child of the com.foo logger.
+        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());
+        }
+        Reference<? extends Logger> ref2;
+        int max = 3;
+        barChild = null;
+        while ((ref2 = queue.poll()) == null) {
+            System.gc();
+            Thread.sleep(100);
+            if (--max == 0) break;
+        }
+
+        Throwable failed = null;
+        try {
+            if (ref2 != null) {
+                String refName = ref2 == fooRef ? "fooRef" : ref2 == barRef ? "barRef" : "unknown";
+                if (ref2 != barRef) {
+                    throw new RuntimeException("Unexpected logger reference cleared: " + refName);
+                } else {
+                    System.out.println("Reference " + refName + " cleared as expected");
+                }
+            } else if (ref2 == null) {
+                throw new RuntimeException("Expected 'barRef' to be cleared");
+            }
+            // Now lets try to check handlers, and
+            // attempt to update the configuration again.
+            Properties previousProps  = properties.get(0);
+            int expectedHandlersCount = 1;
+            boolean checkHandlersOnParent = Boolean.parseBoolean(
+                    previousProps.getProperty("test.checkHandlersOnParent", "true"));
+            String checkHandlersOn = previousProps.getProperty("test.checkHandlersOn", null);
+            for (int i=1; i<properties.size(); i++) {
+                System.out.println("\n*** Reconfiguration with properties["+i+"]\n");
+                Properties nextProps = properties.get(i);
+                boolean reconfigureHandlers = true;
+
+                if (checkHandlersOnParent) {
+                    assertEquals(expectedHandlersCount,
+                            fooChild.getParent().getHandlers().length,
+                            "fooChild.getParent().getHandlers().length");
+                }
+                if (checkHandlersOn != null) {
+                    Logger loggerWithHandlers = LogManager.getLogManager().getLogger(checkHandlersOn);
+                    if (loggerWithHandlers == null) {
+                        throw new RuntimeException("Logger with handlers not found: " + checkHandlersOn);
+                    }
+                    assertEquals(expectedHandlersCount,
+                            loggerWithHandlers.getHandlers().length,
+                            checkHandlersOn + ".getHandlers().length");
+                }
+
+                if (i == 4) {
+                    System.out.println("Last configuration...");
+                }
+                // Read configuration
+                Configure.doPrivileged(() -> Configure.updateConfigurationWith(nextProps, false));
+
+                expectedHandlersCount = reconfigureHandlers ? 1 : 0;
+                checkHandlersOnParent = Boolean.parseBoolean(
+                    nextProps.getProperty("test.checkHandlersOnParent", "true"));
+                checkHandlersOn = nextProps.getProperty("test.checkHandlersOn", null);
+
+                if (checkHandlersOnParent) {
+                    assertEquals(expectedHandlersCount,
+                        fooChild.getParent().getHandlers().length,
+                        "fooChild.getParent().getHandlers().length");
+                } else {
+                    assertEquals(0,
+                        fooChild.getParent().getHandlers().length,
+                        "fooChild.getParent().getHandlers().length");
+                }
+                if (checkHandlersOn != null) {
+                    Logger loggerWithHandlers = LogManager.getLogManager().getLogger(checkHandlersOn);
+                    if (loggerWithHandlers == null) {
+                        throw new RuntimeException("Logger with handlers not found: " + checkHandlersOn);
+                    }
+                    assertEquals(expectedHandlersCount,
+                            loggerWithHandlers.getHandlers().length,
+                            checkHandlersOn + ".getHandlers().length");
+                }
+            }
+        } 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);
+                }
+            });
+            fooChild = null;
+            System.out.println("Setting fooChild to: " + fooChild);
+            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(), fooChild is " + fooChild);
+
+        }
+        if (failed != null) {
+            // should rarely happen...
+            throw new RuntimeException(failed);
+        }
+
+    }
+
+    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) {
+                TestCase test = TestCase.valueOf(testName);
+                test.run(properties);
+            }
+        } 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 ThreadLocal<AtomicBoolean> allowAll = new ThreadLocal<AtomicBoolean>() {
+            @Override
+            protected AtomicBoolean initialValue() {
+                return  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(() -> {
+                configureWith(propertyFile);
+            });
+        }
+
+        static void configureWith(Properties propertyFile) {
+            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 updateConfigurationWith(Properties propertyFile, boolean append) {
+            try {
+                ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+                propertyFile.store(bytes, propertyFile.getProperty("test.name"));
+                ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());
+                Function<String, BiFunction<String,String,String>> remapper =
+                        append ? (x) -> ((o, n) -> n == null ? o : n)
+                               : (x) -> ((o, n) -> n);
+                LogManager.getLogManager().updateConfiguration(bais, remapper);
+            } catch (IOException ex) {
+                throw new RuntimeException(ex);
+            }
+        }
+
+        static void doPrivileged(Runnable run) {
+            final boolean old = allowAll.get().getAndSet(true);
+            try {
+                run.run();
+            } finally {
+                allowAll.get().set(old);
+            }
+        }
+        static <T> T callPrivileged(Callable<T> call) throws Exception {
+            final boolean old = allowAll.get().getAndSet(true);
+            try {
+                return call.call();
+            } finally {
+                allowAll.get().set(old);
+            }
+        }
+    }
+
+    @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);
+        }
+    }
+
+    final static 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 ThreadLocal<AtomicBoolean> allowAll; // actually: this should be in a thread locale
+        public SimplePolicy(TestCase test, ThreadLocal<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().get()) return allPermissions.implies(permission);
+            return permissions.implies(permission);
+        }
+
+        @Override
+        public PermissionCollection getPermissions(CodeSource codesource) {
+            return new PermissionsBuilder().addAll(allowAll.get().get()
+                    ? allPermissions : permissions).toPermissions();
+        }
+
+        @Override
+        public PermissionCollection getPermissions(ProtectionDomain domain) {
+            return new PermissionsBuilder().addAll(allowAll.get().get()
+                    ? allPermissions : permissions).toPermissions();
+        }
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/util/logging/LogManager/Configuration/updateConfiguration/SimpleUpdateConfigWithInputStreamTest.java	Mon Oct 12 20:13:22 2015 +0200
@@ -0,0 +1,685 @@
+/*
+ * Copyright (c) 2015, 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.FileOutputStream;
+import java.io.IOException;
+import java.nio.file.Path;
+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.Enumeration;
+import java.util.Objects;
+import java.util.Properties;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+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.logging.LoggingPermission;
+
+/**
+ * @test
+ * @bug 8033661
+ * @summary tests LogManager.updateConfiguration(InputStream, Function) method
+ * @run main/othervm SimpleUpdateConfigWithInputStreamTest UNSECURE
+ * @run main/othervm SimpleUpdateConfigWithInputStreamTest SECURE
+ * @author danielfuchs
+ */
+public class SimpleUpdateConfigWithInputStreamTest {
+
+    /**
+     * We will test updateConfiguration 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 execute(Runnable run) {
+            System.out.println("Running test case: " + name());
+            try {
+               Configure.setUp(this);
+               Configure.doPrivileged(run, SimplePolicy.allowControl);
+            } finally {
+               Configure.doPrivileged(() -> {
+                   try {
+                       setSystemProperty("java.util.logging.config.file", null);
+                       LogManager.getLogManager().readConfiguration();
+                       System.gc();
+                   } catch (Exception x) {
+                       throw new RuntimeException(x);
+                   }
+               }, SimplePolicy.allowAll);
+            }
+        }
+    }
+
+    public static class MyHandler extends Handler {
+        static final AtomicLong seq = new AtomicLong();
+        long count = seq.incrementAndGet();
+
+        @Override
+        public void publish(LogRecord record) {
+        }
+
+        @Override
+        public void flush() {
+        }
+
+        @Override
+        public void close() throws SecurityException {
+        }
+
+        @Override
+        public String toString() {
+            return super.toString() + "("+count+")";
+        }
+
+    }
+
+    static String storePropertyToFile(String name, Properties props)
+        throws Exception {
+        return Configure.callPrivileged(() -> {
+            String scratch = System.getProperty("user.dir", ".");
+            Path p = Paths.get(scratch, name);
+            try (FileOutputStream fos = new FileOutputStream(p.toFile())) {
+                props.store(fos, name);
+            }
+            return p.toString();
+        }, SimplePolicy.allowAll);
+    }
+
+    static void setSystemProperty(String name, String value)
+        throws Exception {
+        Configure.doPrivileged(() -> {
+            if (value == null)
+                System.clearProperty(name);
+            else
+                System.setProperty(name, value);
+        }, SimplePolicy.allowAll);
+    }
+
+    static String trim(String value) {
+        return value == null ? null : value.trim();
+    }
+
+
+    /**
+     * Tests one of the configuration defined above.
+     * <p>
+     * This is the main test method (the rest is infrastructure).
+     */
+    static void testUpdateConfiguration() {
+        try {
+            // manager initialized with default configuration.
+            LogManager manager = LogManager.getLogManager();
+
+            // Test default configuration. It should not have
+            // any value for "com.foo.level" and "com.foo.handlers"
+            assertEquals(null, manager.getProperty("com.foo.level"),
+                "com.foo.level in default configuration");
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in default configuration");
+
+            // Create a logging configuration file that contains
+            // com.foo.level=FINEST
+            // and set "java.util.logging.config.file" to this file.
+            Properties props = new Properties();
+            props.setProperty("com.foo.level", "FINEST");
+
+            // Update configuration with props
+            // then test that the new configuration has
+            // com.foo.level=FINEST
+            // and nothing for com.foo.handlers
+            Configure.updateConfigurationWith(props, null);
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level in " + props);
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in " + props);
+
+            // call updateConfiguration with an empty stream.
+            // check that the new configuration no longer has
+            // any value for com.foo.level, and still no value
+            // for com.foo.handlers
+            Configure.updateConfigurationWith(new Properties(), null);
+            assertEquals(null, manager.getProperty("com.foo.level"),
+                    "com.foo.level in default configuration");
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in default configuration");
+
+            // creates the com.foo logger, check it has
+            // the default config: no level, and no handlers
+            final Logger logger = Logger.getLogger("com.foo");
+            assertEquals(null, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertDeepEquals(new Handler[0], logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+
+            // call updateConfiguration with 'props'
+            // check that the configuration has
+            // com.foo.level=FINEST
+            // and nothing for com.foo.handlers
+            // check that the logger has now a FINEST level and still
+            // no handlers
+            Configure.updateConfigurationWith(props, null);
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level in " + props);
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertDeepEquals(new Handler[0], logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in " + props);
+
+            // Calls updateConfiguration with a lambda whose effect should
+            // be to set the FINER level on the "com.foo" logger.
+            // Check that the new configuration has
+            // com.foo.level=FINER
+            // and nothing for com.foo.handlers
+            // check that the logger has now a FINER level and still
+            // no handlers
+            Configure.updateConfigurationWith(props,
+                    (k) -> ("com.foo.level".equals(k) ? (o, n) -> "FINER" : (o, n) -> n));
+            assertEquals("FINER", manager.getProperty("com.foo.level"),
+                "com.foo.level set to FINER by updateConfiguration");
+            assertEquals(Level.FINER, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertDeepEquals(new Handler[0], logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in " + props);
+
+            // Calls updateConfiguration with a lambda whose effect is a noop.
+            // This should not change the configuration, so
+            // check that the new configuration still has
+            // com.foo.level=FINER
+            // and nothing for com.foo.handlers
+            // check that the logger still has FINER level and still
+            // no handlers
+            Configure.updateConfigurationWith(props,
+                    (k) -> ((o, n) -> o));
+            assertEquals("FINER", manager.getProperty("com.foo.level"),
+                "com.foo.level preserved by updateConfiguration");
+            assertEquals(Level.FINER, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertDeepEquals(new Handler[0], logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in " + props);
+
+            // Calls updateConfiguration with a lambda whose effect is to
+            // take all values from the new configuration.
+            // This should update the configuration to what is in props, so
+            // check that the new configuration has
+            // com.foo.level=FINEST
+            // and nothing for com.foo.handlers
+            // check that the logger now has FINEST level and still
+            // no handlers
+            Configure.updateConfigurationWith(props,
+                    (k) -> ((o, n) -> n));
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level updated by updateConfiguration");
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertDeepEquals(new Handler[0], logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in " + props);
+
+            // now set a handler on the com.foo logger.
+            MyHandler h = new MyHandler();
+            logger.addHandler(h);
+            assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+
+            // Calls updateConfiguration with a lambda whose effect should
+            // be to set the FINER level on the "com.foo" logger, and
+            // take the value from props for everything else.
+            // Check that the new configuration has
+            // com.foo.level=FINER
+            // and nothing for com.foo.handlers
+            // check that the logger has now a FINER level, but that its
+            // handlers are still present and have not been reset
+            // since neither the old nor new configuration defined them.
+            Configure.updateConfigurationWith(props,
+                    (k) -> ("com.foo.level".equals(k) ? (o, n) -> "FINER" : (o, n) -> n));
+            assertEquals("FINER", manager.getProperty("com.foo.level"),
+                "com.foo.level set to FINER by updateConfiguration");
+            assertEquals(Level.FINER, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in " + props);
+
+            // now add some configuration for com.foo.handlers
+            props.setProperty("com.foo.handlers", MyHandler.class.getName());
+
+            // we didn't call updateConfiguration, so just changing the
+            // content of props should have had no effect.
+            assertEquals("FINER", manager.getProperty("com.foo.level"),
+                "com.foo.level set to FINER by updateConfiguration");
+            assertEquals(Level.FINER, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(null,
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+            assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+
+            // Calls updateConfiguration with a lambda whose effect is a noop.
+            // This should not change the current configuration, so
+            // check that the new configuration still has
+            // com.foo.level=FINER
+            // and nothing for com.foo.handlers
+            // check that the logger still has FINER level and still
+            // has its handlers and that they haven't been reset.
+            Configure.updateConfigurationWith(props, (k) -> ((o, n) -> o));
+            assertEquals("FINER", manager.getProperty("com.foo.level"),
+                "com.foo.level set to FINER by updateConfiguration");
+            assertEquals(Level.FINER, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(null,
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+            assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+
+            // Calls updateConfiguration with a lambda whose effect is to
+            // take all values from the new configuration.
+            // This should update the configuration to what is in props, so
+            // check that the new configuration has
+            // com.foo.level=FINEST
+            // com.foo.handlers=SimpleUpdateConfigWithInputStreamTest$MyHandler
+            // check that the logger now has FINEST level
+            // and a new handler instance, since the old config
+            // had no handlers for com.foo and the new config has one.
+            Configure.updateConfigurationWith(props, (k) -> ((o, n) -> n));
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level updated by updateConfiguration");
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(MyHandler.class.getName(),
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+            Handler[] loggerHandlers = logger.getHandlers().clone();
+            assertEquals(1, loggerHandlers.length,
+                    "Logger.getLogger(\"com.foo\").getHandlers().length");
+            assertEquals(MyHandler.class, loggerHandlers[0].getClass(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()[0].getClass()");
+            assertEquals(h.count + 1, ((MyHandler)logger.getHandlers()[0]).count,
+                    "Logger.getLogger(\"com.foo\").getHandlers()[0].count");
+
+            // Calls updateConfiguration with a lambda whose effect is a noop.
+            // This should not change the current configuration, so
+            // check that the new configuration still has
+            // com.foo.level=FINEST
+            // com.foo.handlers=SimpleUpdateConfigWithInputStreamTest$MyHandler
+            // check that the logger still has FINEST level and still
+            // has its handlers and that they haven't been reset.
+            Configure.updateConfigurationWith(props, (k) -> ((o, n) -> o));
+            assertDeepEquals(loggerHandlers, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level updated by updateConfiguration");
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(MyHandler.class.getName(),
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+
+            // Calls updateConfiguration with a lambda whose effect is to
+            // take all values from the new configuration.
+            // Because the content of the props hasn't changed, then
+            // it should also be a noop.
+            // check that the new configuration still has
+            // com.foo.level=FINEST
+            // com.foo.handlers=SimpleUpdateConfigWithInputStreamTest$MyHandler
+            // check that the logger still has FINEST level and still
+            // has its handlers and that they haven't been reset.
+            Configure.updateConfigurationWith(props, (k) -> ((o, n) -> n));
+            assertDeepEquals(loggerHandlers, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level updated by updateConfiguration");
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(MyHandler.class.getName(),
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+
+            // Calls updateConfiguration with a null lambda, whose effect is to
+            // take all values from the new configuration.
+            // Because the content of the props hasn't changed, then
+            // it should also be a noop.
+            // check that the new configuration still has
+            // com.foo.level=FINEST
+            // com.foo.handlers=SimpleUpdateConfigWithInputStreamTest$MyHandler
+            // check that the logger still has FINEST level and still
+            // has its handlers and that they haven't been reset.
+            Configure.updateConfigurationWith(props, (k) -> ((o, n) -> n));
+            assertDeepEquals(loggerHandlers, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level updated by updateConfiguration");
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(MyHandler.class.getName(),
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+
+            // now remove com.foo.handlers=SimpleUpdateConfigWithInputStreamTest$MyHandler
+            // from the configuration file.
+            props.remove("com.foo.handlers");
+
+            // Calls updateConfiguration with a lambda whose effect is a noop.
+            // This should not change the current configuration, so
+            // check that the new configuration still has
+            // com.foo.level=FINEST
+            // com.foo.handlers=SimpleUpdateConfigWithInputStreamTest$MyHandler
+            // check that the logger still has FINEST level and still
+            // has its handlers and that they haven't been reset.
+            Configure.updateConfigurationWith(props, (k) -> ((o, n) -> o));
+            assertDeepEquals(loggerHandlers, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level updated by updateConfiguration");
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(MyHandler.class.getName(),
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+
+            // Calls updateConfiguration with a lambda whose effect is to
+            // take all values from the new configuration.
+            // This should update the configuration to what is in props, so
+            // check that the new configuration has
+            // com.foo.level=FINEST
+            // and nothing for com.foo.handlers
+            // check that the logger still has FINEST level
+            // and no handlers, since the old config
+            // had an handler for com.foo and the new config doesn't.
+            Configure.updateConfigurationWith(props, (k) -> ((o, n) -> n));
+            assertDeepEquals(new Handler[0], logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level updated by updateConfiguration");
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(null,
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+
+
+        } catch (RuntimeException | Error r) {
+            throw r;
+        } catch (Exception x) {
+            throw new RuntimeException(x);
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (args == null || args.length == 0) {
+            args = new String[] { "UNSECURE", "SECURE" };
+        }
+        for (String test : args) {
+            TestCase.valueOf(test).execute(SimpleUpdateConfigWithInputStreamTest::testUpdateConfiguration);
+        }
+    }
+
+    static class Configure {
+        static Policy policy = null;
+        static void setUp(TestCase test) {
+            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);
+                        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:
+                    throw new InternalError("No such testcase: " + test);
+            }
+        }
+
+        static void updateConfigurationWith(Properties propertyFile,
+                Function<String,BiFunction<String,String,String>> remapper) {
+            try {
+                ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+                propertyFile.store(bytes, propertyFile.getProperty("test.name"));
+                ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());
+                LogManager.getLogManager().updateConfiguration(bais, remapper);
+            } catch (IOException ex) {
+                throw new RuntimeException(ex);
+            }
+        }
+
+        static void doPrivileged(Runnable run, ThreadLocal<AtomicBoolean> granter) {
+            final boolean old = granter.get().getAndSet(true);
+            try {
+                run.run();
+            } finally {
+                granter.get().set(old);
+            }
+        }
+        static <T> T callPrivileged(Callable<T> call,
+                ThreadLocal<AtomicBoolean> granter) throws Exception {
+            final boolean old = granter.get().getAndSet(true);
+            try {
+                return call.call();
+            } finally {
+                granter.get().set(old);
+            }
+        }
+    }
+
+    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);
+        }
+    }
+
+    private static void assertEquals(String expected, String received, String msg) {
+        if (!Objects.equals(expected, received)) {
+            throw new TestAssertException("Unexpected result for " + msg
+                    + ".\n\texpected: " + expected
+                    +  "\n\tactual:   " + received);
+        } else {
+            System.out.println("Got expected " + msg + ": " + received);
+        }
+    }
+
+    private static void assertEquals(Object expected, Object received, String msg) {
+        if (!Objects.equals(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 String deepToString(Object o) {
+        if (o == null) {
+            return "null";
+        } else if (o.getClass().isArray()) {
+            String s;
+            if (o instanceof Object[])
+                s = Arrays.deepToString((Object[]) o);
+            else if (o instanceof byte[])
+                s = Arrays.toString((byte[]) o);
+            else if (o instanceof short[])
+                s = Arrays.toString((short[]) o);
+            else if (o instanceof int[])
+                s = Arrays.toString((int[]) o);
+            else if (o instanceof long[])
+                s = Arrays.toString((long[]) o);
+            else if (o instanceof char[])
+                s = Arrays.toString((char[]) o);
+            else if (o instanceof float[])
+                s = Arrays.toString((float[]) o);
+            else if (o instanceof double[])
+                s = Arrays.toString((double[]) o);
+            else if (o instanceof boolean[])
+                s = Arrays.toString((boolean[]) o);
+            else
+                s = o.toString();
+            return s;
+        } else {
+            return o.toString();
+        }
+    }
+
+    private static void assertDeepEquals(Object expected, Object received, String msg) {
+        if (!Objects.deepEquals(expected, received)) {
+            throw new TestAssertException("Unexpected result for " + msg
+                    + ".\n\texpected: " + deepToString(expected)
+                    +  "\n\tactual:   " + deepToString(received));
+        } else {
+            System.out.println("Got expected " + msg + ": " + deepToString(received));
+        }
+    }
+
+    final static 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 basic;
+        final Permissions control;
+        final Permissions all;
+        public final static ThreadLocal<AtomicBoolean> allowAll =
+                new ThreadLocal<AtomicBoolean>() {
+            @Override
+            protected AtomicBoolean initialValue() {
+                return new AtomicBoolean();
+            }
+        };
+        public final static ThreadLocal<AtomicBoolean> allowControl =
+                new ThreadLocal<AtomicBoolean>() {
+            @Override
+            protected AtomicBoolean initialValue() {
+                return new AtomicBoolean();
+            }
+        };
+        public SimplePolicy(TestCase test) {
+            basic = new Permissions();
+            control = new Permissions();
+            control.add(new LoggingPermission("control", null));
+
+            // these are used for configuring the test itself...
+            all = new Permissions();
+            all.add(new java.security.AllPermission());
+
+        }
+
+        @Override
+        public boolean implies(ProtectionDomain domain, Permission permission) {
+            return getPermissions(domain).implies(permission);
+        }
+
+        public PermissionCollection permissions() {
+            PermissionsBuilder builder = new PermissionsBuilder();
+            if (allowAll.get().get()) {
+                builder.addAll(all);
+            } else {
+                builder.addAll(basic);
+                if (allowControl.get().get()) {
+                    builder.addAll(control);
+                }
+            }
+            return builder.toPermissions();
+        }
+
+        @Override
+        public PermissionCollection getPermissions(CodeSource codesource) {
+            return permissions();
+        }
+
+        @Override
+        public PermissionCollection getPermissions(ProtectionDomain domain) {
+            return permissions();
+        }
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/util/logging/LogManager/Configuration/updateConfiguration/SimpleUpdateConfigurationTest.java	Mon Oct 12 20:13:22 2015 +0200
@@ -0,0 +1,720 @@
+/*
+ * Copyright (c) 2015, 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.FileOutputStream;
+import java.io.FilePermission;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+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.Enumeration;
+import java.util.Objects;
+import java.util.Properties;
+import java.util.PropertyPermission;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+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.logging.LoggingPermission;
+
+/**
+ * @test
+ * @bug 8033661
+ * @summary tests LogManager.updateConfiguration(Function) method
+ * @run main/othervm SimpleUpdateConfigurationTest UNSECURE
+ * @run main/othervm SimpleUpdateConfigurationTest SECURE
+ * @author danielfuchs
+ */
+public class SimpleUpdateConfigurationTest {
+
+    /**
+     * We will test updateConfiguration 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 execute(Runnable run) {
+            System.out.println("Running test case: " + name());
+            try {
+               Configure.setUp(this);
+               Configure.doPrivileged(run, SimplePolicy.allowControl);
+            } finally {
+               Configure.doPrivileged(() -> {
+                   try {
+                       setSystemProperty("java.util.logging.config.file", null);
+                       LogManager.getLogManager().readConfiguration();
+                       System.gc();
+                   } catch (Exception x) {
+                       throw new RuntimeException(x);
+                   }
+               }, SimplePolicy.allowAll);
+            }
+        }
+    }
+
+    public static class MyHandler extends Handler {
+        static final AtomicLong seq = new AtomicLong();
+        long count = seq.incrementAndGet();
+
+        @Override
+        public void publish(LogRecord record) {
+        }
+
+        @Override
+        public void flush() {
+        }
+
+        @Override
+        public void close() throws SecurityException {
+        }
+
+        @Override
+        public String toString() {
+            return super.toString() + "("+count+")";
+        }
+
+    }
+
+    static String storePropertyToFile(String name, Properties props)
+        throws Exception {
+        return Configure.callPrivileged(() -> {
+            String scratch = System.getProperty("user.dir", ".");
+            Path p = Paths.get(scratch, name);
+            try (FileOutputStream fos = new FileOutputStream(p.toFile())) {
+                props.store(fos, name);
+            }
+            return p.toString();
+        }, SimplePolicy.allowAll);
+    }
+
+    static void setSystemProperty(String name, String value)
+        throws Exception {
+        Configure.doPrivileged(() -> {
+            if (value == null)
+                System.clearProperty(name);
+            else
+                System.setProperty(name, value);
+        }, SimplePolicy.allowAll);
+    }
+
+    static String trim(String value) {
+        return value == null ? null : value.trim();
+    }
+
+
+    /**
+     * Tests one of the configuration defined above.
+     * <p>
+     * This is the main test method (the rest is infrastructure).
+     */
+    static void testUpdateConfiguration() {
+        String configFile = null;
+        try {
+            // manager initialized with default configuration.
+            LogManager manager = LogManager.getLogManager();
+
+            // Test default configuration. It should not have
+            // any value for "com.foo.level" and "com.foo.handlers"
+            assertEquals(null, manager.getProperty("com.foo.level"),
+                "com.foo.level in default configuration");
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in default configuration");
+
+            // Create a logging configuration file that contains
+            // com.foo.level=FINEST
+            // and set "java.util.logging.config.file" to this file.
+            Properties props = new Properties();
+            props.setProperty("com.foo.level", "FINEST");
+            configFile = storePropertyToFile("config1", props);
+            setSystemProperty("java.util.logging.config.file", configFile);
+
+            // Update configuration with configFile
+            // then test that the new configuration has
+            // com.foo.level=FINEST
+            // and nothing for com.foo.handlers
+            manager.updateConfiguration(null);
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level in " + configFile);
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in " + configFile);
+
+            // clear ("java.util.logging.config.file" system property,
+            // and call updateConfiguration again.
+            // check that the new configuration no longer has
+            // any value for com.foo.level, and still no value
+            // for com.foo.handlers
+            setSystemProperty("java.util.logging.config.file", null);
+            manager.updateConfiguration(null);
+            assertEquals(null, manager.getProperty("com.foo.level"),
+                    "com.foo.level in default configuration");
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in default configuration");
+
+            // creates the com.foo logger, check it has
+            // the default config: no level, and no handlers
+            final Logger logger = Logger.getLogger("com.foo");
+            assertEquals(null, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertDeepEquals(new Handler[0], logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+
+            // set "java.util.logging.config.file" to configFile and
+            // call updateConfiguration.
+            // check that the configuration has
+            // com.foo.level=FINEST
+            // and nothing for com.foo.handlers
+            // check that the logger has now a FINEST level and still
+            // no handlers
+            setSystemProperty("java.util.logging.config.file", configFile);
+            manager.updateConfiguration(null);
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level in " + configFile);
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertDeepEquals(new Handler[0], logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in " + configFile);
+
+            // Calls updateConfiguration with a lambda whose effect should
+            // be to set the FINER level on the "com.foo" logger.
+            // Check that the new configuration has
+            // com.foo.level=FINER
+            // and nothing for com.foo.handlers
+            // check that the logger has now a FINER level and still
+            // no handlers
+            manager.updateConfiguration(
+                    (k) -> ("com.foo.level".equals(k) ? (o, n) -> "FINER" : (o, n) -> n));
+            assertEquals("FINER", manager.getProperty("com.foo.level"),
+                "com.foo.level set to FINER by updateConfiguration");
+            assertEquals(Level.FINER, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertDeepEquals(new Handler[0], logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in " + configFile);
+
+            // Calls updateConfiguration with a lambda whose effect is a noop.
+            // This should not change the configuration, so
+            // check that the new configuration still has
+            // com.foo.level=FINER
+            // and nothing for com.foo.handlers
+            // check that the logger still has FINER level and still
+            // no handlers
+            manager.updateConfiguration(
+                    (k) -> ((o, n) -> o));
+            assertEquals("FINER", manager.getProperty("com.foo.level"),
+                "com.foo.level preserved by updateConfiguration");
+            assertEquals(Level.FINER, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertDeepEquals(new Handler[0], logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in " + configFile);
+
+            // Calls updateConfiguration with a lambda whose effect is to
+            // take all values from the new configuration.
+            // This should update the configuration to what is in configFile, so
+            // check that the new configuration has
+            // com.foo.level=FINEST
+            // and nothing for com.foo.handlers
+            // check that the logger now has FINEST level and still
+            // no handlers
+            manager.updateConfiguration(
+                    (k) -> ((o, n) -> n));
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level updated by updateConfiguration");
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertDeepEquals(new Handler[0], logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in " + configFile);
+
+            // now set a handler on the com.foo logger.
+            MyHandler h = new MyHandler();
+            logger.addHandler(h);
+            assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+
+            // Calls updateConfiguration with a lambda whose effect should
+            // be to set the FINER level on the "com.foo" logger, and
+            // take the value from configFile for everything else.
+            // Check that the new configuration has
+            // com.foo.level=FINER
+            // and nothing for com.foo.handlers
+            // check that the logger has now a FINER level, but that its
+            // handlers are still present and have not been reset
+            // since neither the old nor new configuration defined them.
+            manager.updateConfiguration(
+                    (k) -> ("com.foo.level".equals(k) ? (o, n) -> "FINER" : (o, n) -> n));
+            assertEquals("FINER", manager.getProperty("com.foo.level"),
+                "com.foo.level set to FINER by updateConfiguration");
+            assertEquals(Level.FINER, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals(null, manager.getProperty("com.foo.handlers"),
+                "com.foo.handlers in " + configFile);
+
+            // now add some configuration for com.foo.handlers in the
+            // configuration file.
+            props.setProperty("com.foo.handlers", MyHandler.class.getName());
+            storePropertyToFile("config1", props);
+
+            // we didn't call updateConfiguration, so just changing the
+            // content of the file should have had no no effect yet.
+            assertEquals("FINER", manager.getProperty("com.foo.level"),
+                "com.foo.level set to FINER by updateConfiguration");
+            assertEquals(Level.FINER, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(null,
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+            assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+
+            // Calls updateConfiguration with a lambda whose effect is a noop.
+            // This should not change the current configuration, so
+            // check that the new configuration still has
+            // com.foo.level=FINER
+            // and nothing for com.foo.handlers
+            // check that the logger still has FINER level and still
+            // has its handlers and that they haven't been reset.
+            manager.updateConfiguration((k) -> ((o, n) -> o));
+            assertEquals("FINER", manager.getProperty("com.foo.level"),
+                "com.foo.level set to FINER by updateConfiguration");
+            assertEquals(Level.FINER, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(null,
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+            assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+
+            // Calls updateConfiguration with a lambda whose effect is to
+            // take all values from the new configuration.
+            // This should update the configuration to what is in configFile, so
+            // check that the new configuration has
+            // com.foo.level=FINEST
+            // com.foo.handlers=SimpleUpdateConfigurationTest$MyHandler
+            // check that the logger now has FINEST level
+            // and a new handler instance, since the old config
+            // had no handlers for com.foo and the new config has one.
+            manager.updateConfiguration((k) -> ((o, n) -> n));
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level updated by updateConfiguration");
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(MyHandler.class.getName(),
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+            Handler[] loggerHandlers = logger.getHandlers().clone();
+            assertEquals(1, loggerHandlers.length,
+                    "Logger.getLogger(\"com.foo\").getHandlers().length");
+            assertEquals(MyHandler.class, loggerHandlers[0].getClass(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()[0].getClass()");
+            assertEquals(h.count + 1, ((MyHandler)logger.getHandlers()[0]).count,
+                    "Logger.getLogger(\"com.foo\").getHandlers()[0].count");
+
+            // Calls updateConfiguration with a lambda whose effect is a noop.
+            // This should not change the current configuration, so
+            // check that the new configuration still has
+            // com.foo.level=FINEST
+            // com.foo.handlers=SimpleUpdateConfigurationTest$MyHandler
+            // check that the logger still has FINEST level and still
+            // has its handlers and that they haven't been reset.
+            manager.updateConfiguration((k) -> ((o, n) -> o));
+            assertDeepEquals(loggerHandlers, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level updated by updateConfiguration");
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(MyHandler.class.getName(),
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+
+            // Calls updateConfiguration with a lambda whose effect is to
+            // take all values from the new configuration.
+            // Because the content of the configFile hasn't changed, then
+            // it should also be a noop.
+            // check that the new configuration still has
+            // com.foo.level=FINEST
+            // com.foo.handlers=SimpleUpdateConfigurationTest$MyHandler
+            // check that the logger still has FINEST level and still
+            // has its handlers and that they haven't been reset.
+            manager.updateConfiguration((k) -> ((o, n) -> n));
+            assertDeepEquals(loggerHandlers, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level updated by updateConfiguration");
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(MyHandler.class.getName(),
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+
+            // Calls updateConfiguration with a null lambda, whose effect is to
+            // take all values from the new configuration.
+            // Because the content of the configFile hasn't changed, then
+            // it should also be a noop.
+            // check that the new configuration still has
+            // com.foo.level=FINEST
+            // com.foo.handlers=SimpleUpdateConfigurationTest$MyHandler
+            // check that the logger still has FINEST level and still
+            // has its handlers and that they haven't been reset.
+            manager.updateConfiguration((k) -> ((o, n) -> n));
+            assertDeepEquals(loggerHandlers, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level updated by updateConfiguration");
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(MyHandler.class.getName(),
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+
+            // no remove com.foo.handlers=SimpleUpdateConfigurationTest$MyHandler
+            // from the configuration file.
+            props.remove("com.foo.handlers");
+            storePropertyToFile("config1", props);
+
+            // Calls updateConfiguration with a lambda whose effect is a noop.
+            // This should not change the current configuration, so
+            // check that the new configuration still has
+            // com.foo.level=FINEST
+            // com.foo.handlers=SimpleUpdateConfigurationTest$MyHandler
+            // check that the logger still has FINEST level and still
+            // has its handlers and that they haven't been reset.
+            manager.updateConfiguration((k) -> ((o, n) -> o));
+            assertDeepEquals(loggerHandlers, logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level updated by updateConfiguration");
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(MyHandler.class.getName(),
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+
+            // Calls updateConfiguration with a lambda whose effect is to
+            // take all values from the new configuration.
+            // This should update the configuration to what is in configFile, so
+            // check that the new configuration has
+            // com.foo.level=FINEST
+            // and nothing for com.foo.handlers
+            // check that the logger still has FINEST level
+            // and no handlers, since the old config
+            // had an handler for com.foo and the new config doesn't.
+            manager.updateConfiguration((k) -> ((o, n) -> n));
+            assertDeepEquals(new Handler[0], logger.getHandlers(),
+                    "Logger.getLogger(\"com.foo\").getHandlers()");
+            assertEquals("FINEST", manager.getProperty("com.foo.level"),
+                "com.foo.level updated by updateConfiguration");
+            assertEquals(Level.FINEST, logger.getLevel(),
+                "Logger.getLogger(\"com.foo\").getLevel()");
+            assertEquals(null,
+                    manager.getProperty("com.foo.handlers"),
+                    "manager.getProperty(\"com.foo.handlers\")");
+
+
+        } catch (RuntimeException | Error r) {
+            throw r;
+        } catch (Exception x) {
+            throw new RuntimeException(x);
+        } finally {
+            if (configFile != null) {
+                // cleanup
+                final String file = configFile;
+                Configure.doPrivileged(() -> {
+                    try {
+                        Files.delete(Paths.get(file));
+                    } catch (RuntimeException | Error r) {
+                        throw r;
+                    } catch (Exception x) {
+                        throw new RuntimeException(x);
+                    }
+                }, SimplePolicy.allowAll);
+            }
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (args == null || args.length == 0) {
+            args = new String[] { "UNSECURE", "SECURE" };
+        }
+        for (String test : args) {
+            TestCase.valueOf(test).execute(SimpleUpdateConfigurationTest::testUpdateConfiguration);
+        }
+    }
+
+    static class Configure {
+        static Policy policy = null;
+        static void setUp(TestCase test) {
+            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);
+                        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:
+                    throw new InternalError("No such testcase: " + test);
+            }
+        }
+
+        static void updateConfigurationWith(Properties propertyFile,
+                Function<String,BiFunction<String,String,String>> remapper) {
+            try {
+                ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+                propertyFile.store(bytes, propertyFile.getProperty("test.name"));
+                ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());
+                LogManager.getLogManager().updateConfiguration(bais, remapper);
+            } catch (IOException ex) {
+                throw new RuntimeException(ex);
+            }
+        }
+
+        static void doPrivileged(Runnable run, ThreadLocal<AtomicBoolean> granter) {
+            final boolean old = granter.get().getAndSet(true);
+            try {
+                run.run();
+            } finally {
+                granter.get().set(old);
+            }
+        }
+        static <T> T callPrivileged(Callable<T> call,
+                ThreadLocal<AtomicBoolean> granter) throws Exception {
+            final boolean old = granter.get().getAndSet(true);
+            try {
+                return call.call();
+            } finally {
+                granter.get().set(old);
+            }
+        }
+    }
+
+    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);
+        }
+    }
+
+    private static void assertEquals(String expected, String received, String msg) {
+        if (!Objects.equals(expected, received)) {
+            throw new TestAssertException("Unexpected result for " + msg
+                    + ".\n\texpected: " + expected
+                    +  "\n\tactual:   " + received);
+        } else {
+            System.out.println("Got expected " + msg + ": " + received);
+        }
+    }
+
+    private static void assertEquals(Object expected, Object received, String msg) {
+        if (!Objects.equals(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 String deepToString(Object o) {
+        if (o == null) {
+            return "null";
+        } else if (o.getClass().isArray()) {
+            String s;
+            if (o instanceof Object[])
+                s = Arrays.deepToString((Object[]) o);
+            else if (o instanceof byte[])
+                s = Arrays.toString((byte[]) o);
+            else if (o instanceof short[])
+                s = Arrays.toString((short[]) o);
+            else if (o instanceof int[])
+                s = Arrays.toString((int[]) o);
+            else if (o instanceof long[])
+                s = Arrays.toString((long[]) o);
+            else if (o instanceof char[])
+                s = Arrays.toString((char[]) o);
+            else if (o instanceof float[])
+                s = Arrays.toString((float[]) o);
+            else if (o instanceof double[])
+                s = Arrays.toString((double[]) o);
+            else if (o instanceof boolean[])
+                s = Arrays.toString((boolean[]) o);
+            else
+                s = o.toString();
+            return s;
+        } else {
+            return o.toString();
+        }
+    }
+
+    private static void assertDeepEquals(Object expected, Object received, String msg) {
+        if (!Objects.deepEquals(expected, received)) {
+            throw new TestAssertException("Unexpected result for " + msg
+                    + ".\n\texpected: " + deepToString(expected)
+                    +  "\n\tactual:   " + deepToString(received));
+        } else {
+            System.out.println("Got expected " + msg + ": " + deepToString(received));
+        }
+    }
+
+    final static 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 basic;
+        final Permissions control;
+        final Permissions all;
+        public final static ThreadLocal<AtomicBoolean> allowAll =
+                new ThreadLocal<AtomicBoolean>() {
+            @Override
+            protected AtomicBoolean initialValue() {
+                return new AtomicBoolean();
+            }
+        };
+        public final static ThreadLocal<AtomicBoolean> allowControl =
+                new ThreadLocal<AtomicBoolean>() {
+            @Override
+            protected AtomicBoolean initialValue() {
+                return new AtomicBoolean();
+            }
+        };
+        public SimplePolicy(TestCase test) {
+            basic = new Permissions();
+            control = new Permissions();
+            control.add(new LoggingPermission("control", null));
+
+            // These permissions are required to call updateConfiguration(Function)
+            control.add(new PropertyPermission("java.util.logging.config.file", "read"));
+            control.add(new PropertyPermission("java.home", "read"));
+            control.add(new FilePermission(
+                    Paths.get(System.getProperty("user.dir", "."),"-").toString(), "read"));
+            control.add(new FilePermission(
+                    Paths.get(System.getProperty("java.home"),"conf","-").toString(), "read"));
+
+            // these are used for configuring the test itself...
+            all = new Permissions();
+            all.add(new java.security.AllPermission());
+
+        }
+
+        @Override
+        public boolean implies(ProtectionDomain domain, Permission permission) {
+            return getPermissions(domain).implies(permission);
+        }
+
+        public PermissionCollection permissions() {
+            PermissionsBuilder builder = new PermissionsBuilder();
+            if (allowAll.get().get()) {
+                builder.addAll(all);
+            } else {
+                builder.addAll(basic);
+                if (allowControl.get().get()) {
+                    builder.addAll(control);
+                }
+            }
+            return builder.toPermissions();
+        }
+
+        @Override
+        public PermissionCollection getPermissions(CodeSource codesource) {
+            return permissions();
+        }
+
+        @Override
+        public PermissionCollection getPermissions(ProtectionDomain domain) {
+            return permissions();
+        }
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/util/logging/LogManager/Configuration/updateConfiguration/UpdateConfigurationTest.java	Mon Oct 12 20:13:22 2015 +0200
@@ -0,0 +1,608 @@
+/*
+ * Copyright (c) 2015, 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.lang.reflect.Field;
+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.Objects;
+import java.util.Properties;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.UUID;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.logging.FileHandler;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+import java.util.logging.LoggingPermission;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * @test
+ * @bug 8033661
+ * @summary tests LogManager.updateConfiguration(bin)
+ * @run main/othervm UpdateConfigurationTest UNSECURE
+ * @run main/othervm UpdateConfigurationTest SECURE
+ * @author danielfuchs
+ */
+public class UpdateConfigurationTest {
+
+    /**
+     * 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, boolean last) throws Exception {
+            System.out.println("Running test case: " + name());
+            Configure.setUp(this);
+            test(this.name() + " " + propertyFile.getProperty("test.name"),
+                    propertyFile, last);
+        }
+    }
+
+
+    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 { APPEND, REPLACE, DEFAULT;
+        boolean append() { return this == APPEND; }
+        Function<String, BiFunction<String,String,String>> remapper() {
+            switch(this) {
+                case APPEND:
+                    return (k) -> ((o,n) -> (n == null ? o : n));
+                case REPLACE:
+                    return (k) -> ((o,n) -> n);
+            }
+            return null;
+        }
+    }
+
+    private static final List<Properties> properties;
+    static {
+        // The test will be run with each of the configurations below.
+        // The 'child' logger is forgotten after each test
+
+        Properties props1 = new Properties();
+        props1.setProperty("test.name", "props1");
+        props1.setProperty("test.config.mode", ConfigMode.REPLACE.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", "props2");
+        props2.setProperty("test.config.mode", ConfigMode.DEFAULT.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.level", "FINE");
+
+        Properties props3 = new Properties();
+        props3.setProperty("test.name", "props3");
+        props3.setProperty("test.config.mode", ConfigMode.APPEND.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", ""); // specify "" to override the value in the previous conf
+        props3.setProperty("com.foo.handlers.ensureCloseOnReset", "false");
+        props3.setProperty("com.bar.level", "FINER");
+
+
+        properties = Collections.unmodifiableList(Arrays.asList(
+                    props1, props2, props3, props1));
+    }
+
+    static Properties previous;
+    static Properties current;
+    static final Field propsField;
+    static {
+        LogManager manager = LogManager.getLogManager();
+        try {
+            propsField = LogManager.class.getDeclaredField("props");
+            propsField.setAccessible(true);
+            previous = current = (Properties) propsField.get(manager);
+        } catch (NoSuchFieldException | IllegalAccessException ex) {
+            throw new ExceptionInInitializerError(ex);
+        }
+    }
+
+    static Properties getProperties() {
+        try {
+            return (Properties) propsField.get(LogManager.getLogManager());
+        } catch (IllegalAccessException x) {
+            throw new RuntimeException(x);
+        }
+    }
+
+    static String trim(String value) {
+        return value == null ? null : value.trim();
+    }
+
+
+    /**
+     * Tests one of the configuration defined above.
+     * <p>
+     * This is the main test method (the rest is infrastructure).
+     * <p>
+     * Creates a child of the com.foo logger (com.foo.child), resets
+     * the configuration, and verifies that com.foo has no handler.
+     * Then reapplies the configuration and verifies that the handler
+     * for com.foo has been reestablished, depending on whether
+     * java.util.logging.LogManager.reconfigureHandlers is present and
+     * true.
+     * <p>
+     * Finally releases the logger com.foo.child, so that com.foo can
+     * be garbage collected, and the next configuration can be
+     * tested.
+     */
+    static void test(ConfigMode mode, String name, Properties props, boolean last)
+            throws Exception {
+
+        // Then create a child of the com.foo logger.
+        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());
+        }
+        Reference<? extends Logger> ref2;
+        int max = 3;
+        barChild = null;
+        while ((ref2 = queue.poll()) == null) {
+            System.gc();
+            Thread.sleep(100);
+            if (--max == 0) break;
+        }
+
+        Throwable failed = null;
+        try {
+            if (ref2 != null) {
+                String refName = ref2 == fooRef ? "fooRef" : ref2 == barRef ? "barRef" : "unknown";
+                if (ref2 != barRef) {
+                    throw new RuntimeException("Unexpected logger reference cleared: " + refName);
+                } else {
+                    System.out.println("Reference " + refName + " cleared as expected");
+                }
+            } else if (ref2 == null) {
+                throw new RuntimeException("Expected 'barRef' to be cleared");
+            }
+            // Now lets try to  check that ref2 has expected handlers, and
+            // attempt to configure again.
+            String p = current.getProperty("com.foo.handlers", "").trim();
+            assertEquals(p.isEmpty() ? 0 : 1, fooChild.getParent().getHandlers().length,
+                    "["+name+"] fooChild.getParent().getHandlers().length");
+            Configure.doPrivileged(() -> Configure.updateConfigurationWith(props, mode.remapper()));
+            String p2 = previous.getProperty("com.foo.handlers", "").trim();
+            assertEquals(p, p2, "["+name+"] com.foo.handlers");
+            String n = trim(props.getProperty("com.foo.handlers", null));
+            boolean hasHandlers = mode.append()
+                    ? (n == null ? !p.isEmpty() : !n.isEmpty())
+                    : n != null && !n.isEmpty();
+            assertEquals( hasHandlers ? 1 : 0,
+                    fooChild.getParent().getHandlers().length,
+                    "["+name+"] fooChild.getParent().getHandlers().length"
+                    + "[p=\""+p+"\", n=" + (n==null?null:"\""+n+"\"") + "]");
+
+            checkProperties(mode, previous, current, props);
+
+        } catch (Throwable t) {
+            failed = t;
+        } finally {
+            if (last || failed != null) {
+                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);
+                    }
+                });
+
+                // Now we need to forget the child, so that loggers are released,
+                // and so that we can run the test with the next configuration...
+
+                fooChild = null;
+                System.out.println("Setting fooChild to: " + fooChild);
+                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(), fooChild is " + fooChild);
+
+            }
+        }
+        if (failed != null) {
+            // should rarely happen...
+            throw new RuntimeException(failed);
+        }
+
+    }
+
+    private static void checkProperties(ConfigMode mode,
+            Properties previous, Properties current, Properties props) {
+        Set<String> set = new HashSet<>();
+
+        // Check that all property names from 'props' are in current.
+        set.addAll(props.stringPropertyNames());
+        set.removeAll(current.keySet());
+        if (!set.isEmpty()) {
+            throw new RuntimeException("Missing properties in current: " + set);
+        }
+        set.clear();
+        set.addAll(current.stringPropertyNames());
+        set.removeAll(previous.keySet());
+        set.removeAll(props.keySet());
+        if (!set.isEmpty()) {
+            throw new RuntimeException("Superfluous properties in current: " + set);
+        }
+        set.clear();
+        Stream<String> allnames =
+                Stream.concat(
+                    Stream.concat(previous.stringPropertyNames().stream(),
+                                  props.stringPropertyNames().stream()),
+                    current.stringPropertyNames().stream())
+                        .collect(Collectors.toCollection(TreeSet::new))
+                        .stream();
+        if (mode.append()) {
+            // Check that all previous property names are in current.
+            set.addAll(previous.stringPropertyNames());
+            set.removeAll(current.keySet());
+            if (!set.isEmpty()) {
+                throw new RuntimeException("Missing properties in current: " + set
+                    + "\n\tprevious: " + previous
+                    + "\n\tcurrent:  " + current
+                    + "\n\tprops:    " + props);
+
+            }
+            allnames.forEach((k) -> {
+                    String p = previous.getProperty(k, "").trim();
+                    String n = current.getProperty(k, "").trim();
+                    if (props.containsKey(k)) {
+                        assertEquals(props.getProperty(k), n, k);
+                    } else {
+                        assertEquals(p, n, k);
+                    }
+                });
+        } else {
+            // Check that only properties from 'props' are in current.
+            set.addAll(current.stringPropertyNames());
+            set.removeAll(props.keySet());
+            if (!set.isEmpty()) {
+                throw new RuntimeException("Superfluous properties in current: " + set);
+            }
+            allnames.forEach((k) -> {
+                    String p = previous.getProperty(k, "");
+                    String n = current.getProperty(k, "");
+                    if (props.containsKey(k)) {
+                        assertEquals(props.getProperty(k), n, k);
+                    } else {
+                        assertEquals("", n, k);
+                    }
+                });
+        }
+
+    }
+
+    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) {
+                TestCase test = TestCase.valueOf(testName);
+                for (int i=0; i<properties.size();i++) {
+                    Properties propertyFile = properties.get(i);
+                    test.run(propertyFile, i == properties.size() - 1);
+                }
+            }
+        } 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 ThreadLocal<AtomicBoolean> allowAll = new ThreadLocal<AtomicBoolean>() {
+            @Override
+            protected AtomicBoolean initialValue() {
+                return  new AtomicBoolean(false);
+            }
+        };
+        static void setUp(TestCase test) {
+            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);
+            }
+        }
+
+        static void updateConfigurationWith(Properties propertyFile,
+                Function<String,BiFunction<String,String,String>> remapper) {
+            try {
+                ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+                propertyFile.store(bytes, propertyFile.getProperty("test.name"));
+                ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());
+                LogManager.getLogManager().updateConfiguration(bais, remapper);
+            } catch (IOException ex) {
+                throw new RuntimeException(ex);
+            }
+        }
+
+        static void doPrivileged(Runnable run) {
+            final boolean old = allowAll.get().getAndSet(true);
+            try {
+                Properties before = getProperties();
+                try {
+                    run.run();
+                } finally {
+                    Properties after = getProperties();
+                    if (before != after) {
+                        previous = before;
+                        current = after;
+                    }
+                }
+            } finally {
+                allowAll.get().set(old);
+            }
+        }
+        static <T> T callPrivileged(Callable<T> call) throws Exception {
+            final boolean old = allowAll.get().getAndSet(true);
+            try {
+                Properties before = getProperties();
+                try {
+                    return call.call();
+                } finally {
+                    Properties after = getProperties();
+                    if (before != after) {
+                        previous = before;
+                        current = after;
+                    }
+                }
+            } finally {
+                allowAll.get().set(old);
+            }
+        }
+    }
+
+    @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);
+        }
+    }
+
+    private static void assertEquals(String expected, String received, String msg) {
+        if (!Objects.equals(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, boolean last) 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 REPLACE:
+            case APPEND:
+            case DEFAULT:
+                test(configMode, name, props, last); break;
+            default:
+                throw new RuntimeException("Unknwown mode: " + configMode);
+        }
+    }
+
+    final static 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 ThreadLocal<AtomicBoolean> allowAll; // actually: this should be in a thread locale
+        public SimplePolicy(TestCase test, ThreadLocal<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().get()) return allPermissions.implies(permission);
+            return permissions.implies(permission);
+        }
+
+        @Override
+        public PermissionCollection getPermissions(CodeSource codesource) {
+            return new PermissionsBuilder().addAll(allowAll.get().get()
+                    ? allPermissions : permissions).toPermissions();
+        }
+
+        @Override
+        public PermissionCollection getPermissions(ProtectionDomain domain) {
+            return new PermissionsBuilder().addAll(allowAll.get().get()
+                    ? allPermissions : permissions).toPermissions();
+        }
+    }
+
+}