1 /*
2 * Copyright (c) 2014, 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 8046565
27 * @author danielfuchs
28 * @summary JDK implementation specific unit test for JDK internal artifacts.
29 * This test tests all the public API methods defined in the {@link
30 * java.lang.System.Logger} interface, as well as all the JDK
31 * internal methods defined in the
32 * {@link sun.util.logging.PlatformLoggerBridge}
33 * interface, with loggers returned by {@link
34 * java.lang.System.LoggerFinder#getLogger(java.lang.String, java.lang.Class)}
35 * and {@link java.lang.System.LoggerFinder#getLocalizedLogger(java.lang.String,
36 * java.util.ResourceBundle, java.lang.Class)}
37 * (using both a null resource bundle and a non null resource bundle).
38 * It calls both the {@link java.lang.System} factory methods and
39 * {@link sun.util.logger.LazyLoggers} to obtains those loggers,
40 * and configure them with all possible known levels.
41 * @modules java.base/sun.util.logging
42 * java.base/sun.util.logger
43 * @build LoggerFinderBackendTest SystemClassLoader
44 * @run main/othervm -Djava.system.class.loader=SystemClassLoader -Dtest.logger.hidesProvider=true LoggerFinderBackendTest
45 * @run main/othervm -Djava.system.class.loader=SystemClassLoader -Dtest.logger.hidesProvider=false LoggerFinderBackendTest
46 */
47
48
49 import java.lang.invoke.MethodHandle;
50 import java.lang.invoke.MethodHandles;
51 import java.lang.invoke.MethodHandles.Lookup;
52 import java.lang.invoke.MethodType;
53 import java.lang.reflect.InvocationTargetException;
54 import java.lang.reflect.Method;
55 import java.util.ArrayList;
56 import java.util.Arrays;
57 import java.util.Collections;
58 import java.util.Enumeration;
59 import java.util.HashMap;
60 import java.util.LinkedHashMap;
61 import java.util.LinkedHashSet;
62 import java.util.List;
63 import java.util.Map;
64 import java.util.Objects;
65 import java.util.ResourceBundle;
66 import java.util.concurrent.atomic.AtomicInteger;
67 import java.util.function.BiFunction;
68 import java.util.function.BooleanSupplier;
69 import java.util.function.Function;
70 import java.util.function.Supplier;
71 import java.lang.System.LoggerFinder;
72 import java.util.logging.ConsoleHandler;
73 import java.util.logging.Handler;
74 import sun.util.logging.PlatformLogger.Level;
75 import java.util.logging.LogManager;
76 import java.util.logging.LogRecord;
77 import java.util.logging.Logger;
78
79 /**
80 * @author danielfuchs
81 */
82 public class LoggerFinderBackendTest {
83
84 // whether the implementation of Logger try to do a best
85 // effort for logp... If the provider is not hidden, then
86 // the logp() implementation comes from LoggerWrapper - which does a
87 // best effort. Otherwise, it comes from the default provider
88 // which does support logp.
89 static final boolean BEST_EFFORT_FOR_LOGP =
90 !Boolean.getBoolean("test.logger.hidesProvider");
91 static final boolean VERBOSE = false;
92
93 static final Class<java.lang.System.Logger> spiLoggerClass =
94 java.lang.System.Logger.class;
95 static final Class<java.lang.System.Logger> jdkLoggerClass =
96 java.lang.System.Logger.class;
97 static final Class<sun.util.logging.PlatformLoggerBridge> bridgeLoggerClass =
98 sun.util.logging.PlatformLoggerBridge.class;
99
100 /** Use to retrieve the log records that were produced by the JUL backend */
101 static class LoggerTesterHandler extends Handler {
102 public final List<LogRecord> records =
103 Collections.synchronizedList(new ArrayList<>());
104
105 @Override
106 public void publish(LogRecord record) {
107 record.getSourceClassName(); record.getSourceMethodName();
108 records.add(record);
109 }
110
111 @Override
112 public void flush() {
113 }
114
115 @Override
116 public void close() throws SecurityException {
117 records.clear();
118 }
119
120 public void reset() {
121 records.clear();
122 }
123 }
124
125 /** The {@link LoggerTesterHandler} handler is added to the root logger. */
126 static final LoggerTesterHandler handler = new LoggerTesterHandler();
127 static {
128 for (Handler h : Logger.getLogger("").getHandlers()) {
129 if (h instanceof ConsoleHandler) {
130 Logger.getLogger("").removeHandler(h);
131 }
132 }
133 Logger.getLogger("").addHandler(handler);
134 }
135
136 /**
137 * A resource handler parameter that will be used when calling out the
138 * logrb-like methods - as well as when calling the level-specific
139 * methods that take a ResourceBundle parameter.
140 */
141 public static class ResourceBundeParam extends ResourceBundle {
142 Map<String, String> map = Collections.synchronizedMap(new LinkedHashMap<>());
143 @Override
144 protected Object handleGetObject(String key) {
145 map.putIfAbsent(key, "${"+key+"}");
146 return map.get(key);
147 }
148
149 @Override
150 public Enumeration<String> getKeys() {
151 return Collections.enumeration(new LinkedHashSet<>(map.keySet()));
152 }
153
154 }
155
156 final static ResourceBundle bundleParam =
157 ResourceBundle.getBundle(ResourceBundeParam.class.getName());
158
159 /**
160 * A resource handler parameter that will be used when creating localized
161 * loggers by calling {@link
162 * LoggerFinder#getLocalizedLogger(java.lang.String, java.util.ResourceBundle, java.lang.Class)}.
163 */
164 public static class ResourceBundeLocalized extends ResourceBundle {
165 Map<String, String> map = Collections.synchronizedMap(new LinkedHashMap<>());
166 @Override
167 protected Object handleGetObject(String key) {
168 map.putIfAbsent(key, "Localized:${"+key+"}");
169 return map.get(key);
170 }
171
172 @Override
173 public Enumeration<String> getKeys() {
174 return Collections.enumeration(new LinkedHashSet<>(map.keySet()));
175 }
176
177 }
178
179 /**
180 * The Levels enum is used to call all the level-specific methods on
181 * a logger instance. To minimize the amount of code it uses reflection
182 * to do so.
183 */
184 static Lookup lookup = MethodHandles.lookup();
185 public enum Levels {
186 /** Used to call all forms of Logger.log?(SEVERE, ...) */
187 SEVERE("severe", bridgeLoggerClass, Level.SEVERE, null, "error", false),
188 /** Used to call all forms of Logger.log?(WARNING,...) */
189 WARNING("warning", bridgeLoggerClass, Level.WARNING, "warning", "warning", false),
190 /** Used to call all forms of Logger.log?(INFO,...) */
191 INFO("info", bridgeLoggerClass, Level.INFO, "info", "info", false),
192 /** Used to call all forms of Logger.log?(CONFIG,...) */
193 CONFIG("config", bridgeLoggerClass, Level.CONFIG, null, "debug", false),
194 /** Used to call all forms of Logger.log?(FINE,...) */
195 FINE("fine", bridgeLoggerClass, Level.FINE, null, "debug", false),
196 /** Used to call all forms of Logger.log?(FINER,...) */
197 FINER("finer", bridgeLoggerClass, Level.FINER, null, "trace", false),
198 /** Used to call all forms of Logger.log?(FINEST,...) */
199 FINEST("finest", bridgeLoggerClass, Level.FINEST, null, "trace", false),
200 ;
201 public final String method; // The name of the level-specific method to call
202 public final Class<?> definingClass; // which interface j.u.logger.Logger or j.u.logging.spi.Logger defines it
203 public final Level platformLevel; // The platform Level it will be mapped to in Jul when Jul is the backend
204 public final String jdkExtensionToJUL; // The name of the method called on the JUL logger when JUL is the backend
205 public final String julToJdkExtension; // The name of the method called in the jdk extension by the default impl in jdk.internal.logging.Logger
206 public final String enableMethod; // The name of the isXxxxEnabled method
207 public final boolean hasSpecificIsEnabled;
208 Levels(String method, Class<?> definingClass, Level defaultMapping,
209 String jdkExtensionToJUL, String julToJdkExtension,
210 boolean hasSpecificIsEnabled) {
211 this.method = method;
212 this.definingClass = definingClass;
213 this.platformLevel = defaultMapping;
214 this.jdkExtensionToJUL = jdkExtensionToJUL;
215 this.julToJdkExtension = julToJdkExtension;
216 this.hasSpecificIsEnabled = hasSpecificIsEnabled;
217 if (hasSpecificIsEnabled) {
218 this.enableMethod = "is" + method.substring(0,1).toUpperCase()
219 + method.substring(1) + "Enabled";
220 } else {
221 this.enableMethod = "isLoggable";
222 }
223 }
224
225 /*
226 * calls this level specific method - e.g. if this==INFO: logger.info(msg);
227 */
228 public void level(Object logger, String msg) {
229 MethodType mt = MethodType.methodType(void.class, Level.class, String.class);
230 invoke("log", logger, mt, platformLevel, msg);
231 }
232
233 /*
234 * calls this level specific method - e.g. if this==INFO: logger.info(msgSupplier);
235 */
236 public void level(Object logger, Supplier<String> msgSupplier) {
237 MethodType mt = MethodType.methodType(void.class, Level.class, Supplier.class);
238 invoke("log", logger, mt, platformLevel, msgSupplier);
239 }
240
241 /*
242 * calls this level specific method - e.g. if this==INFO: logger.info(msg, params);
243 */
244 public void level(Object logger, String msg, Object... params) {
245 MethodType mt = MethodType.methodType(void.class, Level.class, String.class,
246 Object[].class);
247 invoke("log", logger, mt, platformLevel, msg, params);
248 }
249
250 /*
251 * calls this level specific method - e.g. if this==INFO: logger.info(msg, thrown);
252 */
253 public void level(Object logger, String msg, Throwable thrown) {
254 MethodType mt = MethodType.methodType(void.class, Level.class, String.class,
255 Throwable.class);
256 invoke("log", logger, mt, platformLevel, msg, thrown);
257 }
258
259 /*
260 * calls this level specific method - e.g. if this==INFO: logger.info(msgSupplier, thrown);
261 */
262 public void level(Object logger, Supplier<String> msgSupplier, Throwable thrown) {
263 MethodType mt = MethodType.methodType(void.class, Level.class,
264 Throwable.class, Supplier.class);
265 invoke("log", logger, mt, platformLevel, thrown, msgSupplier);
266 }
267
268 /*
269 * calls this level specific method - e.g. if this==INFO: logger.info(bundle, msg);
270 */
271 public void level(Object logger, String msg, ResourceBundle bundle) {
272 MethodType mt = MethodType.methodType(void.class, Level.class,
273 ResourceBundle.class, String.class, Object[].class);
274 invoke("logrb", logger, mt, platformLevel, bundle, msg, null);
275 }
276
277 public void level(Object logger, String msg, ResourceBundle bundle,
278 Object... params) {
279 MethodType mt = MethodType.methodType(void.class, Level.class,
280 ResourceBundle.class, String.class, Object[].class);
281 invoke("logrb", logger, mt, platformLevel, bundle, msg, params);
282 }
283
284 public void level(Object logger, String msg, ResourceBundle bundle,
285 Throwable thrown) {
286 MethodType mt = MethodType.methodType(void.class, Level.class,
287 ResourceBundle.class, String.class, Throwable.class);
288 invoke("logrb", logger, mt, platformLevel, bundle, msg, thrown);
289 }
290
291 public boolean isEnabled(Object logger) {
292 try {
293 if (hasSpecificIsEnabled) {
294 MethodType mt = MethodType.methodType(boolean.class);
295 final MethodHandle handle = lookup.findVirtual(definingClass,
296 enableMethod, mt).bindTo(logger);
297 return Boolean.class.cast(handle.invoke());
298 } else {
299 MethodType mt = MethodType.methodType(boolean.class,
300 Level.class);
301 final MethodHandle handle = lookup.findVirtual(definingClass,
302 enableMethod, mt).bindTo(logger);
303 return Boolean.class.cast(handle.invoke(platformLevel));
304 }
305 } catch (Throwable ex) {
306 throw new RuntimeException(ex);
307 }
308 }
309
310 private void invoke(String method, Object logger, MethodType mt, Object... args) {
311 try {
312 final int last = mt.parameterCount()-1;
313 boolean isVarargs = mt.parameterType(last).isArray();
314 final MethodHandle handle = lookup.findVirtual(definingClass,
315 method, mt).bindTo(logger);
316
317 final StringBuilder builder = new StringBuilder();
318 builder.append(logger.getClass().getSimpleName()).append('.')
319 .append(method).append('(');
320 String sep = "";
321 int offset = 0;
322 Object[] params = args;
323 for (int i=0; (i-offset) < params.length; i++) {
324 if (isVarargs && i == last) {
325 offset = last;
326 params = (Object[])args[i];
327 if (params == null) break;
328 }
329 Object p = params[i - offset];
330 String quote = (p instanceof String) ? "\"" : "";
331 builder.append(sep).append(quote).append(p).append(quote);
332 sep = ", ";
333 }
334 builder.append(')');
335 if (verbose) {
336 System.out.println(builder);
337 }
338 handle.invokeWithArguments(args);
339 } catch (Throwable ex) {
340 throw new RuntimeException(ex);
341 }
342 }
343
344 };
345
346 static interface Checker<LogResult, L> extends BiFunction<LogResult, L, Void> {}
347 static interface JdkLogTester
348 extends BiFunction<sun.util.logging.PlatformLoggerBridge, Level, Void> {}
349 static interface SpiLogTester
350 extends BiFunction<java.lang.System.Logger, java.lang.System.Logger.Level, Void> {}
351
352 static interface MethodInvoker<LOGGER, LEVEL> {
353 public void logX(LOGGER logger, LEVEL level, Object... args);
354 }
355
356 public enum JdkLogMethodInvoker
357 implements MethodInvoker<sun.util.logging.PlatformLoggerBridge, Level> {
358 /**
359 * Tests {@link
360 * jdk.internal.logging.Logger#log(Level, String, Object...)};
361 **/
362 LOG_STRING_PARAMS("log", MethodType.methodType(void.class,
363 Level.class, String.class, Object[].class)),
364 /**
365 * Tests {@link
366 * jdk.internal.logging.Logger#log(Level, String, Throwable)};
367 **/
368 LOG_STRING_THROWN("log", MethodType.methodType(void.class,
369 Level.class, String.class, Throwable.class)),
370 /**
371 * Tests {@link
372 * jdk.internal.logging.Logger#log(Level, Supplier<String>)};
373 **/
374 LOG_SUPPLIER("log", MethodType.methodType(void.class,
375 Level.class, Supplier.class)),
376 /**
377 * Tests {@link
378 * jdk.internal.logging.Logger#log(Level, Throwable, Supplier<String>)};
379 **/
380 LOG_SUPPLIER_THROWN("log", MethodType.methodType(void.class,
381 Level.class, Throwable.class, Supplier.class)),
382 /**
383 * Tests {@link
384 * jdk.internal.logging.Logger#logp(Level, String, String, String)};
385 **/
386 LOGP_STRING("logp", MethodType.methodType(void.class,
387 Level.class, String.class, String.class, String.class)),
388 /**
389 * Tests {@link
390 * jdk.internal.logging.Logger#logp(Level, String, String, String, Object...)};
391 **/
392 LOGP_STRING_PARAMS("logp", MethodType.methodType(void.class,
393 Level.class, String.class, String.class, String.class, Object[].class)),
394 /**
395 * Tests {@link
396 * jdk.internal.logging.Logger#logp(Level, String, String, String, Throwable)};
397 **/
398 LOGP_STRING_THROWN("logp", MethodType.methodType(void.class,
399 Level.class, String.class, String.class, String.class, Throwable.class)),
400 /**
401 * Tests {@link
402 * jdk.internal.logging.Logger#logp(Level, String, String, Supplier<String>)};
403 **/
404 LOGP_SUPPLIER("logp", MethodType.methodType(void.class,
405 Level.class, String.class, String.class, Supplier.class)),
406 /**
407 * Tests {@link
408 * jdk.internal.logging.Logger#logp(Level, String, String, Throwable, Supplier<String>)};
409 **/
410 LOGP_SUPPLIER_THROWN("logp", MethodType.methodType(void.class,
411 Level.class, String.class, String.class,
412 Throwable.class, Supplier.class)),
413 /**
414 * Tests {@link
415 * jdk.internal.logging.Logger#logrb(Level, ResourceBundle, String, Object...)};
416 **/
417 LOGRB_STRING_PARAMS("logrb", MethodType.methodType(void.class,
418 Level.class, ResourceBundle.class, String.class, Object[].class)),
419 /**
420 * Tests {@link
421 * jdk.internal.logging.Logger#logrb(Level, ResourceBundle, String, Throwable)};
422 **/
423 LOGRB_STRING_THROWN("logrb", MethodType.methodType(void.class,
424 Level.class, ResourceBundle.class, String.class, Throwable.class)),
425 /**
426 * Tests {@link
427 * jdk.internal.logging.Logger#logrb(Level, String, String, ResourceBundle, String, Object...)};
428 **/
429 LOGRBP_STRING_PARAMS("logrb", MethodType.methodType(void.class,
430 Level.class, String.class, String.class, ResourceBundle.class,
431 String.class, Object[].class)),
432 /**
433 * Tests {@link
434 * jdk.internal.logging.Logger#logrb(Level, String, String, ResourceBundle, String, Throwable)};
435 **/
436 LOGRBP_STRING_THROWN("logrb", MethodType.methodType(void.class,
437 Level.class, String.class, String.class, ResourceBundle.class,
438 String.class, Throwable.class)),
439 ;
440 final MethodType mt;
441 final String method;
442 JdkLogMethodInvoker(String method, MethodType mt) {
443 this.mt = mt;
444 this.method = method;
445 }
446 Object[] makeArgs(Level level, Object... rest) {
447 List<Object> list = new ArrayList<>(rest == null ? 1 : rest.length + 1);
448 list.add(level);
449 if (rest != null) {
450 list.addAll(Arrays.asList(rest));
451 }
452 return list.toArray(new Object[list.size()]);
453 }
454
455 @Override
456 public void logX(sun.util.logging.PlatformLoggerBridge logger, Level level, Object... args) {
457 try {
458 MethodHandle handle = lookup.findVirtual(bridgeLoggerClass,
459 method, mt).bindTo(logger);
460 final int last = mt.parameterCount()-1;
461 boolean isVarargs = mt.parameterType(last).isArray();
462
463 args = makeArgs(level, args);
464
465 final StringBuilder builder = new StringBuilder();
466 builder.append(logger.getClass().getSimpleName()).append('.')
467 .append(this.method).append('(');
468 String sep = "";
469 int offset = 0;
470 Object[] params = args;
471 for (int i=0; (i-offset) < params.length; i++) {
472 if (isVarargs && i == last) {
473 offset = last;
474 params = (Object[])args[i];
475 if (params == null) break;
476 }
477 Object p = params[i - offset];
478 String quote = (p instanceof String) ? "\"" : "";
479 p = p instanceof Level ? "Level."+p : p;
480 builder.append(sep).append(quote).append(p).append(quote);
481 sep = ", ";
482 }
483 builder.append(')');
484 if (verbose) System.out.println(builder);
485 handle.invokeWithArguments(args);
486 } catch (Throwable ex) {
487 throw new RuntimeException(ex);
488 }
489 }
490 }
491
492
493 public enum SpiLogMethodInvoker implements MethodInvoker<java.lang.System.Logger,
494 java.lang.System.Logger.Level> {
495 /**
496 * Tests {@link
497 * jdk.internal.logging.Logger#log(Level, String, Object...)};
498 **/
499 LOG_STRING_PARAMS("log", MethodType.methodType(void.class,
500 java.lang.System.Logger.Level.class, String.class, Object[].class)),
501 /**
502 * Tests {@link
503 * jdk.internal.logging.Logger#log(Level, String, Throwable)};
504 **/
505 LOG_STRING_THROWN("log", MethodType.methodType(void.class,
506 java.lang.System.Logger.Level.class, String.class, Throwable.class)),
507 /**
508 * Tests {@link
509 * jdk.internal.logging.Logger#log(Level, Supplier<String>)};
510 **/
511 LOG_SUPPLIER("log", MethodType.methodType(void.class,
512 java.lang.System.Logger.Level.class, Supplier.class)),
513 /**
514 * Tests {@link
515 * jdk.internal.logging.Logger#log(Level, Throwable, Supplier<String>)};
516 **/
517 LOG_SUPPLIER_THROWN("log", MethodType.methodType(void.class,
518 java.lang.System.Logger.Level.class, Supplier.class, Throwable.class)),
519 /**
520 * Tests {@link
521 * jdk.internal.logging.Logger#log(Level, Supplier<String>)};
522 **/
523 LOG_OBJECT("log", MethodType.methodType(void.class,
524 java.lang.System.Logger.Level.class, Object.class)),
525 /**
526 * Tests {@link
527 * jdk.internal.logging.Logger#logrb(Level, ResourceBundle, String, Object...)};
528 **/
529 LOGRB_STRING_PARAMS("log", MethodType.methodType(void.class,
530 java.lang.System.Logger.Level.class, ResourceBundle.class,
531 String.class, Object[].class)),
532 /**
533 * Tests {@link
534 * jdk.internal.logging.Logger#logrb(Level, ResourceBundle, String, Throwable)};
535 **/
536 LOGRB_STRING_THROWN("log", MethodType.methodType(void.class,
537 java.lang.System.Logger.Level.class, ResourceBundle.class,
538 String.class, Throwable.class)),
539 ;
540 final MethodType mt;
541 final String method;
542 SpiLogMethodInvoker(String method, MethodType mt) {
543 this.mt = mt;
544 this.method = method;
545 }
546 Object[] makeArgs(java.lang.System.Logger.Level level, Object... rest) {
547 List<Object> list = new ArrayList<>(rest == null ? 1 : rest.length + 1);
548 list.add(level);
549 if (rest != null) {
550 list.addAll(Arrays.asList(rest));
551 }
552 return list.toArray(new Object[list.size()]);
553 }
554
555 @Override
556 public void logX(java.lang.System.Logger logger,
557 java.lang.System.Logger.Level level, Object... args) {
558 try {
559 MethodHandle handle = lookup.findVirtual(spiLoggerClass,
560 method, mt).bindTo(logger);
561 final int last = mt.parameterCount()-1;
562 boolean isVarargs = mt.parameterType(last).isArray();
563
564 args = makeArgs(level, args);
565
566 final StringBuilder builder = new StringBuilder();
567 builder.append(logger.getClass().getSimpleName()).append('.')
568 .append(this.method).append('(');
569 String sep = "";
570 int offset = 0;
571 Object[] params = args;
572 for (int i=0; (i-offset) < params.length; i++) {
573 if (isVarargs && i == last) {
574 offset = last;
575 params = (Object[])args[i];
576 if (params == null) break;
577 }
578 Object p = params[i - offset];
579 String quote = (p instanceof String) ? "\"" : "";
580 p = p instanceof Level ? "Level."+p : p;
581 builder.append(sep).append(quote).append(p).append(quote);
582 sep = ", ";
583 }
584 builder.append(')');
585 if (verbose) System.out.println(builder);
586 handle.invokeWithArguments(args);
587 } catch (Throwable ex) {
588 throw new RuntimeException(ex);
589 }
590 }
591 }
592
593
594 public abstract static class BackendTester<BackendRecord> {
595 static final Level[] levelMap = {Level.ALL, Level.FINER, Level.FINE,
596 Level.INFO, Level.WARNING, Level.SEVERE, Level.OFF};
597
598 abstract class BackendAdaptor {
599 public abstract String getLoggerName(BackendRecord res);
600 public abstract Object getLevel(BackendRecord res);
601 public abstract String getMessage(BackendRecord res);
602 public abstract String getSourceClassName(BackendRecord res);
603 public abstract String getSourceMethodName(BackendRecord res);
604 public abstract Throwable getThrown(BackendRecord res);
605 public abstract ResourceBundle getResourceBundle(BackendRecord res);
606 public abstract void setLevel(java.lang.System.Logger logger,
607 Level level);
608 public abstract void setLevel(java.lang.System.Logger logger,
609 java.lang.System.Logger.Level level);
610 public abstract List<BackendRecord> getBackendRecords();
611 public abstract void resetBackendRecords();
612 public boolean shouldBeLoggable(Levels level, Level loggerLevel) {
613 final Level logLevel = level.platformLevel;
614 return shouldBeLoggable(logLevel, loggerLevel);
615 }
616 public boolean shouldBeLoggable(Level logLevel, Level loggerLevel) {
617 return loggerLevel.intValue() != Level.OFF.intValue()
618 && logLevel.intValue() >= loggerLevel.intValue();
619 }
620 public boolean shouldBeLoggable(java.lang.System.Logger.Level logLevel,
621 java.lang.System.Logger.Level loggerLevel) {
622 return loggerLevel != java.lang.System.Logger.Level.OFF
623 && logLevel.ordinal() >= loggerLevel.ordinal();
624 }
625 public boolean isLoggable(java.lang.System.Logger logger, Level l) {
626 return bridgeLoggerClass.cast(logger).isLoggable(l);
627 }
628 public String getCallerClassName(Levels level, String clazz) {
629 return clazz != null ? clazz : Levels.class.getName();
630 }
631 public String getCallerClassName(MethodInvoker<?,?> logMethod,
632 String clazz) {
633 return clazz != null ? clazz : logMethod.getClass().getName();
634 }
635 public String getCallerMethodName(Levels level, String method) {
636 return method != null ? method : "invoke";
637 }
638 public String getCallerMethodName(MethodInvoker<?,?> logMethod,
639 String method) {
640 return method != null ? method : "logX";
641 }
642 public Object getMappedLevel(Object level) {
643 return level;
644 }
645
646 public Level toJUL(java.lang.System.Logger.Level level) {
647 return levelMap[level.ordinal()];
648 }
649 }
650
651 public final boolean isSystem;
652 public final Class<? extends java.lang.System.Logger> restrictedTo;
653 public final ResourceBundle localized;
654 public BackendTester(boolean isSystem) {
655 this(isSystem,null,null);
656 }
657 public BackendTester(boolean isSystem, ResourceBundle localized) {
658 this(isSystem,null,localized);
659 }
660 public BackendTester(boolean isSystem,
661 Class<? extends java.lang.System.Logger> restrictedTo) {
662 this(isSystem, restrictedTo, null);
663 }
664 public BackendTester(boolean isSystem,
665 Class<? extends java.lang.System.Logger> restrictedTo,
666 ResourceBundle localized) {
667 this.isSystem = isSystem;
668 this.restrictedTo = restrictedTo;
669 this.localized = localized;
670 }
671
672 public java.lang.System.Logger convert(java.lang.System.Logger logger) {
673 return logger;
674 }
675
676 public static Level[] LEVELS = {
677 Level.OFF,
678 Level.SEVERE, Level.WARNING, Level.INFO, Level.CONFIG,
679 Level.FINE, Level.FINER, Level.FINEST,
680 Level.ALL
681 };
682
683 abstract BackendAdaptor adaptor();
684
685 protected void checkRecord(Levels test, BackendRecord res, String loggerName,
686 Level level, String msg, String className, String methodName,
687 Throwable thrown, ResourceBundle bundle, Object... params) {
688 checkRecord(test, res, loggerName, level, ()->msg, className,
689 methodName, thrown, bundle, params);
690
691 }
692 protected void checkRecord(Levels test, BackendRecord res, String loggerName,
693 Level level, Supplier<String> msg, String className, String methodName,
694 Throwable thrown, ResourceBundle bundle, Object... params) {
695 checkRecord(test.method, res, loggerName, level, msg,
696 className, methodName, thrown, bundle, params);
697 }
698 protected <L> void checkRecord(String logMethod, BackendRecord res, String loggerName,
699 L level, Supplier<String> msg, String className, String methodName,
700 Throwable thrown, ResourceBundle bundle, Object... params) {
701 final BackendAdaptor analyzer = adaptor();
702 if (! Objects.equals(analyzer.getLoggerName(res), loggerName)) {
703 throw new RuntimeException(logMethod+": expected logger name "
704 + loggerName + " got " + analyzer.getLoggerName(res));
705 }
706 if (!Objects.equals(analyzer.getLevel(res), analyzer.getMappedLevel(level))) {
707 throw new RuntimeException(logMethod+": expected level "
708 + analyzer.getMappedLevel(level) + " got " + analyzer.getLevel(res));
709 }
710 if (!Objects.equals(analyzer.getMessage(res), msg.get())) {
711 throw new RuntimeException(logMethod+": expected message \""
712 + msg.get() + "\" got \"" + analyzer.getMessage(res) +"\"");
713 }
714 if (!Objects.equals(analyzer.getSourceClassName(res), className)) {
715 throw new RuntimeException(logMethod
716 + ": expected class name \"" + className
717 + "\" got \"" + analyzer.getSourceClassName(res) +"\"");
718 }
719 if (!Objects.equals(analyzer.getSourceMethodName(res), methodName)) {
720 throw new RuntimeException(logMethod
721 + ": expected method name \"" + methodName
722 + "\" got \"" + analyzer.getSourceMethodName(res) +"\"");
723 }
724 final Throwable thrownRes = analyzer.getThrown(res);
725 if (!Objects.equals(thrownRes, thrown)) {
726 throw new RuntimeException(logMethod
727 + ": expected throwable \"" + thrown
728 + "\" got \"" + thrownRes + "\"");
729 }
730 if (!Objects.equals(analyzer.getResourceBundle(res), bundle)) {
731 throw new RuntimeException(logMethod
732 + ": expected bundle \"" + bundle
733 + "\" got \"" + analyzer.getResourceBundle(res) +"\"");
734 }
735 }
736
737 public void testLevel(Levels level, java.lang.System.Logger logger,
738 String msg) {
739 Runnable test = () -> level.level(logger, msg);
740 Checker<BackendRecord, Level> check = (res, l) -> {
741 checkRecord(level, res, logger.getName(), l, msg,
742 adaptor().getCallerClassName(level, Levels.class.getName()),
743 adaptor().getCallerMethodName(level, "invoke"),
744 null, localized);
745 return null;
746 };
747 test("msg", level, logger, test, check);
748 }
749
750 public void testLevel(Levels level, java.lang.System.Logger logger,
751 String msg, Object... params) {
752 Runnable test = () -> level.level(logger, msg, (Object[])params);
753 Checker<BackendRecord, Level> check = (res, l) -> {
754 checkRecord(level, res, logger.getName(), l, msg,
755 adaptor().getCallerClassName(level, Levels.class.getName()),
756 adaptor().getCallerMethodName(level, "invoke"),
757 null, localized, (Object[])params);
758 return null;
759 };
760 test("msg, params", level, logger, test, check);
761 }
762
763 public void testLevel(Levels level, java.lang.System.Logger logger,
764 String msg, Throwable thrown) {
765 Runnable test = () -> level.level(logger, msg, thrown);
766 Checker<BackendRecord, Level> check = (res, l) -> {
767 checkRecord(level, res, logger.getName(), l, msg,
768 adaptor().getCallerClassName(level, Levels.class.getName()),
769 adaptor().getCallerMethodName(level, "invoke"),
770 thrown, localized);
771 return null;
772 };
773 test("msg, thrown", level, logger, test, check);
774 }
775
776 public void testLevel(Levels level, java.lang.System.Logger logger,
777 Supplier<String> msg) {
778 Runnable test = () -> level.level(logger, msg);
779 Checker<BackendRecord, Level> check = (res, l) -> {
780 checkRecord(level, res, logger.getName(), l, msg,
781 adaptor().getCallerClassName(level, Levels.class.getName()),
782 adaptor().getCallerMethodName(level, "invoke"),
783 null, null);
784 return null;
785 };
786 test("msgSupplier", level, logger, test, check);
787 }
788
789 public void testLevel(Levels level, java.lang.System.Logger logger,
790 Supplier<String> msg, Throwable thrown) {
791 Runnable test = () -> level.level(logger, msg, thrown);
792 Checker<BackendRecord, Level> check = (res, l) -> {
793 checkRecord(level, res, logger.getName(), l, msg,
794 adaptor().getCallerClassName(level, Levels.class.getName()),
795 adaptor().getCallerMethodName(level, "invoke"),
796 thrown, null);
797 return null;
798 };
799 test("throw, msgSupplier", level, logger, test, check);
800 }
801
802 public void testLevel(Levels level, java.lang.System.Logger logger,
803 String msg, ResourceBundle bundle) {
804 Runnable test = () -> level.level(logger, msg, bundle);
805 Checker<BackendRecord, Level> check = (res, l) -> {
806 checkRecord(level, res, logger.getName(), l, msg,
807 adaptor().getCallerClassName(level, Levels.class.getName()),
808 adaptor().getCallerMethodName(level, "invoke"),
809 null, bundle);
810 return null;
811 };
812 test("bundle, msg", level, logger, test, check);
813 }
814
815 public void testLevel(Levels level, java.lang.System.Logger logger,
816 String msg, ResourceBundle bundle, Object... params) {
817 Runnable test = () -> level.level(logger, msg, bundle, (Object[])params);
818 Checker<BackendRecord, Level> check = (res, l) -> {
819 checkRecord(level, res, logger.getName(), l, msg,
820 adaptor().getCallerClassName(level, Levels.class.getName()),
821 adaptor().getCallerMethodName(level, "invoke"),
822 null, bundle, (Object[])params);
823 return null;
824 };
825 test("bundle, msg, params", level, logger, test, check);
826 }
827
828 public void testLevel(Levels level, java.lang.System.Logger logger,
829 String msg, ResourceBundle bundle, Throwable thrown) {
830 Runnable test = () -> level.level(logger, msg, bundle, thrown);
831 Checker<BackendRecord, Level> check = (res, l) -> {
832 checkRecord(level, res, logger.getName(), l, msg,
833 adaptor().getCallerClassName(level, Levels.class.getName()),
834 adaptor().getCallerMethodName(level, "invoke"),
835 thrown, bundle);
836 return null;
837 };
838 test("bundle, msg, throwable", level, logger, test, check);
839 }
840
841 // System.Logger
842 public void testSpiLog(java.lang.System.Logger logger, String msg) {
843 Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> {
844 checkRecord("log", res, logger.getName(), l, () -> msg,
845 adaptor().getCallerClassName(
846 SpiLogMethodInvoker.LOG_STRING_PARAMS,
847 SpiLogMethodInvoker.class.getName()),
848 adaptor().getCallerMethodName(
849 SpiLogMethodInvoker.LOG_STRING_PARAMS,
850 "logX"), null, localized);
851 return null;
852 };
853 SpiLogTester tester = (x, level) -> {
854 SpiLogMethodInvoker.LOG_STRING_PARAMS.logX(x, level, msg, (Object[])null);
855 return null;
856 };
857 Function<String, String> nameProducer = (l) -> "log(Level." + l + ", \"" + msg + "\")";
858 testSpiLog(logger, tester, check, nameProducer);
859 }
860
861 public void testSpiLog(java.lang.System.Logger logger,
862 ResourceBundle bundle, String msg) {
863 Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> {
864 checkRecord("log", res, logger.getName(), l, () -> msg,
865 adaptor().getCallerClassName(
866 SpiLogMethodInvoker.LOGRB_STRING_PARAMS,
867 SpiLogMethodInvoker.class.getName()),
868 adaptor().getCallerMethodName(
869 SpiLogMethodInvoker.LOGRB_STRING_PARAMS,
870 "logX"), null, bundle);
871 return null;
872 };
873 SpiLogTester tester = (x, level) -> {
874 SpiLogMethodInvoker.LOGRB_STRING_PARAMS.logX(x, level, bundle, msg, (Object[])null);
875 return null;
876 };
877 Function<String, String> nameProducer = (l) -> "log(Level." + l
878 + ", bundle, \"" + msg + "\")";
879 testSpiLog(logger, tester, check, nameProducer);
880 }
881
882 public void testSpiLog(java.lang.System.Logger logger, String msg, Object... params) {
883 Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> {
884 checkRecord("log", res, logger.getName(), l, () -> msg,
885 adaptor().getCallerClassName(
886 SpiLogMethodInvoker.LOG_STRING_PARAMS,
887 SpiLogMethodInvoker.class.getName()),
888 adaptor().getCallerMethodName(
889 SpiLogMethodInvoker.LOG_STRING_PARAMS,
890 "logX"), null, localized, params);
891 return null;
892 };
893 SpiLogTester tester = (x, level) -> {
894 SpiLogMethodInvoker.LOG_STRING_PARAMS.logX(x, level, msg, params);
895 return null;
896 };
897 Function<String, String> nameProducer = (l) -> "log(Level." + l + ", \"" + msg + "\", params...)";
898 testSpiLog(logger, tester, check, nameProducer);
899 }
900
901 public void testSpiLog(java.lang.System.Logger logger,
902 ResourceBundle bundle, String msg, Object... params) {
903 Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> {
904 checkRecord("log", res, logger.getName(), l, () -> msg,
905 adaptor().getCallerClassName(
906 SpiLogMethodInvoker.LOGRB_STRING_PARAMS,
907 SpiLogMethodInvoker.class.getName()),
908 adaptor().getCallerMethodName(
909 SpiLogMethodInvoker.LOGRB_STRING_PARAMS,
910 "logX"), null, bundle, params);
911 return null;
912 };
913 SpiLogTester tester = (x, level) -> {
914 SpiLogMethodInvoker.LOGRB_STRING_PARAMS.logX(x, level, bundle, msg, params);
915 return null;
916 };
917 Function<String, String> nameProducer = (l) -> "log(Level." + l
918 + ", bundle, \"" + msg + "\", params...)";
919 testSpiLog(logger, tester, check, nameProducer);
920 }
921
922 public void testSpiLog(java.lang.System.Logger logger, String msg, Throwable thrown) {
923 Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> {
924 checkRecord("log", res, logger.getName(), l, () -> msg,
925 adaptor().getCallerClassName(
926 SpiLogMethodInvoker.LOG_STRING_THROWN,
927 SpiLogMethodInvoker.class.getName()),
928 adaptor().getCallerMethodName(
929 SpiLogMethodInvoker.LOG_STRING_THROWN,
930 "logX"), thrown, localized);
931 return null;
932 };
933 SpiLogTester tester = (x, level) -> {
934 SpiLogMethodInvoker.LOG_STRING_THROWN.logX(x, level, msg, thrown);
935 return null;
936 };
937 Function<String, String> nameProducer = (l) ->
938 "log(Level." + l + ", \"" + msg + "\", thrown)";
939 testSpiLog(logger, tester, check, nameProducer);
940 }
941
942 public void testSpiLog(java.lang.System.Logger logger,
943 ResourceBundle bundle, String msg, Throwable thrown) {
944 Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> {
945 checkRecord("log", res, logger.getName(), l, () -> msg,
946 adaptor().getCallerClassName(
947 SpiLogMethodInvoker.LOGRB_STRING_THROWN,
948 SpiLogMethodInvoker.class.getName()),
949 adaptor().getCallerMethodName(
950 SpiLogMethodInvoker.LOGRB_STRING_THROWN,
951 "logX"), thrown, bundle);
952 return null;
953 };
954 SpiLogTester tester = (x, level) -> {
955 SpiLogMethodInvoker.LOGRB_STRING_THROWN.logX(x, level, bundle, msg, thrown);
956 return null;
957 };
958 Function<String, String> nameProducer = (l) ->
959 "log(Level." + l + ", bundle, \"" + msg + "\", thrown)";
960 testSpiLog(logger, tester, check, nameProducer);
961 }
962
963 public void testSpiLog(java.lang.System.Logger logger, Supplier<String> msg) {
964 Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> {
965 checkRecord("log", res, logger.getName(), l, msg,
966 adaptor().getCallerClassName(
967 SpiLogMethodInvoker.LOG_SUPPLIER,
968 SpiLogMethodInvoker.class.getName()),
969 adaptor().getCallerMethodName(
970 SpiLogMethodInvoker.LOG_SUPPLIER,
971 "logX"), null, null);
972 return null;
973 };
974 SpiLogTester tester = (x, level) -> {
975 SpiLogMethodInvoker.LOG_SUPPLIER.logX(x, level, msg);
976 return null;
977 };
978 Function<String, String> nameProducer = (l) ->
979 "log(Level." + l + ", () -> \"" + msg.get() + "\")";
980 testSpiLog(logger, tester, check, nameProducer);
981 }
982
983 public void testSpiLog(java.lang.System.Logger logger, Object obj) {
984 Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> {
985 checkRecord("log", res, logger.getName(), l, () -> obj.toString(),
986 adaptor().getCallerClassName(
987 SpiLogMethodInvoker.LOG_OBJECT,
988 SpiLogMethodInvoker.class.getName()),
989 adaptor().getCallerMethodName(
990 SpiLogMethodInvoker.LOG_OBJECT,
991 "logX"), null, null);
992 return null;
993 };
994 SpiLogTester tester = (x, level) -> {
995 SpiLogMethodInvoker.LOG_OBJECT.logX(x, level, obj);
996 return null;
997 };
998 Function<String, String> nameProducer = (l) ->
999 "log(Level." + l + ", new "+obj.getClass().getSimpleName()+"(\""
1000 + obj.toString() + "\"))";
1001 testSpiLog(logger, tester, check, nameProducer);
1002 }
1003
1004 public void testSpiLog(java.lang.System.Logger logger, Throwable thrown, Supplier<String> msg) {
1005 Checker<BackendRecord, java.lang.System.Logger.Level> check = (res, l) -> {
1006 checkRecord("log", res, logger.getName(), l, msg,
1007 adaptor().getCallerClassName(
1008 SpiLogMethodInvoker.LOG_SUPPLIER_THROWN,
1009 SpiLogMethodInvoker.class.getName()),
1010 adaptor().getCallerMethodName(
1011 SpiLogMethodInvoker.LOG_SUPPLIER_THROWN,
1012 "logX"), thrown, null);
1013 return null;
1014 };
1015 SpiLogTester tester = (x, level) -> {
1016 SpiLogMethodInvoker.LOG_SUPPLIER_THROWN.logX(x, level, msg, thrown);
1017 return null;
1018 };
1019 Function<String, String> nameProducer = (l) ->
1020 "log(Level." + l + ", () -> \"" + msg.get() + "\", thrown)";
1021 testSpiLog(logger, tester, check, nameProducer);
1022 }
1023
1024
1025 // JDK
1026
1027 public void testLog(java.lang.System.Logger logger, String msg) {
1028 Checker<BackendRecord, Level> check = (res, l) -> {
1029 checkRecord("log", res, logger.getName(), l, () -> msg,
1030 adaptor().getCallerClassName(
1031 JdkLogMethodInvoker.LOG_STRING_PARAMS,
1032 JdkLogMethodInvoker.class.getName()),
1033 adaptor().getCallerMethodName(
1034 JdkLogMethodInvoker.LOG_STRING_PARAMS,
1035 "logX"), null, localized);
1036 return null;
1037 };
1038 JdkLogTester tester = (x, level) -> {
1039 JdkLogMethodInvoker.LOG_STRING_PARAMS.logX(x, level, msg, (Object[])null);
1040 return null;
1041 };
1042 Function<String, String> nameProducer = (l) -> "log(Level." + l + ", \"" + msg + "\")";
1043 testJdkLog(logger, tester, check, nameProducer);
1044 }
1045
1046 public void testLogrb(java.lang.System.Logger logger,
1047 ResourceBundle bundle, String msg) {
1048 Checker<BackendRecord, Level> check = (res, l) -> {
1049 checkRecord("log", res, logger.getName(), l, () -> msg,
1050 adaptor().getCallerClassName(
1051 JdkLogMethodInvoker.LOGRB_STRING_PARAMS,
1052 JdkLogMethodInvoker.class.getName()),
1053 adaptor().getCallerMethodName(
1054 JdkLogMethodInvoker.LOGRB_STRING_PARAMS,
1055 "logX"), null, bundle);
1056 return null;
1057 };
1058 JdkLogTester tester = (x, level) -> {
1059 JdkLogMethodInvoker.LOGRB_STRING_PARAMS.logX(x, level, bundle, msg, (Object[])null);
1060 return null;
1061 };
1062 Function<String, String> nameProducer = (l) -> "logrb(Level." + l
1063 + ", bundle, \"" + msg + "\")";
1064 testJdkLog(logger, tester, check, nameProducer);
1065 }
1066
1067 public void testLog(java.lang.System.Logger logger, String msg, Object... params) {
1068 Checker<BackendRecord, Level> check = (res, l) -> {
1069 checkRecord("log", res, logger.getName(), l, () -> msg,
1070 adaptor().getCallerClassName(
1071 JdkLogMethodInvoker.LOG_STRING_PARAMS,
1072 JdkLogMethodInvoker.class.getName()),
1073 adaptor().getCallerMethodName(
1074 JdkLogMethodInvoker.LOG_STRING_PARAMS,
1075 "logX"), null, localized, params);
1076 return null;
1077 };
1078 JdkLogTester tester = (x, level) -> {
1079 JdkLogMethodInvoker.LOG_STRING_PARAMS.logX(x, level, msg, params);
1080 return null;
1081 };
1082 Function<String, String> nameProducer = (l) -> "log(Level." + l + ", \"" + msg + "\", params...)";
1083 testJdkLog(logger, tester, check, nameProducer);
1084 }
1085
1086 public void testLogrb(java.lang.System.Logger logger,
1087 ResourceBundle bundle, String msg, Object... params) {
1088 Checker<BackendRecord, Level> check = (res, l) -> {
1089 checkRecord("log", res, logger.getName(), l, () -> msg,
1090 adaptor().getCallerClassName(
1091 JdkLogMethodInvoker.LOGRB_STRING_PARAMS,
1092 JdkLogMethodInvoker.class.getName()),
1093 adaptor().getCallerMethodName(
1094 JdkLogMethodInvoker.LOGRB_STRING_PARAMS,
1095 "logX"), null, bundle, params);
1096 return null;
1097 };
1098 JdkLogTester tester = (x, level) -> {
1099 JdkLogMethodInvoker.LOGRB_STRING_PARAMS.logX(x, level, bundle, msg, params);
1100 return null;
1101 };
1102 Function<String, String> nameProducer = (l) -> "log(Level." + l
1103 + ", bundle, \"" + msg + "\", params...)";
1104 testJdkLog(logger, tester, check, nameProducer);
1105 }
1106
1107 public void testLog(java.lang.System.Logger logger, String msg, Throwable thrown) {
1108 Checker<BackendRecord, Level> check = (res, l) -> {
1109 checkRecord("log", res, logger.getName(), l, () -> msg,
1110 adaptor().getCallerClassName(
1111 JdkLogMethodInvoker.LOG_STRING_THROWN,
1112 JdkLogMethodInvoker.class.getName()),
1113 adaptor().getCallerMethodName(
1114 JdkLogMethodInvoker.LOG_STRING_THROWN,
1115 "logX"), thrown, localized);
1116 return null;
1117 };
1118 JdkLogTester tester = (x, level) -> {
1119 JdkLogMethodInvoker.LOG_STRING_THROWN.logX(x, level, msg, thrown);
1120 return null;
1121 };
1122 Function<String, String> nameProducer = (l) ->
1123 "log(Level." + l + ", \"" + msg + "\", thrown)";
1124 testJdkLog(logger, tester, check, nameProducer);
1125 }
1126
1127 public void testLogrb(java.lang.System.Logger logger,
1128 ResourceBundle bundle, String msg, Throwable thrown) {
1129 Checker<BackendRecord, Level> check = (res, l) -> {
1130 checkRecord("log", res, logger.getName(), l, () -> msg,
1131 adaptor().getCallerClassName(
1132 JdkLogMethodInvoker.LOGRB_STRING_THROWN,
1133 JdkLogMethodInvoker.class.getName()),
1134 adaptor().getCallerMethodName(
1135 JdkLogMethodInvoker.LOGRB_STRING_THROWN,
1136 "logX"), thrown, bundle);
1137 return null;
1138 };
1139 JdkLogTester tester = (x, level) -> {
1140 JdkLogMethodInvoker.LOGRB_STRING_THROWN.logX(x, level, bundle, msg, thrown);
1141 return null;
1142 };
1143 Function<String, String> nameProducer = (l) ->
1144 "log(Level." + l + ", bundle, \"" + msg + "\", thrown)";
1145 testJdkLog(logger, tester, check, nameProducer);
1146 }
1147
1148 public void testLog(java.lang.System.Logger logger, Supplier<String> msg) {
1149 Checker<BackendRecord, Level> check = (res, l) -> {
1150 checkRecord("log", res, logger.getName(), l, msg,
1151 adaptor().getCallerClassName(
1152 JdkLogMethodInvoker.LOG_SUPPLIER,
1153 JdkLogMethodInvoker.class.getName()),
1154 adaptor().getCallerMethodName(
1155 JdkLogMethodInvoker.LOG_SUPPLIER,
1156 "logX"), null, null);
1157 return null;
1158 };
1159 JdkLogTester tester = (x, level) -> {
1160 JdkLogMethodInvoker.LOG_SUPPLIER.logX(x, level, msg);
1161 return null;
1162 };
1163 Function<String, String> nameProducer = (l) ->
1164 "log(Level." + l + ", () -> \"" + msg.get() + "\")";
1165 testJdkLog(logger, tester, check, nameProducer);
1166 }
1167
1168 public void testLog(java.lang.System.Logger logger, Throwable thrown, Supplier<String> msg) {
1169 Checker<BackendRecord, Level> check = (res, l) -> {
1170 checkRecord("log", res, logger.getName(), l, msg,
1171 adaptor().getCallerClassName(
1172 JdkLogMethodInvoker.LOG_SUPPLIER_THROWN,
1173 JdkLogMethodInvoker.class.getName()),
1174 adaptor().getCallerMethodName(
1175 JdkLogMethodInvoker.LOG_SUPPLIER_THROWN,
1176 "logX"), thrown, null);
1177 return null;
1178 };
1179 JdkLogTester tester = (x, level) -> {
1180 JdkLogMethodInvoker.LOG_SUPPLIER_THROWN.logX(x, level, thrown, msg);
1181 return null;
1182 };
1183 Function<String, String> nameProducer = (l) ->
1184 "log(Level." + l + ", () -> \"" + msg.get() + "\", thrown)";
1185 testJdkLog(logger, tester, check, nameProducer);
1186 }
1187
1188 static Supplier<String> logpMessage(ResourceBundle bundle,
1189 String className, String methodName, Supplier<String> msg) {
1190 if (BEST_EFFORT_FOR_LOGP && bundle == null
1191 && (className != null || methodName != null)) {
1192 final String cName = className == null ? "" : className;
1193 final String mName = methodName == null ? "" : methodName;
1194 return () -> {
1195 String m = msg.get();
1196 return String.format("[%s %s] %s", cName, mName, m == null ? "" : m);
1197 };
1198 } else {
1199 return msg;
1200 }
1201 }
1202
1203 public void testLogp(java.lang.System.Logger logger, String className,
1204 String methodName, String msg) {
1205 Checker<BackendRecord, Level> check = (res, l) -> {
1206 checkRecord("logp", res, logger.getName(), l,
1207 logpMessage(localized, className, methodName, () -> msg),
1208 adaptor().getCallerClassName(
1209 JdkLogMethodInvoker.LOGP_STRING, className),
1210 adaptor().getCallerClassName(
1211 JdkLogMethodInvoker.LOGP_STRING, methodName),
1212 null, localized);
1213 return null;
1214 };
1215 JdkLogTester tester = (x, level) -> {
1216 JdkLogMethodInvoker.LOGP_STRING.logX(x, level,
1217 className, methodName, msg);
1218 return null;
1219 };
1220 Function<String, String> nameProducer = (l) ->
1221 "logp(Level." + l + ", class, method, \"" + msg + "\")";
1222 testJdkLog(logger, tester, check, nameProducer);
1223 }
1224
1225 public void testLogrb(java.lang.System.Logger logger, String className,
1226 String methodName, ResourceBundle bundle, String msg) {
1227 Checker<BackendRecord, Level> check = (res, l) -> {
1228 checkRecord("logp", res, logger.getName(), l, () -> msg,
1229 adaptor().getCallerClassName(
1230 JdkLogMethodInvoker.LOGRBP_STRING_PARAMS, className),
1231 adaptor().getCallerClassName(
1232 JdkLogMethodInvoker.LOGRBP_STRING_PARAMS, methodName),
1233 null, bundle);
1234 return null;
1235 };
1236 JdkLogTester tester = (x, level) -> {
1237 JdkLogMethodInvoker.LOGRBP_STRING_PARAMS.logX(x, level,
1238 className, methodName, bundle, msg, (Object[])null);
1239 return null;
1240 };
1241 Function<String, String> nameProducer = (l) ->
1242 "logp(Level." + l + ", class, method, bundle, \"" + msg + "\")";
1243 testJdkLog(logger, tester, check, nameProducer);
1244 }
1245
1246 public void testLogp(java.lang.System.Logger logger, String className,
1247 String methodName, String msg, Object... params) {
1248 Checker<BackendRecord, Level> check = (res, l) -> {
1249 checkRecord("logp", res, logger.getName(), l,
1250 logpMessage(localized, className, methodName, () -> msg),
1251 adaptor().getCallerClassName(
1252 JdkLogMethodInvoker.LOGP_STRING_PARAMS, className),
1253 adaptor().getCallerClassName(
1254 JdkLogMethodInvoker.LOGP_STRING_PARAMS, methodName),
1255 null, localized, params);
1256 return null;
1257 };
1258 JdkLogTester tester = (x, level) -> {
1259 JdkLogMethodInvoker.LOGP_STRING_PARAMS.logX(x, level,
1260 className, methodName, msg, params);
1261 return null;
1262 };
1263 Function<String, String> nameProducer = (l) ->
1264 "log(Level." + l + ", class, method, \"" + msg + "\", params...)";
1265 testJdkLog(logger, tester, check, nameProducer);
1266 }
1267
1268 public void testLogrb(java.lang.System.Logger logger, String className,
1269 String methodName, ResourceBundle bundle, String msg,
1270 Object... params) {
1271 Checker<BackendRecord, Level> check = (res, l) -> {
1272 checkRecord("logp", res, logger.getName(), l, () -> msg,
1273 adaptor().getCallerClassName(
1274 JdkLogMethodInvoker.LOGRBP_STRING_PARAMS, className),
1275 adaptor().getCallerClassName(
1276 JdkLogMethodInvoker.LOGRBP_STRING_PARAMS, methodName),
1277 null, bundle, params);
1278 return null;
1279 };
1280 JdkLogTester tester = (x, level) -> {
1281 JdkLogMethodInvoker.LOGRBP_STRING_PARAMS.logX(x, level,
1282 className, methodName, bundle, msg, params);
1283 return null;
1284 };
1285 Function<String, String> nameProducer = (l) ->
1286 "log(Level." + l + ", class, method, bundle, \""
1287 + msg + "\", params...)";
1288 testJdkLog(logger, tester, check, nameProducer);
1289 }
1290
1291 public void testLogp(java.lang.System.Logger logger, String className,
1292 String methodName, String msg, Throwable thrown) {
1293 Checker<BackendRecord, Level> check = (res, l) -> {
1294 checkRecord("log", res, logger.getName(), l,
1295 logpMessage(localized, className, methodName, () -> msg),
1296 adaptor().getCallerClassName(
1297 JdkLogMethodInvoker.LOGP_STRING_THROWN, className),
1298 adaptor().getCallerClassName(
1299 JdkLogMethodInvoker.LOGP_STRING_THROWN, methodName),
1300 thrown, localized);
1301 return null;
1302 };
1303 JdkLogTester tester = (x, level) -> {
1304 JdkLogMethodInvoker.LOGP_STRING_THROWN.logX(x, level,
1305 className, methodName, msg, thrown);
1306 return null;
1307 };
1308 Function<String, String> nameProducer = (l) ->
1309 "log(Level." + l + ", class, method, \"" + msg + "\", thrown)";
1310 testJdkLog(logger, tester, check, nameProducer);
1311 }
1312
1313 public void testLogrb(java.lang.System.Logger logger, String className,
1314 String methodName, ResourceBundle bundle,
1315 String msg, Throwable thrown) {
1316 Checker<BackendRecord, Level> check = (res, l) -> {
1317 checkRecord("log", res, logger.getName(), l, () -> msg,
1318 adaptor().getCallerClassName(
1319 JdkLogMethodInvoker.LOGRBP_STRING_THROWN, className),
1320 adaptor().getCallerClassName(
1321 JdkLogMethodInvoker.LOGRBP_STRING_THROWN, methodName),
1322 thrown, bundle);
1323 return null;
1324 };
1325 JdkLogTester tester = (x, level) -> {
1326 JdkLogMethodInvoker.LOGRBP_STRING_THROWN.logX(x, level,
1327 className, methodName, bundle, msg, thrown);
1328 return null;
1329 };
1330 Function<String, String> nameProducer = (l) ->
1331 "log(Level." + l + ", class, method, bundle, \"" + msg + "\", thrown)";
1332 testJdkLog(logger, tester, check, nameProducer);
1333
1334 }
1335
1336 public void testLogp(java.lang.System.Logger logger, String className,
1337 String methodName, Supplier<String> msg) {
1338 Checker<BackendRecord, Level> check = (res, l) -> {
1339 checkRecord("log", res, logger.getName(), l,
1340 logpMessage(null, className, methodName, msg),
1341 adaptor().getCallerClassName(
1342 JdkLogMethodInvoker.LOGP_SUPPLIER, className),
1343 adaptor().getCallerClassName(
1344 JdkLogMethodInvoker.LOGP_SUPPLIER, methodName),
1345 null, null);
1346 return null;
1347 };
1348 JdkLogTester tester = (x, level) -> {
1349 JdkLogMethodInvoker.LOGP_SUPPLIER.logX(x, level,
1350 className, methodName, msg);
1351 return null;
1352 };
1353 Function<String, String> nameProducer = (l) ->
1354 "log(Level." + l + ", class, method, () -> \"" + msg.get() + "\")";
1355 testJdkLog(logger, tester, check, nameProducer);
1356 }
1357
1358 public void testLogp(java.lang.System.Logger logger, String className,
1359 String methodName, Throwable thrown, Supplier<String> msg) {
1360 Checker<BackendRecord, Level> check = (res, l) -> {
1361 checkRecord("log", res, logger.getName(), l,
1362 logpMessage(null, className, methodName, msg),
1363 adaptor().getCallerClassName(
1364 JdkLogMethodInvoker.LOGP_SUPPLIER_THROWN, className),
1365 adaptor().getCallerClassName(
1366 JdkLogMethodInvoker.LOGP_SUPPLIER_THROWN, methodName),
1367 thrown, null);
1368 return null;
1369 };
1370 JdkLogTester tester = (x, level) -> {
1371 JdkLogMethodInvoker.LOGP_SUPPLIER_THROWN.logX(x, level,
1372 className, methodName, thrown, msg);
1373 return null;
1374 };
1375 Function<String, String> nameProducer = (l) ->
1376 "log(Level." + l + ", class, method, () -> \"" + msg.get() + "\", thrown)";
1377 testJdkLog(logger, tester, check, nameProducer);
1378 }
1379
1380 private void testJdkLog(java.lang.System.Logger logger,
1381 JdkLogTester log, Checker<BackendRecord,Level> check,
1382 Function<String, String> nameProducer) {
1383 if (restrictedTo != null) {
1384 if (!bridgeLoggerClass.isAssignableFrom(restrictedTo)) {
1385 if (VERBOSE) {
1386 System.out.println("Skipping method from "
1387 + bridgeLoggerClass);
1388 }
1389 return;
1390 }
1391 }
1392 System.out.println("Testing Logger." + nameProducer.apply("*")
1393 + " on " + logger);
1394 final BackendAdaptor adaptor = adaptor();
1395 for (Level loggerLevel : LEVELS) {
1396 adaptor.setLevel(logger, loggerLevel);
1397 for (Level l : LEVELS) {
1398 check(logger, () -> log.apply(bridgeLoggerClass.cast(logger), l),
1399 check, () -> adaptor.isLoggable(logger, l),
1400 () -> adaptor.shouldBeLoggable(l, loggerLevel),
1401 l, loggerLevel, nameProducer.apply(l.toString()));
1402 }
1403 }
1404 }
1405
1406 private void testSpiLog(java.lang.System.Logger logger,
1407 SpiLogTester log, Checker<BackendRecord, java.lang.System.Logger.Level> check,
1408 Function<String, String> nameProducer) {
1409 System.out.println("Testing System.Logger." + nameProducer.apply("*")
1410 + " on " + logger);
1411 final BackendAdaptor adaptor = adaptor();
1412 for (java.lang.System.Logger.Level loggerLevel : java.lang.System.Logger.Level.values()) {
1413
1414 adaptor.setLevel(logger, loggerLevel);
1415 for (java.lang.System.Logger.Level l : java.lang.System.Logger.Level.values()) {
1416 check(logger, () -> log.apply(logger, l),
1417 check, () -> logger.isLoggable(l),
1418 () -> adaptor.shouldBeLoggable(l, loggerLevel),
1419 l, loggerLevel, nameProducer.apply(l.toString()));
1420 }
1421 }
1422 }
1423
1424 private void test(String args, Levels level, java.lang.System.Logger logger,
1425 Runnable test, Checker<BackendRecord, Level> check) {
1426 if (restrictedTo != null) {
1427 if (!level.definingClass.isAssignableFrom(restrictedTo)) {
1428 if (VERBOSE) {
1429 System.out.println("Skipping method from "
1430 + level.definingClass);
1431 }
1432 return;
1433 }
1434 }
1435 String method = args.contains("bundle") ? "logrb" : "log";
1436 System.out.println("Testing Logger."
1437 + method + "(Level." + level.platformLevel
1438 + ", "+ args + ")" + " on " + logger);
1439 final BackendAdaptor adaptor = adaptor();
1440 for (Level loggerLevel : LEVELS) {
1441 adaptor.setLevel(logger, loggerLevel);
1442 check(logger, test, check,
1443 () -> level.isEnabled(logger),
1444 () -> adaptor.shouldBeLoggable(level, loggerLevel),
1445 level.platformLevel, loggerLevel, level.method);
1446 }
1447 }
1448
1449 private <L> void check(java.lang.System.Logger logger,
1450 Runnable test, Checker<BackendRecord,L> check,
1451 BooleanSupplier checkLevelEnabled,
1452 BooleanSupplier shouldBeLoggable,
1453 L logLevel, L loggerLevel, String logMethod) {
1454 final BackendAdaptor adaptor = adaptor();
1455 adaptor.resetBackendRecords();
1456 test.run();
1457 final List<BackendRecord> records = adaptor.getBackendRecords();
1458 if (shouldBeLoggable.getAsBoolean()) {
1459 if (!checkLevelEnabled.getAsBoolean()) {
1460 throw new RuntimeException("Logger is not enabled for "
1461 + logMethod
1462 + " although logger level is " + loggerLevel);
1463 }
1464 if (records.size() != 1) {
1465 throw new RuntimeException(loggerLevel + " [" +
1466 logLevel + "] : Unexpected record sizes: "
1467 + records.toString());
1468 }
1469 BackendRecord res = records.get(0);
1470 check.apply(res, logLevel);
1471 } else {
1472 if (checkLevelEnabled.getAsBoolean()) {
1473 throw new RuntimeException("Logger is enabled for "
1474 + logMethod
1475 + " although logger level is " + loggerLevel);
1476 }
1477 if (!records.isEmpty()) {
1478 throw new RuntimeException(loggerLevel + " [" +
1479 logLevel + "] : Unexpected record sizes: "
1480 + records.toString());
1481 }
1482 }
1483 }
1484 }
1485
1486 public static class JULBackendTester extends BackendTester<LogRecord>{
1487
1488 public JULBackendTester(boolean isSystem) {
1489 this(isSystem,null,null);
1490 }
1491 public JULBackendTester(boolean isSystem, ResourceBundle localized) {
1492 this(isSystem,null,localized);
1493 }
1494 public JULBackendTester(boolean isSystem,
1495 Class<? extends java.lang.System.Logger> restrictedTo) {
1496 this(isSystem, restrictedTo, null);
1497 }
1498 public JULBackendTester(boolean isSystem,
1499 Class<? extends java.lang.System.Logger> restrictedTo,
1500 ResourceBundle localized) {
1501 super(isSystem, restrictedTo, localized);
1502 }
1503
1504 Logger getBackendLogger(String name) {
1505 if (isSystem) {
1506 return LogManager.demandLoggerFor(name, Thread.class);
1507 } else {
1508 return Logger.getLogger(name);
1509 }
1510 }
1511
1512 class JULBackendAdaptor extends BackendAdaptor {
1513 @Override
1514 public String getLoggerName(LogRecord res) {
1515 return res.getLoggerName();
1516 }
1517 @Override
1518 public Level getLevel(LogRecord res) {
1519 return Level.valueOf(res.getLevel().getName());
1520 }
1521 @Override
1522 public String getMessage(LogRecord res) {
1523 return res.getMessage();
1524 }
1525 @Override
1526 public String getSourceClassName(LogRecord res) {
1527 return res.getSourceClassName();
1528 }
1529 @Override
1530 public String getSourceMethodName(LogRecord res) {
1531 return res.getSourceMethodName();
1532 }
1533 @Override
1534 public Throwable getThrown(LogRecord res) {
1535 return res.getThrown();
1536 }
1537 @Override
1538 public ResourceBundle getResourceBundle(LogRecord res) {
1539 return res.getResourceBundle();
1540 }
1541 @Override
1542 public void setLevel(java.lang.System.Logger logger, Level level) {
1543 Logger backend = getBackendLogger(logger.getName());
1544 backend.setLevel(java.util.logging.Level.parse(level.name()));
1545 }
1546 @Override
1547 public void setLevel(java.lang.System.Logger logger, java.lang.System.Logger.Level level) {
1548 setLevel(logger, toJUL(level));
1549 }
1550 @Override
1551 public List<LogRecord> getBackendRecords() {
1552 return handler.records;
1553 }
1554 @Override
1555 public void resetBackendRecords() {
1556 handler.reset();
1557 }
1558 @Override
1559 public Level getMappedLevel(Object level) {
1560 if (level instanceof java.lang.System.Logger.Level) {
1561 return toJUL((java.lang.System.Logger.Level)level);
1562 }
1563 return (Level)level;
1564 }
1565 }
1566
1567 final JULBackendAdaptor julAdaptor = new JULBackendAdaptor();
1568
1569 @Override
1570 BackendAdaptor adaptor() {
1571 return julAdaptor;
1572 }
1573
1574 }
1575
1576 public abstract static class BackendTesterFactory {
1577 public abstract BackendTester createBackendTester(boolean isSystem);
1578 public abstract BackendTester createBackendTester(boolean isSystem,
1579 Class<? extends java.lang.System.Logger> restrictedTo);
1580 public abstract BackendTester createBackendTester(boolean isSystem,
1581 Class<? extends java.lang.System.Logger> restrictedTo,
1582 ResourceBundle bundle);
1583 public abstract BackendTester createBackendTester(boolean isSystem,
1584 ResourceBundle bundle);
1585 }
1586
1587 public static class JULBackendTesterFactory extends BackendTesterFactory {
1588
1589 @Override
1590 public BackendTester createBackendTester(boolean isSystem) {
1591 return new JULBackendTester(isSystem);
1592 }
1593
1594 @Override
1595 public BackendTester createBackendTester(boolean isSystem,
1596 Class<? extends java.lang.System.Logger> restrictedTo) {
1597 return new JULBackendTester(isSystem, restrictedTo);
1598 }
1599
1600 @Override
1601 public BackendTester createBackendTester(boolean isSystem,
1602 Class<? extends java.lang.System.Logger> restrictedTo,
1603 ResourceBundle bundle) {
1604 return new JULBackendTester(isSystem, restrictedTo, bundle);
1605 }
1606
1607 @Override
1608 public BackendTester createBackendTester(boolean isSystem,
1609 ResourceBundle bundle) {
1610 return new JULBackendTester(isSystem, bundle);
1611 }
1612 }
1613
1614 public static class CustomLoggerFinder extends LoggerFinder {
1615
1616 static enum CustomLevel { OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE, ALL };
1617 static CustomLevel[] customLevelMap = { CustomLevel.ALL,
1618 CustomLevel.TRACE, CustomLevel.DEBUG, CustomLevel.INFO,
1619 CustomLevel.WARN, CustomLevel.ERROR, CustomLevel.OFF
1620 };
1621 static class CustomLogRecord {
1622 public final CustomLevel logLevel;
1623 public final java.lang.System.Logger logger;
1624 public final String msg;
1625 public final Object[] params;
1626 public final Throwable thrown;
1627 public final ResourceBundle bundle;
1628
1629 CustomLogRecord(java.lang.System.Logger producer,
1630 CustomLevel level, String msg) {
1631 this(producer, level, msg, (ResourceBundle)null, (Throwable)null, (Object[])null);
1632 }
1633
1634 CustomLogRecord(java.lang.System.Logger producer,
1635 CustomLevel level, String msg, ResourceBundle bundle,
1636 Throwable thrown, Object... params) {
1637 this.logger = producer;
1638 this.logLevel = level;
1639 this.msg = msg;
1640 this.params = params;
1641 this.thrown = thrown;
1642 this.bundle = bundle;
1643 }
1644 }
1645
1646 static final List<CustomLogRecord> records =
1647 Collections.synchronizedList(new ArrayList<>());
1648
1649 static class CustomLogger implements java.lang.System.Logger {
1650
1651 final String name;
1652 volatile CustomLevel level;
1653 CustomLogger(String name) {
1654 this.name = name;
1655 this.level = CustomLevel.INFO;
1656 }
1657
1658 @Override
1659 public String getName() {
1660 return name;
1661 }
1662
1663 public void setLevel(CustomLevel level) {
1664 this.level = level;
1665 }
1666
1667
1668 @Override
1669 public boolean isLoggable(java.lang.System.Logger.Level level) {
1670
1671 return this.level != CustomLevel.OFF && this.level.ordinal()
1672 >= customLevelMap[level.ordinal()].ordinal();
1673 }
1674
1675 @Override
1676 public void log(java.lang.System.Logger.Level level, ResourceBundle bundle, String key, Throwable thrown) {
1677 if (isLoggable(level)) {
1678 records.add(new CustomLogRecord(this, customLevelMap[level.ordinal()],
1679 key, bundle, thrown));
1680 }
1681 }
1682
1683 @Override
1684 public void log(java.lang.System.Logger.Level level, ResourceBundle bundle, String format, Object... params) {
1685 if (isLoggable(level)) {
1686 records.add(new CustomLogRecord(this, customLevelMap[level.ordinal()],
1687 format, bundle, null, params));
1688 }
1689 }
1690
1691 }
1692
1693 final Map<String, java.lang.System.Logger> applicationLoggers =
1694 Collections.synchronizedMap(new HashMap<>());
1695 final Map<String, java.lang.System.Logger> systemLoggers =
1696 Collections.synchronizedMap(new HashMap<>());
1697
1698 @Override
1699 public java.lang.System.Logger getLogger(String name, Class<?> caller) {
1700 ClassLoader callerLoader = caller.getClassLoader();
1701 if (callerLoader == null) {
1702 systemLoggers.putIfAbsent(name, new CustomLogger(name));
1703 return systemLoggers.get(name);
1704 } else {
1705 applicationLoggers.putIfAbsent(name, new CustomLogger(name));
1706 return applicationLoggers.get(name);
1707 }
1708 }
1709
1710 CustomLevel fromJul(Level level) {
1711 if (level.intValue() == Level.OFF.intValue()) {
1712 return CustomLevel.OFF;
1713 } else if (level.intValue() > Level.SEVERE.intValue()) {
1714 return CustomLevel.ERROR;
1715 } else if (level.intValue() > Level.WARNING.intValue()) {
1716 return CustomLevel.ERROR;
1717 } else if (level.intValue() > Level.INFO.intValue()) {
1718 return CustomLevel.WARN;
1719 } else if (level.intValue() > Level.CONFIG.intValue()) {
1720 return CustomLevel.INFO;
1721 } else if (level.intValue() > Level.FINER.intValue()) {
1722 return CustomLevel.DEBUG;
1723 } else if (level.intValue() > Level.FINEST.intValue()) {
1724 return CustomLevel.TRACE;
1725 } else if (level.intValue() == Level.ALL.intValue()) {
1726 return CustomLevel.ALL;
1727 } else {
1728 return CustomLevel.TRACE;
1729 }
1730 }
1731
1732 Level toJul(CustomLevel level) {
1733 switch(level) {
1734 case OFF: return Level.OFF;
1735 case FATAL: return Level.SEVERE;
1736 case ERROR: return Level.SEVERE;
1737 case WARN: return Level.WARNING;
1738 case INFO: return Level.INFO;
1739 case DEBUG: return Level.FINE;
1740 case TRACE: return Level.FINER;
1741 case ALL: return Level.ALL;
1742 default: throw new InternalError("No such level: "+level);
1743 }
1744 }
1745
1746 }
1747
1748 public static class CustomBackendTester extends
1749 BackendTester<CustomLoggerFinder.CustomLogRecord> {
1750
1751 public final CustomLoggerFinder provider;
1752
1753 public CustomBackendTester(boolean isSystem) {
1754 this(isSystem, null, null);
1755 }
1756
1757 public CustomBackendTester(boolean isSystem,
1758 Class<? extends java.lang.System.Logger> restrictedTo) {
1759 this(isSystem, restrictedTo, null);
1760 }
1761
1762 public CustomBackendTester(boolean isSystem,
1763 ResourceBundle localized) {
1764 this(isSystem, null, localized);
1765 }
1766
1767 public CustomBackendTester(boolean isSystem,
1768 Class<? extends java.lang.System.Logger> restrictedTo,
1769 ResourceBundle localized) {
1770 super(isSystem, restrictedTo, localized);
1771 provider = (CustomLoggerFinder)java.lang.System.LoggerFinder.getLoggerFinder();
1772 }
1773
1774 @Override
1775 public java.lang.System.Logger convert(java.lang.System.Logger logger) {
1776 if (restrictedTo != null && restrictedTo.isInstance(logger)) {
1777 return logger;
1778 } else if (restrictedTo == jdkLoggerClass) {
1779 return logger;
1780 } else {
1781 return java.lang.System.Logger.class.cast(
1782 sun.util.logging.PlatformLoggerBridge.convert(logger));
1783 }
1784 }
1785
1786 class CustomBackendAdaptor extends BackendAdaptor {
1787
1788 @Override
1789 public String getLoggerName(CustomLoggerFinder.CustomLogRecord res) {
1790 return res.logger.getName();
1791 }
1792
1793 @Override
1794 public CustomLoggerFinder.CustomLevel getLevel(CustomLoggerFinder.CustomLogRecord res) {
1795 return res.logLevel;
1796 }
1797
1798 @Override
1799 public String getMessage(CustomLoggerFinder.CustomLogRecord res) {
1800 return res.msg;
1801 }
1802
1803 @Override // we don't support source class name in our custom provider implementation
1804 public String getSourceClassName(CustomLoggerFinder.CustomLogRecord res) {
1805 return null;
1806 }
1807
1808 @Override // we don't support source method name in our custom provider implementation
1809 public String getSourceMethodName(CustomLoggerFinder.CustomLogRecord res) {
1810 return null;
1811 }
1812
1813 @Override
1814 public Throwable getThrown(CustomLoggerFinder.CustomLogRecord res) {
1815 return res.thrown;
1816 }
1817
1818 @Override
1819 public ResourceBundle getResourceBundle(CustomLoggerFinder.CustomLogRecord res) {
1820 return res.bundle;
1821 }
1822
1823 @Override
1824 public void setLevel(java.lang.System.Logger logger, Level level) {
1825 final CustomLoggerFinder.CustomLogger l =
1826 (CustomLoggerFinder.CustomLogger)
1827 (isSystem ? provider.getLogger(logger.getName(), Thread.class) :
1828 provider.getLogger(logger.getName(), LoggerFinderBackendTest.class));
1829 l.setLevel(provider.fromJul(level));
1830 }
1831 @Override
1832 public void setLevel(java.lang.System.Logger logger,
1833 java.lang.System.Logger.Level level) {
1834 setLevel(logger, toJUL(level));
1835 }
1836
1837 CustomLoggerFinder.CustomLevel getLevel(java.lang.System.Logger logger) {
1838 final CustomLoggerFinder.CustomLogger l =
1839 (CustomLoggerFinder.CustomLogger)
1840 (isSystem ? provider.getLogger(logger.getName(), Thread.class) :
1841 provider.getLogger(logger.getName(), LoggerFinderBackendTest.class));
1842 return l.level;
1843 }
1844
1845 @Override
1846 public List<CustomLoggerFinder.CustomLogRecord> getBackendRecords() {
1847 return CustomLoggerFinder.records;
1848 }
1849
1850 @Override
1851 public void resetBackendRecords() {
1852 CustomLoggerFinder.records.clear();
1853 }
1854
1855 @Override
1856 public boolean shouldBeLoggable(Levels level, Level loggerLevel) {
1857 return loggerLevel != Level.OFF &&
1858 fromLevels(level).ordinal() <= provider.fromJul(loggerLevel).ordinal();
1859 }
1860
1861 @Override
1862 public boolean isLoggable(java.lang.System.Logger logger, Level l) {
1863 return super.isLoggable(logger, l);
1864 }
1865
1866 @Override
1867 public boolean shouldBeLoggable(Level logLevel, Level loggerLevel) {
1868 return loggerLevel != Level.OFF &&
1869 provider.fromJul(logLevel).ordinal() <= provider.fromJul(loggerLevel).ordinal();
1870 }
1871
1872 @Override // we don't support source class name in our custom provider implementation
1873 public String getCallerClassName(Levels level, String clazz) {
1874 return null;
1875 }
1876
1877 @Override // we don't support source method name in our custom provider implementation
1878 public String getCallerMethodName(Levels level, String method) {
1879 return null;
1880 }
1881
1882 @Override // we don't support source class name in our custom provider implementation
1883 public String getCallerClassName(MethodInvoker<?,?> logMethod, String clazz) {
1884 return null;
1885 }
1886
1887 @Override // we don't support source method name in our custom provider implementation
1888 public String getCallerMethodName(MethodInvoker<?,?> logMethod, String method) {
1889 return null;
1890 }
1891
1892 @Override
1893 public CustomLoggerFinder.CustomLevel getMappedLevel(Object level) {
1894 if (level instanceof java.lang.System.Logger.Level) {
1895 final int index = ((java.lang.System.Logger.Level)level).ordinal();
1896 return CustomLoggerFinder.customLevelMap[index];
1897 } else if (level instanceof Level) {
1898 return provider.fromJul((Level)level);
1899 }
1900 return (CustomLoggerFinder.CustomLevel) level;
1901 }
1902
1903 CustomLoggerFinder.CustomLevel fromLevels(Levels level) {
1904 switch(level) {
1905 case SEVERE:
1906 return CustomLoggerFinder.CustomLevel.ERROR;
1907 case WARNING:
1908 return CustomLoggerFinder.CustomLevel.WARN;
1909 case INFO:
1910 return CustomLoggerFinder.CustomLevel.INFO;
1911 case CONFIG: case FINE:
1912 return CustomLoggerFinder.CustomLevel.DEBUG;
1913 case FINER: case FINEST:
1914 return CustomLoggerFinder.CustomLevel.TRACE;
1915 }
1916 throw new InternalError("No such level "+level);
1917 }
1918
1919 }
1920
1921 @Override
1922 BackendAdaptor adaptor() {
1923 return new CustomBackendAdaptor();
1924 }
1925
1926 }
1927
1928 public static class CustomBackendTesterFactory extends BackendTesterFactory {
1929
1930 @Override
1931 public BackendTester createBackendTester(boolean isSystem) {
1932 return new CustomBackendTester(isSystem);
1933 }
1934
1935 @Override
1936 public BackendTester createBackendTester(boolean isSystem,
1937 Class<? extends java.lang.System.Logger> restrictedTo) {
1938 return new CustomBackendTester(isSystem, restrictedTo);
1939 }
1940
1941 @Override
1942 public BackendTester createBackendTester(boolean isSystem,
1943 Class<? extends java.lang.System.Logger> restrictedTo,
1944 ResourceBundle bundle) {
1945 return new CustomBackendTester(isSystem, restrictedTo, bundle);
1946 }
1947
1948 @Override
1949 public BackendTester createBackendTester(boolean isSystem,
1950 ResourceBundle bundle) {
1951 return new CustomBackendTester(isSystem, bundle);
1952 }
1953 }
1954
1955 static final Method getLazyLogger;
1956 static final Method accessLoggerFinder;
1957 static {
1958 // sun.util.logger.LazyLoggers.getLazyLogger(name, caller);
1959 try {
1960 Class<?> lazyLoggers = sun.util.logger.LazyLoggers.class;
1961 getLazyLogger = lazyLoggers.getMethod("getLazyLogger",
1962 String.class, Class.class);
1963 getLazyLogger.setAccessible(true);
1964 Class<?> loggerFinderLoader =
1965 Class.forName("java.lang.System$LoggerFinder$LoggerFinderLoader");
1966 accessLoggerFinder = loggerFinderLoader.getDeclaredMethod("spi");
1967 accessLoggerFinder.setAccessible(true);
1968 } catch (Throwable ex) {
1969 throw new ExceptionInInitializerError(ex);
1970 }
1971 }
1972
1973 static java.lang.System.Logger getSystemLogger(String name, Class<?> caller) throws Exception {
1974 try {
1975 return java.lang.System.Logger.class.cast(getLazyLogger.invoke(null, name, caller));
1976 } catch (InvocationTargetException x) {
1977 Throwable t = x.getTargetException();
1978 if (t instanceof Exception) {
1979 throw (Exception)t;
1980 } else {
1981 throw (Error)t;
1982 }
1983 }
1984 }
1985 static java.lang.System.Logger getSystemLogger(String name,
1986 ResourceBundle bundle, Class<?> caller) throws Exception {
1987 try {
1988 LoggerFinder provider = LoggerFinder.class.cast(accessLoggerFinder.invoke(null));
1989 return provider.getLocalizedLogger(name, bundle, caller);
1990 } catch (InvocationTargetException x) {
1991 Throwable t = x.getTargetException();
1992 if (t instanceof Exception) {
1993 throw (Exception)t;
1994 } else {
1995 throw (Error)t;
1996 }
1997 }
1998 }
1999
2000 // Change this to 'true' to get more traces...
2001 public static boolean verbose = false;
2002
2003 public static void main(String[] argv) throws Exception {
2004
2005 final AtomicInteger nb = new AtomicInteger(0);
2006 final boolean hidesProvider = Boolean.getBoolean("test.logger.hidesProvider");
2007 System.out.println(ClassLoader.getSystemClassLoader());
2008 final BackendTesterFactory factory;
2009 if (java.lang.System.LoggerFinder.getLoggerFinder() instanceof CustomLoggerFinder) {
2010 if (hidesProvider) {
2011 System.err.println("Custom backend "
2012 + java.lang.System.LoggerFinder.getLoggerFinder()
2013 + " should have been hidden!");
2014 throw new RuntimeException(
2015 "Custom backend should have been hidden: "
2016 + "check value of java.system.class.loader property");
2017 }
2018 System.out.println("Using custom backend");
2019 factory = new CustomBackendTesterFactory();
2020 } else {
2021 if (!hidesProvider) {
2022 System.err.println("Default JUL backend "
2023 + java.lang.System.LoggerFinder.getLoggerFinder()
2024 + " should have been hidden!");
2025 throw new RuntimeException(
2026 "Default JUL backend should have been hidden: "
2027 + "check value of java.system.class.loader property");
2028 }
2029 System.out.println("Using JUL backend");
2030 factory = new JULBackendTesterFactory();
2031 }
2032
2033 testBackend(nb, factory);
2034 }
2035
2036 public static void testBackend(AtomicInteger nb, BackendTesterFactory factory) throws Exception {
2037
2038 // Tests all level specifics methods with loggers configured with
2039 // all possible levels and loggers obtained with all possible
2040 // entry points from LoggerFactory and JdkLoggerFactory, with
2041 // JUL as backend.
2042
2043 // Test a simple application logger with JUL backend
2044 final BackendTester tester = factory.createBackendTester(false);
2045 final java.lang.System.Logger logger =
2046 java.lang.System.LoggerFinder.getLoggerFinder()
2047 .getLogger("foo", LoggerFinderBackendTest.class);
2048
2049 testLogger(tester, logger, nb);
2050
2051 // Test a simple system logger with JUL backend
2052 final java.lang.System.Logger system =
2053 java.lang.System.LoggerFinder.getLoggerFinder()
2054 .getLogger("bar", Thread.class);
2055 final BackendTester systemTester = factory.createBackendTester(true);
2056 testLogger(systemTester, system, nb);
2057
2058 // Test a localized application logger with null resource bundle and
2059 // JUL backend
2060 final java.lang.System.Logger noBundleLogger =
2061 java.lang.System.LoggerFinder.getLoggerFinder()
2062 .getLocalizedLogger("baz", null, LoggerFinderBackendTest.class);
2063 final BackendTester noBundleTester =
2064 factory.createBackendTester(false, spiLoggerClass);
2065 testLogger(noBundleTester, noBundleLogger, nb);
2066
2067 // Test a localized system logger with null resource bundle and JUL
2068 // backend
2069 final java.lang.System.Logger noBundleSysLogger =
2070 java.lang.System.LoggerFinder.getLoggerFinder()
2071 .getLocalizedLogger("oof", null, Thread.class);
2072 final BackendTester noBundleSysTester =
2073 factory.createBackendTester(true, spiLoggerClass);
2074 testLogger(noBundleSysTester, noBundleSysLogger, nb);
2075
2076 // Test a localized application logger with null resource bundle and
2077 // JUL backend
2078 try {
2079 System.getLogger("baz", null);
2080 throw new RuntimeException("Expected NullPointerException not thrown");
2081 } catch (NullPointerException x) {
2082 System.out.println("System.Loggers.getLogger(\"baz\", null): got expected " + x);
2083 }
2084 final java.lang.System.Logger noBundleExtensionLogger =
2085 getSystemLogger("baz", null, LoggerFinderBackendTest.class);
2086 final BackendTester noBundleExtensionTester =
2087 factory.createBackendTester(false, jdkLoggerClass);
2088 testLogger(noBundleExtensionTester, noBundleExtensionLogger, nb);
2089
2090 // Test a simple system logger with JUL backend
2091 final java.lang.System.Logger sysExtensionLogger =
2092 getSystemLogger("oof", Thread.class);
2093 final BackendTester sysExtensionTester =
2094 factory.createBackendTester(true, jdkLoggerClass);
2095 testLogger(sysExtensionTester, sysExtensionLogger, nb);
2096
2097 // Test a localized system logger with null resource bundle and JUL
2098 // backend
2099 final java.lang.System.Logger noBundleSysExtensionLogger =
2100 getSystemLogger("oof", null, Thread.class);
2101 final BackendTester noBundleSysExtensionTester =
2102 factory.createBackendTester(true, jdkLoggerClass);
2103 testLogger(noBundleSysExtensionTester, noBundleSysExtensionLogger, nb);
2104
2105 // Test a localized application logger converted to JDK with null
2106 // resource bundle and JUL backend
2107 final java.lang.System.Logger noBundleConvertedLogger =
2108 (java.lang.System.Logger)
2109 sun.util.logging.PlatformLoggerBridge.convert(noBundleLogger);
2110 final BackendTester noBundleJdkTester = factory.createBackendTester(false);
2111 testLogger(noBundleJdkTester, noBundleConvertedLogger, nb);
2112
2113 // Test a localized system logger converted to JDK with null resource
2114 // bundle and JUL backend
2115 final java.lang.System.Logger noBundleConvertedSysLogger =
2116 (java.lang.System.Logger)
2117 sun.util.logging.PlatformLoggerBridge.convert(noBundleSysLogger);
2118 final BackendTester noBundleJdkSysTester = factory.createBackendTester(true);
2119 testLogger(noBundleJdkSysTester, noBundleConvertedSysLogger, nb);
2120
2121 // Test a localized application logger with resource bundle and JUL
2122 // backend
2123 final ResourceBundle bundle =
2124 ResourceBundle.getBundle(ResourceBundeLocalized.class.getName());
2125 final java.lang.System.Logger bundleLogger =
2126 java.lang.System.LoggerFinder.getLoggerFinder()
2127 .getLocalizedLogger("toto", bundle, LoggerFinderBackendTest.class);
2128 final BackendTester bundleTester =
2129 factory.createBackendTester(false, spiLoggerClass, bundle);
2130 testLogger(bundleTester, bundleLogger, nb);
2131
2132 // Test a localized system logger with resource bundle and JUL backend
2133 final java.lang.System.Logger bundleSysLogger =
2134 java.lang.System.LoggerFinder.getLoggerFinder()
2135 .getLocalizedLogger("titi", bundle, Thread.class);
2136 final BackendTester bundleSysTester =
2137 factory.createBackendTester(true, spiLoggerClass, bundle);
2138 testLogger(bundleSysTester, bundleSysLogger, nb);
2139
2140 // Test a localized Jdk application logger with resource bundle and JUL
2141 // backend
2142 final java.lang.System.Logger bundleExtensionLogger =
2143 System.getLogger("tita", bundle);
2144 final BackendTester bundleExtensionTester =
2145 factory.createBackendTester(false, jdkLoggerClass, bundle);
2146 testLogger(bundleExtensionTester, bundleExtensionLogger, nb);
2147
2148 // Test a localized Jdk system logger with resource bundle and JUL
2149 // backend
2150 final java.lang.System.Logger bundleExtensionSysLogger =
2151 getSystemLogger("titu", bundle, Thread.class);
2152 final BackendTester bundleExtensionSysTester =
2153 factory.createBackendTester(true, jdkLoggerClass, bundle);
2154 testLogger(bundleExtensionSysTester, bundleExtensionSysLogger, nb);
2155
2156 // Test a localized application logger converted to JDK with resource
2157 // bundle and JUL backend
2158 final BackendTester bundleJdkTester =
2159 factory.createBackendTester(false, bundle);
2160 final java.lang.System.Logger bundleConvertedLogger =
2161 (java.lang.System.Logger)
2162 sun.util.logging.PlatformLoggerBridge.convert(bundleLogger);
2163 testLogger(bundleJdkTester, bundleConvertedLogger, nb);
2164
2165 // Test a localized Jdk system logger converted to JDK with resource
2166 // bundle and JUL backend
2167 final BackendTester bundleJdkSysTester =
2168 factory.createBackendTester(true, bundle);
2169 final java.lang.System.Logger bundleConvertedSysLogger =
2170 (java.lang.System.Logger)
2171 sun.util.logging.PlatformLoggerBridge.convert(bundleSysLogger);
2172 testLogger(bundleJdkSysTester, bundleConvertedSysLogger, nb);
2173
2174 // Now need to add tests for all the log/logp/logrb methods...
2175
2176 }
2177
2178 private static class FooObj {
2179 final String s;
2180 FooObj(String s) {
2181 this.s = s;
2182 }
2183
2184 @Override
2185 public String toString() {
2186 return super.toString() +": "+s;
2187 }
2188
2189 }
2190
2191 public static void testLogger(BackendTester tester,
2192 java.lang.System.Logger spiLogger, AtomicInteger nb) {
2193
2194 // Test all level-specific method forms:
2195 // fatal(...) error(...) severe(...) etc...
2196 java.lang.System.Logger jdkLogger = tester.convert(spiLogger);
2197 for (Levels l : Levels.values()) {
2198 java.lang.System.Logger logger =
2199 l.definingClass.equals(spiLoggerClass) ? spiLogger : jdkLogger;
2200 tester.testLevel(l, logger, l.method + "[" + logger.getName()+ "]-"
2201 + nb.incrementAndGet());
2202 tester.testLevel(l, logger, l.method + "[" + logger.getName()+ "]-"
2203 + nb.incrementAndGet(),
2204 bundleParam);
2205 final int nbb = nb.incrementAndGet();
2206 tester.testLevel(l, logger, () -> l.method + "[" + logger.getName()
2207 + "]-" + nbb);
2208 }
2209 for (Levels l : Levels.values()) {
2210 java.lang.System.Logger logger =
2211 l.definingClass.equals(spiLoggerClass) ? spiLogger : jdkLogger;
2212 tester.testLevel(l, logger,
2213 l.method + "[" + logger.getName()+ "]({0},{1})-"
2214 + nb.incrementAndGet(),
2215 "One", "Two");
2216 tester.testLevel(l, logger,
2217 l.method + "[" + logger.getName()+ "]({0},{1})-"
2218 + nb.incrementAndGet(),
2219 bundleParam, "One", "Two");
2220 }
2221 final Throwable thrown = new RuntimeException("Test");
2222 for (Levels l : Levels.values()) {
2223 java.lang.System.Logger logger =
2224 l.definingClass.equals(spiLoggerClass) ? spiLogger : jdkLogger;
2225 tester.testLevel(l, logger, l.method + "[" + logger.getName()+ "]-"
2226 + nb.incrementAndGet(),
2227 thrown);
2228 tester.testLevel(l, logger, l.method + "[" + logger.getName()+ "]-"
2229 + nb.incrementAndGet(),
2230 bundleParam, thrown);
2231 final int nbb = nb.incrementAndGet();
2232 tester.testLevel(l, logger, ()->l.method + "[" + logger.getName()+ "]-"
2233 + nbb, thrown);
2234 }
2235
2236 java.lang.System.Logger logger = jdkLogger;
2237
2238 // test System.Logger methods
2239 tester.testSpiLog(logger, "[" + logger.getName()+ "]-"
2240 + nb.incrementAndGet());
2241 tester.testSpiLog(logger, bundleParam, "[" + logger.getName()+ "]-"
2242 + nb.incrementAndGet());
2243 tester.testSpiLog(logger, "[" + logger.getName()+ "]-({0},{1})"
2244 + nb.incrementAndGet(), "One", "Two");
2245 tester.testSpiLog(logger, bundleParam, "[" + logger.getName()+ "]-({0},{1})"
2246 + nb.incrementAndGet(), "One", "Two");
2247 tester.testSpiLog(logger, "[" + logger.getName()+ "]-"
2248 + nb.incrementAndGet(), thrown);
2249 tester.testSpiLog(logger, bundleParam, "[" + logger.getName()+ "]-"
2250 + nb.incrementAndGet(), thrown);
2251 final int nbb01 = nb.incrementAndGet();
2252 tester.testSpiLog(logger, () -> "[" + logger.getName()+ "]-" + nbb01);
2253 final int nbb02 = nb.incrementAndGet();
2254 tester.testSpiLog(logger, thrown, () -> "[" + logger.getName()+ "]-" + nbb02);
2255 final int nbb03 = nb.incrementAndGet();
2256 tester.testSpiLog(logger, new FooObj("[" + logger.getName()+ "]-" + nbb03));
2257
2258 // Test all log method forms:
2259 // jdk.internal.logging.Logger.log(...)
2260 tester.testLog(logger, "[" + logger.getName()+ "]-"
2261 + nb.incrementAndGet());
2262 tester.testLogrb(logger, bundleParam, "[" + logger.getName()+ "]-"
2263 + nb.incrementAndGet());
2264 tester.testLog(logger, "[" + logger.getName()+ "]-({0},{1})"
2265 + nb.incrementAndGet(), "One", "Two");
2266 tester.testLogrb(logger, bundleParam, "[" + logger.getName()+ "]-({0},{1})"
2267 + nb.incrementAndGet(), "One", "Two");
2268 tester.testLog(logger, "[" + logger.getName()+ "]-"
2269 + nb.incrementAndGet(), thrown);
2270 tester.testLogrb(logger, bundleParam, "[" + logger.getName()+ "]-"
2271 + nb.incrementAndGet(), thrown);
2272 final int nbb1 = nb.incrementAndGet();
2273 tester.testLog(logger, () -> "[" + logger.getName()+ "]-" + nbb1);
2274 final int nbb2 = nb.incrementAndGet();
2275 tester.testLog(logger, thrown, () -> "[" + logger.getName()+ "]-" + nbb2);
2276
2277 // Test all logp method forms
2278 // jdk.internal.logging.Logger.logp(...)
2279 tester.testLogp(logger, "clazz" + nb.incrementAndGet(),
2280 "method" + nb.incrementAndGet(),
2281 "[" + logger.getName()+ "]-"
2282 + nb.incrementAndGet());
2283 tester.testLogrb(logger, "clazz" + nb.incrementAndGet(),
2284 "method" + nb.incrementAndGet(), bundleParam,
2285 "[" + logger.getName()+ "]-"
2286 + nb.incrementAndGet());
2287 tester.testLogp(logger, "clazz" + nb.incrementAndGet(),
2288 "method" + nb.incrementAndGet(),
2289 "[" + logger.getName()+ "]-({0},{1})"
2290 + nb.incrementAndGet(), "One", "Two");
2291 tester.testLogrb(logger, "clazz" + nb.incrementAndGet(),
2292 "method" + nb.incrementAndGet(), bundleParam,
2293 "[" + logger.getName()+ "]-({0},{1})"
2294 + nb.incrementAndGet(), "One", "Two");
2295 tester.testLogp(logger, "clazz" + nb.incrementAndGet(),
2296 "method" + nb.incrementAndGet(),
2297 "[" + logger.getName()+ "]-"
2298 + nb.incrementAndGet(), thrown);
2299 tester.testLogrb(logger, "clazz" + nb.incrementAndGet(),
2300 "method" + nb.incrementAndGet(), bundleParam,
2301 "[" + logger.getName()+ "]-"
2302 + nb.incrementAndGet(), thrown);
2303 final int nbb3 = nb.incrementAndGet();
2304 tester.testLogp(logger, "clazz" + nb.incrementAndGet(),
2305 "method" + nb.incrementAndGet(),
2306 () -> "[" + logger.getName()+ "]-" + nbb3);
2307 final int nbb4 = nb.incrementAndGet();
2308 tester.testLogp(logger, "clazz" + nb.incrementAndGet(),
2309 "method" + nb.incrementAndGet(),
2310 thrown, () -> "[" + logger.getName()+ "]-" + nbb4);
2311 }
2312
2313 }