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 sun.util.logging.LoggingSupport;
42 import static sun.util.logging.PlatformLogger.Level.*;
43
44 public class PlatformLoggerTest {
45 public static void main(String[] args) throws Exception {
46 final String FOO_PLATFORM_LOGGER = "test.platformlogger.foo";
47 final String BAR_PLATFORM_LOGGER = "test.platformlogger.bar";
48 final String GOO_PLATFORM_LOGGER = "test.platformlogger.goo";
49 final String BAR_LOGGER = "test.logger.bar";
50 PlatformLogger goo = PlatformLogger.getLogger(GOO_PLATFORM_LOGGER);
51 // test the PlatformLogger methods
52 testLogMethods(goo);
53
54 // Create a platform logger using the default
55 PlatformLogger foo = PlatformLogger.getLogger(FOO_PLATFORM_LOGGER);
56 checkPlatformLogger(foo, FOO_PLATFORM_LOGGER);
57
58 // create a java.util.logging.Logger
59 // now java.util.logging.Logger should be created for each platform logger
60 Logger logger = Logger.getLogger(BAR_LOGGER);
61 logger.setLevel(Level.WARNING);
62
63 PlatformLogger bar = PlatformLogger.getLogger(BAR_PLATFORM_LOGGER);
64 checkPlatformLogger(bar, BAR_PLATFORM_LOGGER);
65
66 // test the PlatformLogger methods
67 testLogMethods(goo);
68 testLogMethods(bar);
69
70 checkLogger(FOO_PLATFORM_LOGGER, Level.FINER);
71 checkLogger(BAR_PLATFORM_LOGGER, Level.FINER);
72
73 checkLogger(GOO_PLATFORM_LOGGER, null);
74 checkLogger(BAR_LOGGER, Level.WARNING);
75
76 foo.setLevel(PlatformLogger.Level.SEVERE);
77 checkLogger(FOO_PLATFORM_LOGGER, Level.SEVERE);
78
79 checkPlatformLoggerLevels(foo, bar);
80 }
81
82 // don't use java.util.logging here to prevent it from initialized
83 private static void checkPlatformLogger(PlatformLogger logger, String name) {
84 if (!logger.getName().equals(name)) {
85 throw new RuntimeException("Invalid logger's name " +
86 logger.getName() + " but expected " + name);
87 }
88
89 if (logger.level() != null) {
90 throw new RuntimeException("Invalid default level for logger " +
91 logger.getName() + ": " + logger.level());
92 }
93
94 checkLoggable(logger, FINE, false);
95
96 logger.setLevel(FINER);
97 checkLevel(logger, FINER);
98 checkLoggable(logger, FINER, true);
99 checkLoggable(logger, FINE, true);
100 checkLoggable(logger, FINEST, false);
101
102 logger.info("OK: Testing log message");
103 }
104
105 private static void checkLoggable(PlatformLogger logger, PlatformLogger.Level level, boolean expected) {
106 if (logger.isLoggable(level) != expected) {
107 throw new RuntimeException("logger " + logger.getName() + ": " + level +
108 (expected ? " not loggable" : " loggable"));
109 }
110 }
111
112 private static void checkLevel(PlatformLogger logger, PlatformLogger.Level level) {
113 if (logger.level() != level) {
114 throw new RuntimeException("Invalid level for logger " +
115 logger.getName() + ": " + logger.level() + " != " + level);
116 }
117 }
118
119 private static void checkLogger(String name, Level level) {
120 Logger logger = LogManager.getLogManager().getLogger(name);
121 if (logger == null) {
122 throw new RuntimeException("Logger " + name +
123 " does not exist");
124 }
125
126 if (logger.getLevel() != level) {
127 throw new RuntimeException("Invalid level for logger " +
128 logger.getName() + " " + logger.getLevel());
129 }
130 }
131
132 private static void testLogMethods(PlatformLogger logger) {
133 logger.severe("Test severe(String, Object...) {0} {1}", new Long(1), "string");
134 // test Object[]
135 logger.severe("Test severe(String, Object...) {0}", (Object[]) getPoints());
136 logger.warning("Test warning(String, Throwable)", new Throwable("Testing"));
137 logger.info("Test info(String)");
138 }
139
140 private static void checkPlatformLoggerLevels(PlatformLogger... loggers) {
141 final Level[] levels = new Level[] {
142 Level.ALL, Level.CONFIG, Level.FINE, Level.FINER, Level.FINEST,
143 Level.INFO, Level.OFF, Level.SEVERE, Level.WARNING
144 };
145
146 int count = PlatformLogger.Level.values().length;
147 if (levels.length != count) {
148 throw new RuntimeException("There are " + count +
149 " PlatformLogger.Level members, but " + levels.length +
150 " standard java.util.logging levels - the numbers should be equal.");
151 }
152 // check mappings
153 for (Level level : levels) {
154 checkPlatformLoggerLevelMapping(level);
155 }
156
157 for (Level level : levels) {
158 PlatformLogger.Level platformLevel = PlatformLogger.Level.valueOf(level.getName());
159 for (PlatformLogger logger : loggers) {
160 logger.setLevel(platformLevel); // setLevel(PlatformLogger.Level)
161 checkLoggerLevel(logger, level);
162
163 logger.setLevel(ALL); // setLevel(int)
164 checkLoggerLevel(logger, Level.ALL);
165 }
166 }
167
168 Logger javaLogger = Logger.getLogger("foo.bar.baz");
169 for (Level level : levels) {
170 checkJavaLoggerLevel(javaLogger, level);
171 }
172 }
173
174 private static void checkLoggerLevel(PlatformLogger logger, Level level) {
175 PlatformLogger.Level plevel = PlatformLogger.Level.valueOf(level.getName());
176 if (plevel != logger.level()) {
177 throw new RuntimeException("Retrieved PlatformLogger level "
178 + logger.level()
179 + " is not the same as set level " + plevel);
180 }
181
182 // check the level set in java.util.logging.Logger
183 Logger javaLogger = LogManager.getLogManager().getLogger(logger.getName());
184 Level javaLevel = javaLogger.getLevel();
185 if (javaLogger.getLevel() != level) {
186 throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
187 + javaLevel + " is not the expected " + level);
188 }
189 }
190
191 private static void checkJavaLoggerLevel(Logger logger, Level level) {
192 // This method exercise the mapping of java level to platform level
193 // when the java level is not one of the standard levels...
194
195 System.out.println("Testing Java Level with: " + level.getName());
196
197 // create a brand new java logger
198 Logger javaLogger = (Logger) LoggingSupport.getLogger(logger.getName()+"."+level.getName());
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 }