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  *          java.logging/sun.util.logging.internal
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 
45     static Logger logger;
46     static PlatformLogger bar;
47     static PlatformLogger goo;
48     static PlatformLogger foo;
49 
main(String[] args)50     public static void main(String[] args) throws Exception {
51         final String FOO_PLATFORM_LOGGER = "test.platformlogger.foo";
52         final String BAR_PLATFORM_LOGGER = "test.platformlogger.bar";
53         final String GOO_PLATFORM_LOGGER = "test.platformlogger.goo";
54         final String BAR_LOGGER = "test.logger.bar";
55         goo = PlatformLogger.getLogger(GOO_PLATFORM_LOGGER);
56         // test the PlatformLogger methods
57         testLogMethods(goo);
58 
59         // Create a platform logger using the default
60         foo = PlatformLogger.getLogger(FOO_PLATFORM_LOGGER);
61         checkPlatformLogger(foo, FOO_PLATFORM_LOGGER);
62 
63         // create a java.util.logging.Logger
64         // now java.util.logging.Logger should be created for each platform logger
65         logger = Logger.getLogger(BAR_LOGGER);
66         logger.setLevel(Level.WARNING);
67 
68         bar = PlatformLogger.getLogger(BAR_PLATFORM_LOGGER);
69         checkPlatformLogger(bar, BAR_PLATFORM_LOGGER);
70 
71         // test the PlatformLogger methods
72         testLogMethods(goo);
73         testLogMethods(bar);
74 
75         checkLogger(FOO_PLATFORM_LOGGER, Level.FINER);
76         checkLogger(BAR_PLATFORM_LOGGER, Level.FINER);
77 
78         checkLogger(GOO_PLATFORM_LOGGER, null);
79         checkLogger(BAR_LOGGER, Level.WARNING);
80 
81         foo.setLevel(PlatformLogger.Level.SEVERE);
82         checkLogger(FOO_PLATFORM_LOGGER, Level.SEVERE);
83 
84         checkPlatformLoggerLevels(foo, bar);
85     }
86 
87     // don't use java.util.logging here to prevent it from initialized
checkPlatformLogger(PlatformLogger logger, String name)88     private static void checkPlatformLogger(PlatformLogger logger, String name) {
89         if (!logger.getName().equals(name)) {
90             throw new RuntimeException("Invalid logger's name " +
91                 logger.getName() + " but expected " + name);
92         }
93 
94         if (logger.level() != null) {
95             throw new RuntimeException("Invalid default level for logger " +
96                 logger.getName() + ": " + logger.level());
97         }
98 
99         checkLoggable(logger, FINE, false);
100 
101         logger.setLevel(FINER);
102         checkLevel(logger, FINER);
103         checkLoggable(logger, FINER, true);
104         checkLoggable(logger, FINE, true);
105         checkLoggable(logger, FINEST, false);
106 
107         logger.info("OK: Testing log message");
108     }
109 
checkLoggable(PlatformLogger logger, PlatformLogger.Level level, boolean expected)110     private static void checkLoggable(PlatformLogger logger, PlatformLogger.Level level, boolean expected) {
111         if (logger.isLoggable(level) != expected) {
112             throw new RuntimeException("logger " + logger.getName() + ": " + level +
113                 (expected ? " not loggable" : " loggable"));
114         }
115     }
116 
checkLevel(PlatformLogger logger, PlatformLogger.Level level)117     private static void checkLevel(PlatformLogger logger, PlatformLogger.Level level) {
118         if (logger.level() != level) {
119             throw new RuntimeException("Invalid level for logger " +
120                 logger.getName() + ": " + logger.level() + " != " + level);
121         }
122     }
123 
checkLogger(String name, Level level)124     private static void checkLogger(String name, Level level) {
125         Logger logger = LogManager.getLogManager().getLogger(name);
126         if (logger == null) {
127             throw new RuntimeException("Logger " + name +
128                 " does not exist");
129         }
130 
131         if (logger.getLevel() != level) {
132             throw new RuntimeException("Invalid level for logger " +
133                 logger.getName() + " " + logger.getLevel());
134         }
135     }
136 
testLogMethods(PlatformLogger logger)137     private static void testLogMethods(PlatformLogger logger) {
138         logger.severe("Test severe(String, Object...) {0} {1}", new Long(1), "string");
139         // test Object[]
140         logger.severe("Test severe(String, Object...) {0}", (Object[]) getPoints());
141         logger.warning("Test warning(String, Throwable)", new Throwable("Testing"));
142         logger.info("Test info(String)");
143     }
144 
checkPlatformLoggerLevels(PlatformLogger... loggers)145     private static void checkPlatformLoggerLevels(PlatformLogger... loggers) {
146         final Level[] levels = new Level[] {
147             Level.ALL, Level.CONFIG, Level.FINE, Level.FINER, Level.FINEST,
148             Level.INFO, Level.OFF, Level.SEVERE, Level.WARNING
149         };
150 
151         int count = PlatformLogger.Level.values().length;
152         if (levels.length != count) {
153             throw new RuntimeException("There are " + count +
154                     " PlatformLogger.Level members, but " + levels.length +
155                     " standard java.util.logging levels - the numbers should be equal.");
156         }
157         // check mappings
158         for (Level level : levels) {
159             checkPlatformLoggerLevelMapping(level);
160         }
161 
162         for (Level level : levels) {
163             PlatformLogger.Level platformLevel = PlatformLogger.Level.valueOf(level.getName());
164             for (PlatformLogger logger : loggers) {
165                 logger.setLevel(platformLevel);       // setLevel(PlatformLogger.Level)
166                 checkLoggerLevel(logger, level);
167 
168                 logger.setLevel(ALL);  // setLevel(int)
169                 checkLoggerLevel(logger, Level.ALL);
170             }
171         }
172 
173         Logger javaLogger = Logger.getLogger("foo.bar.baz");
174         for (Level level : levels) {
175             checkJavaLoggerLevel(javaLogger, level);
176         }
177     }
178 
checkLoggerLevel(PlatformLogger logger, Level level)179     private static void checkLoggerLevel(PlatformLogger logger, Level level) {
180         PlatformLogger.Level plevel = PlatformLogger.Level.valueOf(level.getName());
181         if (plevel != logger.level()) {
182             throw new RuntimeException("Retrieved PlatformLogger level "
183                     + logger.level()
184                     + " is not the same as set level " + plevel);
185         }
186 
187         // check the level set in java.util.logging.Logger
188         Logger javaLogger = LogManager.getLogManager().getLogger(logger.getName());
189         Level javaLevel = javaLogger.getLevel();
190         if (javaLogger.getLevel() != level) {
191             throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
192                     + javaLevel + " is not the expected " + level);
193         }
194     }
195 
checkJavaLoggerLevel(Logger logger, Level level)196     private static void checkJavaLoggerLevel(Logger logger, Level level) {
197         // This method exercise the mapping of java level to platform level
198         // when the java level is not one of the standard levels...
199 
200         System.out.println("Testing Java Level with: " + level.getName());
201 
202         // create a brand new java logger
203         Logger javaLogger = sun.util.logging.internal.LoggingProviderImpl.getLogManagerAccess()
204                      .demandLoggerFor(LogManager.getLogManager(),
205                           logger.getName()+"."+level.getName(), Thread.class.getModule());
206 
207         // Set a non standard java.util.logging.Level on the java logger
208         // (except for OFF & ALL - which will remain unchanged)
209         int intValue = level.intValue();
210         if (level != Level.ALL && level != Level.OFF) {
211             intValue -= 7;
212         }
213         javaLogger.setLevel(Level.parse(String.valueOf(intValue)));
214 
215         // check the level set in java.util.logging.Logger
216         Level effectiveLevel = javaLogger.getLevel();
217         System.out.println("Effective Java Level used is: " + effectiveLevel);
218 
219         if (effectiveLevel.intValue() != intValue) {
220             throw new RuntimeException("Retrieved backing java.util.logging.Logger level.intValue() "
221                     + effectiveLevel.intValue() + " is not the expected " + intValue);
222         }
223         if (intValue != level.intValue() && javaLogger.getLevel() == level) {
224             throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
225                     + effectiveLevel + " is " + level);
226         }
227         if (intValue == level.intValue() && javaLogger.getLevel() != level) {
228             throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
229                     + effectiveLevel + " is not " + level);
230         }
231 
232         // check the level set in the PlatformLogger
233         PlatformLogger plogger = PlatformLogger.getLogger(javaLogger.getName());
234         PlatformLogger.Level expected = PlatformLogger.Level.valueOf(level.getName());
235         if (plogger.level() != expected) {
236             throw new RuntimeException("Retrieved backing PlatformLogger level "
237                     + plogger.level() + " is not the expected " + expected);
238 
239         }
240     }
241 
checkPlatformLoggerLevelMapping(Level level)242     private static void checkPlatformLoggerLevelMapping(Level level) {
243         // map the given level to PlatformLogger.Level of the same name and value
244         PlatformLogger.Level platformLevel = PlatformLogger.Level.valueOf(level.getName());
245         if (platformLevel.intValue() != level.intValue()) {
246             throw new RuntimeException("Mismatched level: " + level
247                     + " PlatformLogger.Level" + platformLevel);
248         }
249         if (!platformLevel.name().equals(level.getName())) {
250             throw new RuntimeException("The value of PlatformLogger." + level.getName() + ".name() is "
251                                        + platformLevel.name() + " but expected " + level.getName());
252         }
253     }
254 
getPoints()255     static Point[] getPoints() {
256         Point[] res = new Point[3];
257         res[0] = new Point(0,0);
258         res[1] = new Point(1,1);
259         res[2] = new Point(2,2);
260         return res;
261     }
262 
263     static class Point {
264         final int x;
265         final int y;
Point(int x, int y)266         public Point(int x, int y) {
267             this.x = x;
268             this.y = y;
269         }
toString()270         public String toString() {
271             return "{x="+x + ", y=" + y + "}";
272         }
273     }
274 
275 }
276