1 /* 2 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /* 25 * @test 26 * @bug 8005263 27 * @run testng LoggerSupplierAPIsTest 28 */ 29 30 import java.util.logging.Logger; 31 import java.util.logging.Level; 32 import java.util.logging.Handler; 33 import java.util.logging.LogRecord; 34 import java.util.function.Supplier; 35 import java.util.concurrent.atomic.AtomicInteger; 36 import java.util.ArrayList; 37 import java.util.List; 38 import java.util.Collections; 39 40 import org.testng.annotations.Test; 41 import static org.testng.Assert.assertEquals; 42 import static org.testng.Assert.assertTrue; 43 44 @Test(groups="unit") 45 public class LoggerSupplierAPIsTest { 46 static class CountingSupplier implements Supplier<String> { 47 AtomicInteger sno = new AtomicInteger(); 48 49 @Override get()50 public String get() { 51 return "Log message " + sno.getAndIncrement(); 52 } 53 getCount()54 public int getCount() { return sno.get(); } reset()55 public void reset() { sno.set(0); } 56 } 57 58 static class CountingHandler extends Handler { 59 AtomicInteger count = new AtomicInteger(); 60 ArrayList<LogRecord> ar = new ArrayList<>(); 61 62 @Override close()63 public void close() { reset(); } 64 65 @Override flush()66 public void flush() { reset(); } 67 68 @Override publish(LogRecord lr)69 public void publish(LogRecord lr) { 70 // Can do some more assertion here? 71 // System.out.println(lr.getMessage()); 72 count.incrementAndGet(); 73 } 74 getCount()75 public int getCount() { 76 return count.get(); 77 } 78 getLogs()79 public List<LogRecord> getLogs() { 80 return Collections.unmodifiableList(ar); 81 } 82 reset()83 public void reset() { 84 count.set(0); 85 ar.clear(); 86 } 87 } 88 89 static class HelperEx extends Exception { 90 final Level level; HelperEx(Level l)91 HelperEx(Level l) { level = l; } getLevel()92 Level getLevel() { return level; } 93 } 94 95 static class SystemInfo { Java()96 public static String Java() { 97 return "Java: " + System.getProperty("java.version") + 98 " installed at " + System.getProperty("java.home"); 99 } 100 OS()101 public static String OS() { 102 return "OS: " + System.getProperty("os.name") + 103 " " + System.getProperty("os.version") + 104 " " + System.getProperty("os.arch"); 105 } 106 } 107 108 static final CountingSupplier supplier = new CountingSupplier(); 109 static final CountingHandler handler = new CountingHandler(); 110 static final Logger logger; 111 static final Level[] levels = { Level.ALL, Level.OFF, Level.SEVERE, 112 Level.WARNING, Level.INFO, Level.CONFIG, 113 Level.FINE, Level.FINER, Level.FINEST }; 114 static final int[] invokes = { 7, 0, 1, 2, 3, 4, 5, 6, 7 }; 115 static final int[] log_count = { 10, 0, 1, 2, 3, 4, 6, 8, 10 }; 116 117 static { 118 logger = Logger.getLogger("LoggerSupplierApisTest"); 119 logger.setUseParentHandlers(false); 120 logger.addHandler(handler); 121 } 122 setup()123 public void setup() { 124 supplier.reset(); 125 handler.reset(); 126 } 127 testLog()128 private void testLog() { 129 logger.log(Level.SEVERE, supplier); 130 logger.log(Level.WARNING, supplier); 131 logger.log(Level.INFO, supplier); 132 logger.log(Level.CONFIG, supplier); 133 logger.log(Level.FINE, supplier); 134 logger.log(Level.FINER, supplier); 135 logger.log(Level.FINEST, supplier); 136 // Lambda expression 137 logger.log(Level.FINE, () -> 138 "Timestamp: " + System.currentTimeMillis() + 139 ", user home directory: " + System.getProperty("user.home")); 140 // Method reference 141 logger.log(Level.FINER, SystemInfo::Java); 142 logger.log(Level.FINEST, SystemInfo::OS); 143 } 144 testLogThrown()145 private void testLogThrown() { 146 logger.log(Level.SEVERE, new HelperEx(Level.SEVERE), supplier); 147 logger.log(Level.WARNING, new HelperEx(Level.WARNING), supplier); 148 logger.log(Level.INFO, new HelperEx(Level.INFO), supplier); 149 logger.log(Level.CONFIG, new HelperEx(Level.CONFIG), supplier); 150 logger.log(Level.FINE, new HelperEx(Level.FINE), supplier); 151 logger.log(Level.FINER, new HelperEx(Level.FINER), supplier); 152 logger.log(Level.FINEST, new HelperEx(Level.FINEST), supplier); 153 // Lambda expression 154 logger.log(Level.FINE, new HelperEx(Level.FINE), () -> 155 "Timestamp: " + System.currentTimeMillis() + 156 ", user home directory: " + System.getProperty("user.home")); 157 // Method reference 158 logger.log(Level.FINER, new HelperEx(Level.FINER), SystemInfo::Java); 159 logger.log(Level.FINEST, new HelperEx(Level.FINEST), SystemInfo::OS); 160 } 161 testLogp()162 private void testLogp() { 163 final String cls = getClass().getName(); 164 final String mtd = "testLogp"; 165 166 logger.logp(Level.SEVERE, cls, mtd, supplier); 167 logger.logp(Level.WARNING, cls, mtd, supplier); 168 logger.logp(Level.INFO, cls, mtd, supplier); 169 logger.logp(Level.CONFIG, cls, mtd, supplier); 170 logger.logp(Level.FINE, cls, mtd, supplier); 171 logger.logp(Level.FINER, cls, mtd, supplier); 172 logger.logp(Level.FINEST, cls, mtd, supplier); 173 // Lambda expression 174 logger.logp(Level.FINE, cls, mtd, () -> 175 "Timestamp: " + System.currentTimeMillis() + 176 ", user home directory: " + System.getProperty("user.home")); 177 // Method reference 178 logger.logp(Level.FINER, cls, mtd, SystemInfo::Java); 179 logger.logp(Level.FINEST, cls, mtd, SystemInfo::OS); 180 } 181 testLogpThrown()182 private void testLogpThrown() { 183 final String cls = getClass().getName(); 184 final String mtd = "testLogpThrown"; 185 186 logger.logp(Level.SEVERE, cls, mtd, new HelperEx(Level.SEVERE), supplier); 187 logger.logp(Level.WARNING, cls, mtd, new HelperEx(Level.WARNING), supplier); 188 logger.logp(Level.INFO, cls, mtd, new HelperEx(Level.INFO), supplier); 189 logger.logp(Level.CONFIG, cls, mtd, new HelperEx(Level.CONFIG), supplier); 190 logger.logp(Level.FINE, cls, mtd, new HelperEx(Level.FINE), supplier); 191 logger.logp(Level.FINER, cls, mtd, new HelperEx(Level.FINER), supplier); 192 logger.logp(Level.FINEST, cls, mtd, new HelperEx(Level.FINEST), supplier); 193 // Lambda expression 194 logger.logp(Level.FINE, cls, mtd, new HelperEx(Level.FINE), () -> 195 "Timestamp: " + System.currentTimeMillis() + 196 ", user home directory: " + System.getProperty("user.home")); 197 // Method reference 198 logger.logp(Level.FINER, cls, mtd, new HelperEx(Level.FINER), SystemInfo::Java); 199 logger.logp(Level.FINEST, cls, mtd, new HelperEx(Level.FINEST), SystemInfo::OS); 200 } 201 testLevelConvenientMethods()202 private void testLevelConvenientMethods() { 203 logger.severe(supplier); 204 logger.warning(supplier); 205 logger.info(supplier); 206 logger.config(supplier); 207 logger.fine(supplier); 208 logger.finer(supplier); 209 logger.finest(supplier); 210 // Lambda expression 211 logger.fine(() -> 212 "Timestamp: " + System.currentTimeMillis() + 213 ", user home directory: " + System.getProperty("user.home")); 214 // Method reference 215 logger.finer(SystemInfo::Java); 216 logger.finest(SystemInfo::OS); 217 } 218 validate(int index, boolean thrown, String methodName)219 private void validate(int index, boolean thrown, String methodName) { 220 assertEquals(supplier.getCount(), invokes[index]); 221 assertEquals(handler.getCount(), log_count[index]); 222 // Verify associated Throwable is right 223 if (thrown) { 224 for (LogRecord r: handler.getLogs()) { 225 assertTrue(r.getThrown() instanceof HelperEx, "Validate Thrown"); 226 HelperEx e = (HelperEx) r.getThrown(); 227 assertEquals(r.getLevel(), e.getLevel(), "Validate Thrown Log Level"); 228 } 229 } 230 231 if (methodName != null) { 232 for (LogRecord r: handler.getLogs()) { 233 assertEquals(r.getSourceClassName(), getClass().getName()); 234 assertEquals(r.getSourceMethodName(), methodName); 235 } 236 } 237 } 238 verifyLogLevel()239 public void verifyLogLevel() { 240 for (int i = 0; i < levels.length; i++) { 241 logger.setLevel(levels[i]); 242 243 setup(); 244 testLog(); 245 validate(i, false, null); 246 247 setup(); 248 testLogThrown(); 249 validate(i, true, null); 250 251 setup(); 252 testLogp(); 253 validate(i, false, "testLogp"); 254 255 setup(); 256 testLogpThrown(); 257 validate(i, true, "testLogpThrown"); 258 259 setup(); 260 testLevelConvenientMethods(); 261 validate(i, false, null); 262 } 263 } 264 } 265