1 /*

     2  * Copyright (c) 2015, 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 import java.security.AccessController;

    24 import java.security.CodeSource;

    25 import java.security.Permission;

    26 import java.security.PermissionCollection;

    27 import java.security.Permissions;

    28 import java.security.Policy;

    29 import java.security.PrivilegedAction;

    30 import java.security.ProtectionDomain;

    31 import java.util.Arrays;

    32 import java.util.Collections;

    33 import java.util.Enumeration;

    34 import java.util.HashMap;

    35 import java.util.Map;

    36 import java.util.Objects;

    37 import java.util.Queue;

    38 import java.util.ResourceBundle;

    39 import java.util.concurrent.ArrayBlockingQueue;

    40 import java.util.concurrent.ConcurrentHashMap;

    41 import java.util.concurrent.atomic.AtomicBoolean;

    42 import java.util.concurrent.atomic.AtomicLong;

    43 import java.util.function.Supplier;

    44 import java.lang.System.LoggerFinder;

    45 import java.lang.System.Logger;

    46 import java.lang.System.Logger.Level;

    47 import java.security.AccessControlException;

    48 import java.util.stream.Stream;

    49 import sun.util.logging.PlatformLogger;

    50 

    51 /**

    52  * @test

    53  * @bug     8140364

    54  * @summary JDK implementation specific unit test for JDK internal API.

    55  *   Tests a naive implementation of System.Logger, and in particular

    56  *   the default mapping provided by PlatformLogger.

    57  * @modules java.base/sun.util.logging

    58  * @build CustomSystemClassLoader BasePlatformLoggerTest

    59  * @run  main/othervm -Djava.system.class.loader=CustomSystemClassLoader BasePlatformLoggerTest NOSECURITY

    60  * @run  main/othervm -Djava.system.class.loader=CustomSystemClassLoader BasePlatformLoggerTest NOPERMISSIONS

    61  * @run  main/othervm -Djava.system.class.loader=CustomSystemClassLoader BasePlatformLoggerTest WITHPERMISSIONS

    62  * @author danielfuchs

    63  */

    64 public class BasePlatformLoggerTest {

    65 

    66     public static final RuntimePermission LOGGERFINDER_PERMISSION =

    67                 new RuntimePermission("loggerFinder");

    68 

    69     final static AtomicLong sequencer = new AtomicLong();

    70     final static boolean VERBOSE = false;

    71     static final ThreadLocal<AtomicBoolean> allowControl = new ThreadLocal<AtomicBoolean>() {

    72         @Override

    73         protected AtomicBoolean initialValue() {

    74             return  new AtomicBoolean(false);

    75         }

    76     };

    77     static final ThreadLocal<AtomicBoolean> allowAccess = new ThreadLocal<AtomicBoolean>() {

    78         @Override

    79         protected AtomicBoolean initialValue() {

    80             return  new AtomicBoolean(false);

    81         }

    82     };

    83     static final ThreadLocal<AtomicBoolean> allowAll = new ThreadLocal<AtomicBoolean>() {

    84         @Override

    85         protected AtomicBoolean initialValue() {

    86             return  new AtomicBoolean(false);

    87         }

    88     };

    89 

    90     static final Class<?> providerClass;

    91     static {

    92         try {

    93             providerClass = ClassLoader.getSystemClassLoader().loadClass("BasePlatformLoggerTest$BaseLoggerFinder");

    94         } catch (ClassNotFoundException ex) {

    95             throw new ExceptionInInitializerError(ex);

    96         }

    97     }

    98 

    99     static final PlatformLogger.Level[] julLevels = {

   100         PlatformLogger.Level.ALL,

   101         PlatformLogger.Level.FINEST,

   102         PlatformLogger.Level.FINER,

   103         PlatformLogger.Level.FINE,

   104         PlatformLogger.Level.CONFIG,

   105         PlatformLogger.Level.INFO,

   106         PlatformLogger.Level.WARNING,

   107         PlatformLogger.Level.SEVERE,

   108         PlatformLogger.Level.OFF,

   109     };

   110 

   111     static final Level[] mappedLevels = {

   112         Level.ALL,     // ALL

   113         Level.TRACE,   // FINEST

   114         Level.TRACE,   // FINER

   115         Level.DEBUG,   // FINE

   116         Level.DEBUG,   // CONFIG

   117         Level.INFO,    // INFO

   118         Level.WARNING, // WARNING

   119         Level.ERROR,   // SEVERE

   120         Level.OFF,     // OFF

   121     };

   122 

   123     final static Map<PlatformLogger.Level, Level> julToSpiMap;

   124     static {

   125         Map<PlatformLogger.Level, Level> map = new HashMap<>();

   126         if (mappedLevels.length != julLevels.length) {

   127             throw new ExceptionInInitializerError("Array lengths differ"

   128                 + "\n\tjulLevels=" + Arrays.deepToString(julLevels)

   129                 + "\n\tmappedLevels=" + Arrays.deepToString(mappedLevels));

   130         }

   131         for (int i=0; i<julLevels.length; i++) {

   132             map.put(julLevels[i], mappedLevels[i]);

   133         }

   134         julToSpiMap = Collections.unmodifiableMap(map);

   135     }

   136 

   137     public static class MyBundle extends ResourceBundle {

   138 

   139         final ConcurrentHashMap<String,String> map = new ConcurrentHashMap<>();

   140 

   141         @Override

   142         protected Object handleGetObject(String key) {

   143             if (key.contains(" (translated)")) {

   144                 throw new RuntimeException("Unexpected key: " + key);

   145             }

   146             return map.computeIfAbsent(key, k -> k + " (translated)");

   147         }

   148 

   149         @Override

   150         public Enumeration<String> getKeys() {

   151             return Collections.enumeration(map.keySet());

   152         }

   153 

   154     }

   155     public static class MyLoggerBundle extends MyBundle {

   156 

   157     }

   158 

   159 

   160     public static interface TestLoggerFinder  {

   161         final ConcurrentHashMap<String, LoggerImpl> system = new ConcurrentHashMap<>();

   162         final ConcurrentHashMap<String, LoggerImpl> user = new ConcurrentHashMap<>();

   163         public Queue<LogEvent> eventQueue = new ArrayBlockingQueue<>(128);

   164 

   165         public static final class LogEvent implements Cloneable {

   166 

   167             public LogEvent() {

   168                 this(sequencer.getAndIncrement());

   169             }

   170 

   171             LogEvent(long sequenceNumber) {

   172                 this.sequenceNumber = sequenceNumber;

   173             }

   174 

   175             long sequenceNumber;

   176             boolean isLoggable;

   177             String loggerName;

   178             Level level;

   179             ResourceBundle bundle;

   180             Throwable thrown;

   181             Object[] args;

   182             Supplier<String> supplier;

   183             String msg;

   184 

   185             Object[] toArray() {

   186                 return new Object[] {

   187                     sequenceNumber,

   188                     isLoggable,

   189                     loggerName,

   190                     level,

   191                     bundle,

   192                     thrown,

   193                     args,

   194                     supplier,

   195                     msg,

   196                 };

   197             }

   198 

   199             @Override

   200             public String toString() {

   201                 return Arrays.deepToString(toArray());

   202             }

   203 

   204 

   205 

   206             @Override

   207             public boolean equals(Object obj) {

   208                 return obj instanceof LogEvent

   209                         && Objects.deepEquals(this.toArray(), ((LogEvent)obj).toArray());

   210             }

   211 

   212             @Override

   213             public int hashCode() {

   214                 return Objects.hash(toArray());

   215             }

   216 

   217             public LogEvent cloneWith(long sequenceNumber)

   218                     throws CloneNotSupportedException {

   219                 LogEvent cloned = (LogEvent)super.clone();

   220                 cloned.sequenceNumber = sequenceNumber;

   221                 return cloned;

   222             }

   223 

   224             public static LogEvent of(boolean isLoggable, String name,

   225                     Level level, ResourceBundle bundle,

   226                     String key, Throwable thrown) {

   227                 LogEvent evt = new LogEvent();

   228                 evt.isLoggable = isLoggable;

   229                 evt.loggerName = name;

   230                 evt.level = level;

   231                 evt.args = null;

   232                 evt.bundle = bundle;

   233                 evt.thrown = thrown;

   234                 evt.supplier = null;

   235                 evt.msg = key;

   236                 return evt;

   237             }

   238 

   239             public static LogEvent of(boolean isLoggable, String name,

   240                     Level level, Throwable thrown, Supplier<String> supplier) {

   241                 LogEvent evt = new LogEvent();

   242                 evt.isLoggable = isLoggable;

   243                 evt.loggerName = name;

   244                 evt.level = level;

   245                 evt.args = null;

   246                 evt.bundle = null;

   247                 evt.thrown = thrown;

   248                 evt.supplier = supplier;

   249                 evt.msg = null;

   250                 return evt;

   251             }

   252 

   253             public static LogEvent of(boolean isLoggable, String name,

   254                     Level level, ResourceBundle bundle,

   255                     String key, Object... params) {

   256                 LogEvent evt = new LogEvent();

   257                 evt.isLoggable = isLoggable;

   258                 evt.loggerName = name;

   259                 evt.level = level;

   260                 evt.args = params;

   261                 evt.bundle = bundle;

   262                 evt.thrown = null;

   263                 evt.supplier = null;

   264                 evt.msg = key;

   265                 return evt;

   266             }

   267 

   268             public static LogEvent of(long sequenceNumber,

   269                     boolean isLoggable, String name,

   270                     Level level, ResourceBundle bundle,

   271                     String key, Supplier<String> supplier,

   272                     Throwable thrown, Object... params) {

   273                 LogEvent evt = new LogEvent(sequenceNumber);

   274                 evt.loggerName = name;

   275                 evt.level = level;

   276                 evt.args = params;

   277                 evt.bundle = bundle;

   278                 evt.thrown = thrown;

   279                 evt.supplier = supplier;

   280                 evt.msg = key;

   281                 evt.isLoggable = isLoggable;

   282                 return evt;

   283             }

   284 

   285         }

   286 

   287         public class LoggerImpl implements Logger {

   288             private final String name;

   289             private Level level = Level.INFO;

   290 

   291             public LoggerImpl(String name) {

   292                 this.name = name;

   293             }

   294 

   295             @Override

   296             public String getName() {

   297                 return name;

   298             }

   299 

   300             @Override

   301             public boolean isLoggable(Level level) {

   302                 return this.level != Level.OFF && this.level.getSeverity() <= level.getSeverity();

   303             }

   304 

   305             @Override

   306             public void log(Level level, ResourceBundle bundle, String key, Throwable thrown) {

   307                 log(LogEvent.of(isLoggable(level), this.name, level, bundle, key, thrown));

   308             }

   309 

   310             @Override

   311             public void log(Level level, ResourceBundle bundle, String format, Object... params) {

   312                 log(LogEvent.of(isLoggable(level), name, level, bundle, format, params));

   313             }

   314 

   315             void log(LogEvent event) {

   316                 eventQueue.add(event);

   317             }

   318 

   319             @Override

   320             public void log(Level level, Supplier<String> msgSupplier) {

   321                 log(LogEvent.of(isLoggable(level), name, level, null, msgSupplier));

   322             }

   323 

   324             @Override

   325             public void log(Level level,  Supplier<String> msgSupplier, Throwable thrown) {

   326                 log(LogEvent.of(isLoggable(level), name, level, thrown, msgSupplier));

   327             }

   328         }

   329 

   330         public Logger getLogger(String name, Class<?> caller);

   331     }

   332 

   333     public static class BaseLoggerFinder extends LoggerFinder implements TestLoggerFinder {

   334         @Override

   335         public Logger getLogger(String name, Class<?> caller) {

   336             SecurityManager sm = System.getSecurityManager();

   337             if (sm != null) {

   338                 sm.checkPermission(LOGGERFINDER_PERMISSION);

   339             }

   340             PrivilegedAction<ClassLoader> pa = () -> caller.getClassLoader();

   341             ClassLoader callerLoader = AccessController.doPrivileged(pa);

   342             if (callerLoader == null) {

   343                 return system.computeIfAbsent(name, (n) -> new LoggerImpl(n));

   344             } else {

   345                 return user.computeIfAbsent(name, (n) -> new LoggerImpl(n));

   346             }

   347         }

   348     }

   349 

   350     static PlatformLogger getPlatformLogger(String name) {

   351         boolean old = allowAccess.get().get();

   352         allowAccess.get().set(true);

   353         try {

   354             return PlatformLogger.getLogger(name);

   355         } finally {

   356             allowAccess.get().set(old);

   357         }

   358     }

   359 

   360     static enum TestCases {NOSECURITY, NOPERMISSIONS, WITHPERMISSIONS};

   361 

   362     static void setSecurityManager() {

   363         if (System.getSecurityManager() == null) {

   364             Policy.setPolicy(new SimplePolicy(allowControl, allowAccess, allowAll));

   365             System.setSecurityManager(new SecurityManager());

   366         }

   367     }

   368 

   369     public static void main(String[] args) {

   370         if (args.length == 0)

   371             args = new String[] {

   372                 "NOSECURITY",

   373                 "NOPERMISSIONS",

   374                 "WITHPERMISSIONS"

   375             };

   376 

   377 

   378         Stream.of(args).map(TestCases::valueOf).forEach((testCase) -> {

   379             TestLoggerFinder provider;

   380             switch (testCase) {

   381                 case NOSECURITY:

   382                     System.out.println("\n*** Without Security Manager\n");

   383                     provider = TestLoggerFinder.class.cast(LoggerFinder.getLoggerFinder());

   384                     test(provider, true);

   385                     System.out.println("Tetscase count: " + sequencer.get());

   386                     break;

   387                 case NOPERMISSIONS:

   388                     System.out.println("\n*** With Security Manager, without permissions\n");

   389                     setSecurityManager();

   390                     try {

   391                         provider = TestLoggerFinder.class.cast(LoggerFinder.getLoggerFinder());

   392                         throw new RuntimeException("Expected exception not raised");

   393                     } catch (AccessControlException x) {

   394                         if (!LOGGERFINDER_PERMISSION.equals(x.getPermission())) {

   395                             throw new RuntimeException("Unexpected permission check", x);

   396                         }

   397                         final boolean control = allowControl.get().get();

   398                         try {

   399                             allowControl.get().set(true);

   400                             provider = TestLoggerFinder.class.cast(LoggerFinder.getLoggerFinder());

   401                         } finally {

   402                             allowControl.get().set(control);

   403                         }

   404                     }

   405                     test(provider, false);

   406                     System.out.println("Tetscase count: " + sequencer.get());

   407                     break;

   408                 case WITHPERMISSIONS:

   409                     System.out.println("\n*** With Security Manager, with control permission\n");

   410                     setSecurityManager();

   411                     final boolean control = allowControl.get().get();

   412                     try {

   413                         allowControl.get().set(true);

   414                         provider = TestLoggerFinder.class.cast(LoggerFinder.getLoggerFinder());

   415                         test(provider, true);

   416                     } finally {

   417                         allowControl.get().set(control);

   418                     }

   419                     break;

   420                 default:

   421                     throw new RuntimeException("Unknown test case: " + testCase);

   422             }

   423         });

   424         System.out.println("\nPASSED: Tested " + sequencer.get() + " cases.");

   425     }

   426 

   427     public static void test(TestLoggerFinder provider, boolean hasRequiredPermissions) {

   428 

   429         final Map<PlatformLogger, String> loggerDescMap = new HashMap<>();

   430 

   431         TestLoggerFinder.LoggerImpl appSink;

   432         boolean before = allowControl.get().get();

   433         try {

   434             allowControl.get().set(true);

   435             appSink = TestLoggerFinder.LoggerImpl.class.cast(

   436                         provider.getLogger("foo", BasePlatformLoggerTest.class));

   437         } finally {

   438             allowControl.get().set(before);

   439         }

   440 

   441         TestLoggerFinder.LoggerImpl sysSink = null;

   442         before = allowControl.get().get();

   443         try {

   444             allowControl.get().set(true);

   445             sysSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class));

   446         } finally {

   447             allowControl.get().set(before);

   448         }

   449 

   450         if (hasRequiredPermissions && appSink == sysSink) {

   451             throw new RuntimeException("identical loggers");

   452         }

   453 

   454         if (provider.system.contains(appSink)) {

   455             throw new RuntimeException("app logger in system map");

   456         }

   457         if (!provider.user.contains(appSink)) {

   458             throw new RuntimeException("app logger not in appplication map");

   459         }

   460         if (hasRequiredPermissions && provider.user.contains(sysSink)) {

   461             throw new RuntimeException("sys logger in appplication map");

   462         }

   463         if (hasRequiredPermissions && !provider.system.contains(sysSink)) {

   464             throw new RuntimeException("sys logger not in system map");

   465         }

   466 

   467         PlatformLogger platform = getPlatformLogger("foo");

   468         loggerDescMap.put(platform, "PlatformLogger.getLogger(\"foo\")");

   469 

   470         testLogger(provider, loggerDescMap, "foo", null, platform, sysSink);

   471     }

   472 

   473     public static class Foo {

   474 

   475     }

   476 

   477     static void verbose(String msg) {

   478        if (VERBOSE) {

   479            System.out.println(msg);

   480        }

   481     }

   482 

   483     static void checkLogEvent(TestLoggerFinder provider, String desc,

   484             TestLoggerFinder.LogEvent expected) {

   485         TestLoggerFinder.LogEvent actual =  provider.eventQueue.poll();

   486         if (!expected.equals(actual)) {

   487             throw new RuntimeException("mismatch for " + desc

   488                     + "\n\texpected=" + expected

   489                     + "\n\t  actual=" + actual);

   490         } else {

   491             verbose("Got expected results for "

   492                     + desc + "\n\t" + expected);

   493         }

   494     }

   495 

   496     static void checkLogEvent(TestLoggerFinder provider, String desc,

   497             TestLoggerFinder.LogEvent expected, boolean expectNotNull) {

   498         TestLoggerFinder.LogEvent actual =  provider.eventQueue.poll();

   499         if (actual == null && !expectNotNull) return;

   500         if (actual != null && !expectNotNull) {

   501             throw new RuntimeException("Unexpected log event found for " + desc

   502                 + "\n\tgot: " + actual);

   503         }

   504         if (!expected.equals(actual)) {

   505             throw new RuntimeException("mismatch for " + desc

   506                     + "\n\texpected=" + expected

   507                     + "\n\t  actual=" + actual);

   508         } else {

   509             verbose("Got expected results for "

   510                     + desc + "\n\t" + expected);

   511         }

   512     }

   513 

   514     // Calls the methods defined on LogProducer and verify the

   515     // parameters received by the underlying TestLoggerFinder.LoggerImpl

   516     // logger.

   517     private static void testLogger(TestLoggerFinder provider,

   518             Map<PlatformLogger, String> loggerDescMap,

   519             String name,

   520             ResourceBundle loggerBundle,

   521             PlatformLogger logger,

   522             TestLoggerFinder.LoggerImpl sink) {

   523 

   524         System.out.println("Testing " + loggerDescMap.get(logger));

   525 

   526         Foo foo = new Foo();

   527         String fooMsg = foo.toString();

   528         System.out.println("\tlogger.<level>(fooMsg)");

   529         for (Level loggerLevel : Level.values()) {

   530             sink.level = loggerLevel;

   531             for (PlatformLogger.Level messageLevel :julLevels) {

   532                 Level expectedMessageLevel = julToSpiMap.get(messageLevel);

   533                 TestLoggerFinder.LogEvent expected =

   534                         TestLoggerFinder.LogEvent.of(

   535                             sequencer.get(),

   536                             loggerLevel != Level.OFF && expectedMessageLevel.compareTo(loggerLevel) >= 0,

   537                             name, expectedMessageLevel, loggerBundle,

   538                             fooMsg, null, (Throwable)null, (Object[])null);

   539                 String desc2 = "logger." + messageLevel.toString().toLowerCase()

   540                         + "(fooMsg): loggerLevel="

   541                         + loggerLevel+", messageLevel="+messageLevel;

   542                 if (messageLevel == PlatformLogger.Level.FINEST) {

   543                     logger.finest(fooMsg);

   544                     checkLogEvent(provider, desc2, expected);

   545                 } else if (messageLevel == PlatformLogger.Level.FINER) {

   546                     logger.finer(fooMsg);

   547                     checkLogEvent(provider, desc2, expected);

   548                 } else if (messageLevel == PlatformLogger.Level.FINE) {

   549                     logger.fine(fooMsg);

   550                     checkLogEvent(provider, desc2, expected);

   551                 } else if (messageLevel == PlatformLogger.Level.CONFIG) {

   552                     logger.config(fooMsg);

   553                     checkLogEvent(provider, desc2, expected);

   554                 } else if (messageLevel == PlatformLogger.Level.INFO) {

   555                     logger.info(fooMsg);

   556                     checkLogEvent(provider, desc2, expected);

   557                 } else if (messageLevel == PlatformLogger.Level.WARNING) {

   558                     logger.warning(fooMsg);

   559                     checkLogEvent(provider, desc2, expected);

   560                 } else if (messageLevel == PlatformLogger.Level.SEVERE) {

   561                     logger.severe(fooMsg);

   562                     checkLogEvent(provider, desc2, expected);

   563                 }

   564             }

   565         }

   566 

   567         Throwable thrown = new Exception("OK: log me!");

   568         System.out.println("\tlogger.<level>(msg, thrown)");

   569         for (Level loggerLevel : Level.values()) {

   570             sink.level = loggerLevel;

   571             for (PlatformLogger.Level messageLevel :julLevels) {

   572                 Level expectedMessageLevel = julToSpiMap.get(messageLevel);

   573                 TestLoggerFinder.LogEvent expected =

   574                         TestLoggerFinder.LogEvent.of(

   575                             sequencer.get(),

   576                             loggerLevel != Level.OFF && expectedMessageLevel.compareTo(loggerLevel) >= 0,

   577                             name, expectedMessageLevel, (ResourceBundle) null,

   578                             fooMsg, null, (Throwable)thrown, (Object[])null);

   579                 String desc2 = "logger." + messageLevel.toString().toLowerCase()

   580                         + "(msg, thrown): loggerLevel="

   581                         + loggerLevel+", messageLevel="+messageLevel;

   582                 if (messageLevel == PlatformLogger.Level.FINEST) {

   583                     logger.finest(fooMsg, thrown);

   584                     checkLogEvent(provider, desc2, expected);

   585                 } else if (messageLevel == PlatformLogger.Level.FINER) {

   586                     logger.finer(fooMsg, thrown);

   587                     checkLogEvent(provider, desc2, expected);

   588                 } else if (messageLevel == PlatformLogger.Level.FINE) {

   589                     logger.fine(fooMsg, thrown);

   590                     checkLogEvent(provider, desc2, expected);

   591                 } else if (messageLevel == PlatformLogger.Level.CONFIG) {

   592                     logger.config(fooMsg, thrown);

   593                     checkLogEvent(provider, desc2, expected);

   594                 } else if (messageLevel == PlatformLogger.Level.INFO) {

   595                     logger.info(fooMsg, thrown);

   596                     checkLogEvent(provider, desc2, expected);

   597                 } else if (messageLevel == PlatformLogger.Level.WARNING) {

   598                     logger.warning(fooMsg, thrown);

   599                     checkLogEvent(provider, desc2, expected);

   600                 } else if (messageLevel == PlatformLogger.Level.SEVERE) {

   601                     logger.severe(fooMsg, thrown);

   602                     checkLogEvent(provider, desc2, expected);

   603                 }

   604             }

   605         }

   606 

   607         String format = "two params [{1} {2}]";

   608         Object arg1 = foo;

   609         Object arg2 = fooMsg;

   610         System.out.println("\tlogger.<level>(format, arg1, arg2)");

   611         for (Level loggerLevel : Level.values()) {

   612             sink.level = loggerLevel;

   613             for (PlatformLogger.Level messageLevel :julLevels) {

   614                 Level expectedMessageLevel = julToSpiMap.get(messageLevel);

   615                 TestLoggerFinder.LogEvent expected =

   616                         TestLoggerFinder.LogEvent.of(

   617                             sequencer.get(),

   618                             loggerLevel != Level.OFF && expectedMessageLevel.compareTo(loggerLevel) >= 0,

   619                             name, expectedMessageLevel, (ResourceBundle) null,

   620                             format, null, (Throwable)null, foo, fooMsg);

   621                 String desc2 = "logger." + messageLevel.toString().toLowerCase()

   622                         + "(format, foo, fooMsg): loggerLevel="

   623                         + loggerLevel+", messageLevel="+messageLevel;

   624                 if (messageLevel == PlatformLogger.Level.FINEST) {

   625                     logger.finest(format, foo, fooMsg);

   626                     checkLogEvent(provider, desc2, expected);

   627                 } else if (messageLevel == PlatformLogger.Level.FINER) {

   628                     logger.finer(format, foo, fooMsg);

   629                     checkLogEvent(provider, desc2, expected);

   630                 } else if (messageLevel == PlatformLogger.Level.FINE) {

   631                     logger.fine(format, foo, fooMsg);

   632                     checkLogEvent(provider, desc2, expected);

   633                 } else if (messageLevel == PlatformLogger.Level.CONFIG) {

   634                     logger.config(format, foo, fooMsg);

   635                     checkLogEvent(provider, desc2, expected);

   636                 } else if (messageLevel == PlatformLogger.Level.INFO) {

   637                     logger.info(format, foo, fooMsg);

   638                     checkLogEvent(provider, desc2, expected);

   639                 } else if (messageLevel == PlatformLogger.Level.WARNING) {

   640                     logger.warning(format, foo, fooMsg);

   641                     checkLogEvent(provider, desc2, expected);

   642                 } else if (messageLevel == PlatformLogger.Level.SEVERE) {

   643                     logger.severe(format, foo, fooMsg);

   644                     checkLogEvent(provider, desc2, expected);

   645                 }

   646             }

   647         }

   648 

   649     }

   650 

   651     final static class PermissionsBuilder {

   652         final Permissions perms;

   653         public PermissionsBuilder() {

   654             this(new Permissions());

   655         }

   656         public PermissionsBuilder(Permissions perms) {

   657             this.perms = perms;

   658         }

   659         public PermissionsBuilder add(Permission p) {

   660             perms.add(p);

   661             return this;

   662         }

   663         public PermissionsBuilder addAll(PermissionCollection col) {

   664             if (col != null) {

   665                 for (Enumeration<Permission> e = col.elements(); e.hasMoreElements(); ) {

   666                     perms.add(e.nextElement());

   667                 }

   668             }

   669             return this;

   670         }

   671         public Permissions toPermissions() {

   672             final PermissionsBuilder builder = new PermissionsBuilder();

   673             builder.addAll(perms);

   674             return builder.perms;

   675         }

   676     }

   677 

   678     public static class SimplePolicy extends Policy {

   679         final static RuntimePermission CONTROL = LOGGERFINDER_PERMISSION;

   680         final static RuntimePermission ACCESS_LOGGING = new RuntimePermission("accessClassInPackage.sun.util.logging");

   681 

   682         final Permissions permissions;

   683         final Permissions allPermissions;

   684         final ThreadLocal<AtomicBoolean> allowControl;

   685         final ThreadLocal<AtomicBoolean> allowAccess;

   686         final ThreadLocal<AtomicBoolean> allowAll;

   687         public SimplePolicy(ThreadLocal<AtomicBoolean> allowControl,

   688                 ThreadLocal<AtomicBoolean> allowAccess,

   689                 ThreadLocal<AtomicBoolean> allowAll) {

   690             this.allowControl = allowControl;

   691             this.allowAccess = allowAccess;

   692             this.allowAll = allowAll;

   693             permissions = new Permissions();

   694             allPermissions = new PermissionsBuilder()

   695                     .add(new java.security.AllPermission())

   696                     .toPermissions();

   697         }

   698 

   699         Permissions getPermissions() {

   700             if (allowControl.get().get() || allowAccess.get().get() || allowAll.get().get()) {

   701                 PermissionsBuilder builder =  new PermissionsBuilder()

   702                         .addAll(permissions);

   703                 if (allowControl.get().get()) {

   704                     builder.add(CONTROL);

   705                 }

   706                 if (allowAccess.get().get()) {

   707                     builder.add(ACCESS_LOGGING);

   708                 }

   709                 if (allowAll.get().get()) {

   710                     builder.addAll(allPermissions);

   711                 }

   712                 return builder.toPermissions();

   713             }

   714             return permissions;

   715         }

   716 

   717         @Override

   718         public boolean implies(ProtectionDomain domain, Permission permission) {

   719             return getPermissions().implies(permission);

   720         }

   721 

   722         @Override

   723         public PermissionCollection getPermissions(CodeSource codesource) {

   724             return new PermissionsBuilder().addAll(getPermissions()).toPermissions();

   725         }

   726 

   727         @Override

   728         public PermissionCollection getPermissions(ProtectionDomain domain) {

   729             return new PermissionsBuilder().addAll(getPermissions()).toPermissions();

   730         }

   731     }

   732 }