1 /*
   2  * Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25  * @test
  26  * @bug     6882376 6985460 8010309 8011638
  27  * @summary Test if java.util.logging.Logger is created before and after
  28  *          logging is enabled.  Also validate some basic PlatformLogger
  29  *          operations.  othervm mode to make sure java.util.logging
  30  *          is not initialized.
  31  *
  32  * @modules java.base/sun.util.logging
  33  * @compile -XDignore.symbol.file PlatformLoggerTest.java
  34  * @run main/othervm PlatformLoggerTest
  35  */
  36 
  37 import java.lang.reflect.Field;
  38 import java.lang.reflect.Modifier;
  39 import java.util.logging.*;
  40 import sun.util.logging.PlatformLogger;
  41 import static sun.util.logging.PlatformLogger.Level.*;
  42 
  43 public class PlatformLoggerTest {
  44     public static void main(String[] args) throws Exception {
  45         final String FOO_PLATFORM_LOGGER = "test.platformlogger.foo";
  46         final String BAR_PLATFORM_LOGGER = "test.platformlogger.bar";
  47         final String GOO_PLATFORM_LOGGER = "test.platformlogger.goo";
  48         final String BAR_LOGGER = "test.logger.bar";
  49         PlatformLogger goo = PlatformLogger.getLogger(GOO_PLATFORM_LOGGER);
  50         // test the PlatformLogger methods
  51         testLogMethods(goo);
  52 
  53         // Create a platform logger using the default
  54         PlatformLogger foo = PlatformLogger.getLogger(FOO_PLATFORM_LOGGER);
  55         checkPlatformLogger(foo, FOO_PLATFORM_LOGGER);
  56 
  57         // create a java.util.logging.Logger
  58         // now java.util.logging.Logger should be created for each platform logger
  59         Logger logger = Logger.getLogger(BAR_LOGGER);
  60         logger.setLevel(Level.WARNING);
  61 
  62         PlatformLogger bar = PlatformLogger.getLogger(BAR_PLATFORM_LOGGER);
  63         checkPlatformLogger(bar, BAR_PLATFORM_LOGGER);
  64 
  65         // test the PlatformLogger methods
  66         testLogMethods(goo);
  67         testLogMethods(bar);
  68 
  69         checkLogger(FOO_PLATFORM_LOGGER, Level.FINER);
  70         checkLogger(BAR_PLATFORM_LOGGER, Level.FINER);
  71 
  72         checkLogger(GOO_PLATFORM_LOGGER, null);
  73         checkLogger(BAR_LOGGER, Level.WARNING);
  74 
  75         foo.setLevel(PlatformLogger.Level.SEVERE);
  76         checkLogger(FOO_PLATFORM_LOGGER, Level.SEVERE);
  77 
  78         checkPlatformLoggerLevels(foo, bar);
  79     }
  80 
  81     // don't use java.util.logging here to prevent it from initialized
  82     private static void checkPlatformLogger(PlatformLogger logger, String name) {
  83         if (!logger.getName().equals(name)) {
  84             throw new RuntimeException("Invalid logger's name " +
  85                 logger.getName() + " but expected " + name);
  86         }
  87 
  88         if (logger.level() != null) {
  89             throw new RuntimeException("Invalid default level for logger " +
  90                 logger.getName() + ": " + logger.level());
  91         }
  92 
  93         checkLoggable(logger, FINE, false);
  94 
  95         logger.setLevel(FINER);
  96         checkLevel(logger, FINER);
  97         checkLoggable(logger, FINER, true);
  98         checkLoggable(logger, FINE, true);
  99         checkLoggable(logger, FINEST, false);
 100 
 101         logger.info("OK: Testing log message");
 102     }
 103 
 104     private static void checkLoggable(PlatformLogger logger, PlatformLogger.Level level, boolean expected) {
 105         if (logger.isLoggable(level) != expected) {
 106             throw new RuntimeException("logger " + logger.getName() + ": " + level +
 107                 (expected ? " not loggable" : " loggable"));
 108         }
 109     }
 110 
 111     private static void checkLevel(PlatformLogger logger, PlatformLogger.Level level) {
 112         if (logger.level() != level) {
 113             throw new RuntimeException("Invalid level for logger " +
 114                 logger.getName() + ": " + logger.level() + " != " + level);
 115         }
 116     }
 117 
 118     private static void checkLogger(String name, Level level) {
 119         Logger logger = LogManager.getLogManager().getLogger(name);
 120         if (logger == null) {
 121             throw new RuntimeException("Logger " + name +
 122                 " does not exist");
 123         }
 124 
 125         if (logger.getLevel() != level) {
 126             throw new RuntimeException("Invalid level for logger " +
 127                 logger.getName() + " " + logger.getLevel());
 128         }
 129     }
 130 
 131     private static void testLogMethods(PlatformLogger logger) {
 132         logger.severe("Test severe(String, Object...) {0} {1}", new Long(1), "string");
 133         // test Object[]
 134         logger.severe("Test severe(String, Object...) {0}", (Object[]) getPoints());
 135         logger.warning("Test warning(String, Throwable)", new Throwable("Testing"));
 136         logger.info("Test info(String)");
 137     }
 138 
 139     private static void checkPlatformLoggerLevels(PlatformLogger... loggers) {
 140         final Level[] levels = new Level[] {
 141             Level.ALL, Level.CONFIG, Level.FINE, Level.FINER, Level.FINEST,
 142             Level.INFO, Level.OFF, Level.SEVERE, Level.WARNING
 143         };
 144 
 145         int count = PlatformLogger.Level.values().length;
 146         if (levels.length != count) {
 147             throw new RuntimeException("There are " + count +
 148                     " PlatformLogger.Level members, but " + levels.length +
 149                     " standard java.util.logging levels - the numbers should be equal.");
 150         }
 151         // check mappings
 152         for (Level level : levels) {
 153             checkPlatformLoggerLevelMapping(level);
 154         }
 155 
 156         for (Level level : levels) {
 157             PlatformLogger.Level platformLevel = PlatformLogger.Level.valueOf(level.getName());
 158             for (PlatformLogger logger : loggers) {
 159                 logger.setLevel(platformLevel);       // setLevel(PlatformLogger.Level)
 160                 checkLoggerLevel(logger, level);
 161 
 162                 logger.setLevel(ALL);  // setLevel(int)
 163                 checkLoggerLevel(logger, Level.ALL);
 164             }
 165         }
 166 
 167         Logger javaLogger = Logger.getLogger("foo.bar.baz");
 168         for (Level level : levels) {
 169             checkJavaLoggerLevel(javaLogger, level);
 170         }
 171     }
 172 
 173     private static void checkLoggerLevel(PlatformLogger logger, Level level) {
 174         PlatformLogger.Level plevel = PlatformLogger.Level.valueOf(level.getName());
 175         if (plevel != logger.level()) {
 176             throw new RuntimeException("Retrieved PlatformLogger level "
 177                     + logger.level()
 178                     + " is not the same as set level " + plevel);
 179         }
 180 
 181         // check the level set in java.util.logging.Logger
 182         Logger javaLogger = LogManager.getLogManager().getLogger(logger.getName());
 183         Level javaLevel = javaLogger.getLevel();
 184         if (javaLogger.getLevel() != level) {
 185             throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
 186                     + javaLevel + " is not the expected " + level);
 187         }
 188     }
 189 
 190     private static void checkJavaLoggerLevel(Logger logger, Level level) {
 191         // This method exercise the mapping of java level to platform level
 192         // when the java level is not one of the standard levels...
 193 
 194         System.out.println("Testing Java Level with: " + level.getName());
 195 
 196         // create a brand new java logger
 197         Logger javaLogger = LogManager.demandLoggerFor(
 198                 logger.getName()+"."+level.getName(), Thread.class);
 199 
 200         // Set a non standard java.util.logging.Level on the java logger
 201         // (except for OFF & ALL - which will remain unchanged)
 202         int intValue = level.intValue();
 203         if (level != Level.ALL && level != Level.OFF) {
 204             intValue -= 7;
 205         }
 206         javaLogger.setLevel(Level.parse(String.valueOf(intValue)));
 207 
 208         // check the level set in java.util.logging.Logger
 209         Level effectiveLevel = javaLogger.getLevel();
 210         System.out.println("Effective Java Level used is: " + effectiveLevel);
 211 
 212         if (effectiveLevel.intValue() != intValue) {
 213             throw new RuntimeException("Retrieved backing java.util.logging.Logger level.intValue() "
 214                     + effectiveLevel.intValue() + " is not the expected " + intValue);
 215         }
 216         if (intValue != level.intValue() && javaLogger.getLevel() == level) {
 217             throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
 218                     + effectiveLevel + " is " + level);
 219         }
 220         if (intValue == level.intValue() && javaLogger.getLevel() != level) {
 221             throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
 222                     + effectiveLevel + " is not " + level);
 223         }
 224 
 225         // check the level set in the PlatformLogger
 226         PlatformLogger plogger = PlatformLogger.getLogger(javaLogger.getName());
 227         PlatformLogger.Level expected = PlatformLogger.Level.valueOf(level.getName());
 228         if (plogger.level() != expected) {
 229             throw new RuntimeException("Retrieved backing PlatformLogger level "
 230                     + plogger.level() + " is not the expected " + expected);
 231 
 232         }
 233     }
 234 
 235     private static void checkPlatformLoggerLevelMapping(Level level) {
 236         // map the given level to PlatformLogger.Level of the same name and value
 237         PlatformLogger.Level platformLevel = PlatformLogger.Level.valueOf(level.getName());
 238         if (platformLevel.intValue() != level.intValue()) {
 239             throw new RuntimeException("Mismatched level: " + level
 240                     + " PlatformLogger.Level" + platformLevel);
 241         }
 242         if (!platformLevel.name().equals(level.getName())) {
 243             throw new RuntimeException("The value of PlatformLogger." + level.getName() + ".name() is "
 244                                        + platformLevel.name() + " but expected " + level.getName());
 245         }
 246     }
 247 
 248     static Point[] getPoints() {
 249         Point[] res = new Point[3];
 250         res[0] = new Point(0,0);
 251         res[1] = new Point(1,1);
 252         res[2] = new Point(2,2);
 253         return res;
 254     }
 255 
 256     static class Point {
 257         final int x;
 258         final int y;
 259         public Point(int x, int y) {
 260             this.x = x;
 261             this.y = y;
 262         }
 263         public String toString() {
 264             return "{x="+x + ", y=" + y + "}";
 265         }
 266     }
 267 
 268 }