--- /dev/null	2012-12-12 10:31:24.337136170 -0800
+++ new/test/java/util/logging/LoggerSupplierAPIsTest.java	2012-12-20 21:36:14.934786521 -0800
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) 2012, 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.
+ */
+
+/*
+ * @test
+ * @bug 8005263
+ * @run testng LoggerSupplierAPIsTest
+ */
+
+import java.util.logging.Logger;
+import java.util.logging.Level;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+import java.util.function.Supplier;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Collections;
+
+import org.testng.annotations.Test;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+
+@Test(groups="unit")
+public class LoggerSupplierAPIsTest {
+    static class CountingSupplier implements Supplier<String> {
+        AtomicInteger sno = new AtomicInteger();
+
+        @Override
+        public String get() {
+            return "Log message " + sno.getAndIncrement();
+        }
+
+        public int getCount() { return sno.get(); }
+        public void reset() { sno.set(0); }
+    }
+
+    static class CountingHandler extends Handler {
+        AtomicInteger count = new AtomicInteger();
+        ArrayList<LogRecord> ar = new ArrayList<>();
+
+        @Override
+        public void close() { reset(); }
+
+        @Override
+        public void flush() { reset(); }
+
+        @Override
+        public void publish(LogRecord lr) {
+            // Can do some more assertion here?
+            // System.out.println(lr.getMessage());
+            count.incrementAndGet();
+        }
+
+        public int getCount() {
+            return count.get();
+        }
+
+        public List<LogRecord> getLogs() {
+            return Collections.unmodifiableList(ar);
+        }
+
+        public void reset() {
+            count.set(0);
+            ar.clear();
+        }
+    }
+
+    static class HelperEx extends Exception {
+        final Level level;
+        HelperEx(Level l) { level = l; }
+        Level getLevel() { return level; }
+    }
+
+    static class SystemInfo {
+        public static String Java() {
+            return "Java: " + System.getProperty("java.version") +
+                   " installed at " + System.getProperty("java.home");
+        }
+
+        public static String OS() {
+            return "OS: " + System.getProperty("os.name") +
+                   " " + System.getProperty("os.version") +
+                   " " + System.getProperty("os.arch");
+        }
+    }
+
+    static final CountingSupplier supplier = new CountingSupplier();
+    static final CountingHandler handler = new CountingHandler();
+    static final Logger logger;
+    static final Level[] levels = { Level.ALL, Level.OFF, Level.SEVERE,
+                                    Level.WARNING, Level.INFO, Level.CONFIG,
+                                    Level.FINE, Level.FINER, Level.FINEST };
+    static final int[] invokes = { 7, 0, 1, 2, 3, 4, 5, 6, 7 };
+    static final int[] log_count = { 10, 0, 1, 2, 3, 4, 6, 8, 10 };
+
+    static {
+        logger = Logger.getLogger("LoggerSupplierApisTest");
+        logger.setUseParentHandlers(false);
+        logger.addHandler(handler);
+    }
+
+    public void setup() {
+        supplier.reset();
+        handler.reset();
+    }
+
+    private void testLog() {
+        logger.log(Level.SEVERE, supplier);
+        logger.log(Level.WARNING, supplier);
+        logger.log(Level.INFO, supplier);
+        logger.log(Level.CONFIG, supplier);
+        logger.log(Level.FINE, supplier);
+        logger.log(Level.FINER, supplier);
+        logger.log(Level.FINEST, supplier);
+        // Lambda expression
+        logger.log(Level.FINE, () ->
+            "Timestamp: " + System.currentTimeMillis() +
+            ", user home directory:  " + System.getProperty("user.home"));
+        // Method reference
+        logger.log(Level.FINER, SystemInfo::Java);
+        logger.log(Level.FINEST, SystemInfo::OS);
+    }
+
+    private void testLogThrown() {
+        logger.logEx(Level.SEVERE, supplier, new HelperEx(Level.SEVERE));
+        logger.logEx(Level.WARNING, supplier, new HelperEx(Level.WARNING));
+        logger.logEx(Level.INFO, supplier, new HelperEx(Level.INFO));
+        logger.logEx(Level.CONFIG, supplier, new HelperEx(Level.CONFIG));
+        logger.logEx(Level.FINE, supplier, new HelperEx(Level.FINE));
+        logger.logEx(Level.FINER, supplier, new HelperEx(Level.FINER));
+        logger.logEx(Level.FINEST, supplier, new HelperEx(Level.FINEST));
+        // Lambda expression
+        logger.logEx(Level.FINE, () ->
+            "Timestamp: " + System.currentTimeMillis() +
+            ", user home directory:  " + System.getProperty("user.home"),
+            new HelperEx(Level.FINE));
+        // Method reference
+        logger.logEx(Level.FINER, SystemInfo::Java, new HelperEx(Level.FINER));
+        logger.logEx(Level.FINEST, SystemInfo::OS, new HelperEx(Level.FINEST));
+    }
+
+    private void testLogp() {
+        final String cls = getClass().getName();
+        final String mtd = "testLogp";
+
+        logger.logp(Level.SEVERE, cls, mtd, supplier);
+        logger.logp(Level.WARNING, cls, mtd, supplier);
+        logger.logp(Level.INFO, cls, mtd, supplier);
+        logger.logp(Level.CONFIG, cls, mtd, supplier);
+        logger.logp(Level.FINE, cls, mtd, supplier);
+        logger.logp(Level.FINER, cls, mtd, supplier);
+        logger.logp(Level.FINEST, cls, mtd, supplier);
+        // Lambda expression
+        logger.logp(Level.FINE, cls, mtd, () ->
+            "Timestamp: " + System.currentTimeMillis() +
+            ", user home directory:  " + System.getProperty("user.home"));
+        // Method reference
+        logger.logp(Level.FINER, cls, mtd, SystemInfo::Java);
+        logger.logp(Level.FINEST, cls, mtd, SystemInfo::OS);
+    }
+
+    private void testLogpThrown() {
+        final String cls = getClass().getName();
+        final String mtd = "testLogpThrown";
+
+        logger.logpEx(Level.SEVERE, cls, mtd, supplier, new HelperEx(Level.SEVERE));
+        logger.logpEx(Level.WARNING, cls, mtd, supplier, new HelperEx(Level.WARNING));
+        logger.logpEx(Level.INFO, cls, mtd, supplier, new HelperEx(Level.INFO));
+        logger.logpEx(Level.CONFIG, cls, mtd, supplier, new HelperEx(Level.CONFIG));
+        logger.logpEx(Level.FINE, cls, mtd, supplier, new HelperEx(Level.FINE));
+        logger.logpEx(Level.FINER, cls, mtd, supplier, new HelperEx(Level.FINER));
+        logger.logpEx(Level.FINEST, cls, mtd, supplier, new HelperEx(Level.FINEST));
+        // Lambda expression
+        logger.logpEx(Level.FINE, cls, mtd, () ->
+            "Timestamp: " + System.currentTimeMillis() +
+            ", user home directory:  " + System.getProperty("user.home"),
+            new HelperEx(Level.FINE));
+        // Method reference
+        logger.logpEx(Level.FINER, cls, mtd, SystemInfo::Java, new HelperEx(Level.FINER));
+        logger.logpEx(Level.FINEST, cls, mtd, SystemInfo::OS, new HelperEx(Level.FINEST));
+    }
+
+    private void testLevelConvenientMethods() {
+        logger.severe(supplier);
+        logger.warning(supplier);
+        logger.info(supplier);
+        logger.config(supplier);
+        logger.fine(supplier);
+        logger.finer(supplier);
+        logger.finest(supplier);
+        // Lambda expression
+        logger.fine(() ->
+            "Timestamp: " + System.currentTimeMillis() +
+            ", user home directory:  " + System.getProperty("user.home"));
+        // Method reference
+        logger.finer(SystemInfo::Java);
+        logger.finest(SystemInfo::OS);
+    }
+
+    private void validate(int index, boolean thrown, String methodName) {
+        assertEquals(supplier.getCount(), invokes[index]);
+        assertEquals(handler.getCount(), log_count[index]);
+        // Verify associated Throwable is right
+        if (thrown) {
+            for (LogRecord r: handler.getLogs()) {
+                assertTrue(r.getThrown() instanceof HelperEx, "Validate Thrown");
+                HelperEx e = (HelperEx) r.getThrown();
+                assertEquals(r.getLevel(), e.getLevel(), "Validate Thrown Log Level");
+            }
+        }
+
+        if (methodName != null) {
+            for (LogRecord r: handler.getLogs()) {
+                assertEquals(r.getSourceClassName(), getClass().getName());
+                assertEquals(r.getSourceMethodName(), methodName);
+            }
+        }
+    }
+
+    public void verifyLogLevel() {
+        for (int i = 0; i < levels.length; i++) {
+            logger.setLevel(levels[i]);
+
+            setup();
+            testLog();
+            validate(i, false, null);
+
+            setup();
+            testLogThrown();
+            validate(i, true, null);
+
+            setup();
+            testLogp();
+            validate(i, false, "testLogp");
+
+            setup();
+            testLogpThrown();
+            validate(i, true, "testLogpThrown");
+
+            setup();
+            testLevelConvenientMethods();
+            validate(i, false, null);
+        }
+    }
+}