1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.log4j;
19
20 import junit.framework.TestCase;
21 import org.apache.log4j.spi.LoggingEvent;
22 import org.apache.log4j.spi.RootLogger;
23 import org.apache.log4j.spi.LoggerRepository;
24 import org.apache.log4j.spi.HierarchyEventListener;
25
26 import java.util.Enumeration;
27 import java.util.Locale;
28 import java.util.ResourceBundle;
29 import java.util.Vector;
30
31 /***
32 Used for internal unit testing the Logger class.
33
34 @author Ceki Gülcü
35
36 */
37 public class LoggerTestCase extends TestCase {
38
39 Logger logger;
40 Appender a1;
41 Appender a2;
42
43 ResourceBundle rbUS;
44 ResourceBundle rbFR;
45 ResourceBundle rbCH;
46
47
48 static String MSG = "M";
49
50
51 public LoggerTestCase(String name) {
52 super(name);
53 }
54
55 public
56 void setUp() {
57 rbUS = ResourceBundle.getBundle("L7D", new Locale("en", "US"));
58 assertNotNull(rbUS);
59
60 rbFR = ResourceBundle.getBundle("L7D", new Locale("fr", "FR"));
61 assertNotNull("Got a null resource bundle.", rbFR);
62
63 rbCH = ResourceBundle.getBundle("L7D", new Locale("fr", "CH"));
64 assertNotNull("Got a null resource bundle.", rbCH);
65
66 }
67
68 public
69 void tearDown() {
70
71
72 BasicConfigurator.resetConfiguration();
73 a1 = null;
74 a2 = null;
75 }
76
77 /***
78 Add an appender and see if it can be retrieved.
79 */
80 public
81 void testAppender1() {
82 logger = Logger.getLogger("test");
83 a1 = new FileAppender();
84 a1.setName("testAppender1");
85 logger.addAppender(a1);
86
87 Enumeration enumeration = logger.getAllAppenders();
88 Appender aHat = (Appender) enumeration.nextElement();
89 assertEquals(a1, aHat);
90 }
91
92 /***
93 Add an appender X, Y, remove X and check if Y is the only
94 remaining appender.
95 */
96 public
97 void testAppender2() {
98 a1 = new FileAppender();
99 a1.setName("testAppender2.1");
100 a2 = new FileAppender();
101 a2.setName("testAppender2.2");
102
103 logger = Logger.getLogger("test");
104 logger.addAppender(a1);
105 logger.addAppender(a2);
106 logger.removeAppender("testAppender2.1");
107 Enumeration enumeration = logger.getAllAppenders();
108 Appender aHat = (Appender) enumeration.nextElement();
109 assertEquals(a2, aHat);
110 assertTrue(!enumeration.hasMoreElements());
111 }
112
113 /***
114 Test if logger a.b inherits its appender from a.
115 */
116 public
117 void testAdditivity1() {
118 Logger a = Logger.getLogger("a");
119 Logger ab = Logger.getLogger("a.b");
120 CountingAppender ca = new CountingAppender();
121 a.addAppender(ca);
122
123 assertEquals(ca.counter, 0);
124 ab.debug(MSG); assertEquals(ca.counter, 1);
125 ab.info(MSG); assertEquals(ca.counter, 2);
126 ab.warn(MSG); assertEquals(ca.counter, 3);
127 ab.error(MSG); assertEquals(ca.counter, 4);
128
129
130 }
131
132 /***
133 Test multiple additivity.
134
135 */
136 public
137 void testAdditivity2() {
138
139 Logger a = Logger.getLogger("a");
140 Logger ab = Logger.getLogger("a.b");
141 Logger abc = Logger.getLogger("a.b.c");
142 Logger x = Logger.getLogger("x");
143
144 CountingAppender ca1 = new CountingAppender();
145 CountingAppender ca2 = new CountingAppender();
146
147 a.addAppender(ca1);
148 abc.addAppender(ca2);
149
150 assertEquals(ca1.counter, 0);
151 assertEquals(ca2.counter, 0);
152
153 ab.debug(MSG);
154 assertEquals(ca1.counter, 1);
155 assertEquals(ca2.counter, 0);
156
157 abc.debug(MSG);
158 assertEquals(ca1.counter, 2);
159 assertEquals(ca2.counter, 1);
160
161 x.debug(MSG);
162 assertEquals(ca1.counter, 2);
163 assertEquals(ca2.counter, 1);
164 }
165
166 /***
167 Test additivity flag.
168
169 */
170 public
171 void testAdditivity3() {
172
173 Logger root = Logger.getRootLogger();
174 Logger a = Logger.getLogger("a");
175 Logger ab = Logger.getLogger("a.b");
176 Logger abc = Logger.getLogger("a.b.c");
177 Logger x = Logger.getLogger("x");
178
179 CountingAppender caRoot = new CountingAppender();
180 CountingAppender caA = new CountingAppender();
181 CountingAppender caABC = new CountingAppender();
182
183 root.addAppender(caRoot);
184 a.addAppender(caA);
185 abc.addAppender(caABC);
186
187 assertEquals(caRoot.counter, 0);
188 assertEquals(caA.counter, 0);
189 assertEquals(caABC.counter, 0);
190
191 ab.setAdditivity(false);
192
193
194 a.debug(MSG);
195 assertEquals(caRoot.counter, 1);
196 assertEquals(caA.counter, 1);
197 assertEquals(caABC.counter, 0);
198
199 ab.debug(MSG);
200 assertEquals(caRoot.counter, 1);
201 assertEquals(caA.counter, 1);
202 assertEquals(caABC.counter, 0);
203
204 abc.debug(MSG);
205 assertEquals(caRoot.counter, 1);
206 assertEquals(caA.counter, 1);
207 assertEquals(caABC.counter, 1);
208
209 }
210
211
212 public
213 void testDisable1() {
214 CountingAppender caRoot = new CountingAppender();
215 Logger root = Logger.getRootLogger();
216 root.addAppender(caRoot);
217
218 LoggerRepository h = LogManager.getLoggerRepository();
219
220 h.setThreshold((Level) Level.INFO);
221 assertEquals(caRoot.counter, 0);
222
223 root.debug(MSG); assertEquals(caRoot.counter, 0);
224 root.info(MSG); assertEquals(caRoot.counter, 1);
225 root.log(Level.WARN, MSG); assertEquals(caRoot.counter, 2);
226 root.warn(MSG); assertEquals(caRoot.counter, 3);
227
228
229 h.setThreshold((Level) Level.WARN);
230 root.debug(MSG); assertEquals(caRoot.counter, 3);
231 root.info(MSG); assertEquals(caRoot.counter, 3);
232 root.log(Level.WARN, MSG); assertEquals(caRoot.counter, 4);
233 root.error(MSG); assertEquals(caRoot.counter, 5);
234 root.log(Level.ERROR, MSG); assertEquals(caRoot.counter, 6);
235
236
237 h.setThreshold(Level.OFF);
238 root.debug(MSG); assertEquals(caRoot.counter, 6);
239 root.info(MSG); assertEquals(caRoot.counter, 6);
240 root.log(Level.WARN, MSG); assertEquals(caRoot.counter, 6);
241 root.error(MSG); assertEquals(caRoot.counter, 6);
242 root.log(Level.FATAL, MSG); assertEquals(caRoot.counter, 6);
243 root.log(Level.FATAL, MSG); assertEquals(caRoot.counter, 6);
244
245
246 h.setThreshold(Level.OFF);
247 root.debug(MSG); assertEquals(caRoot.counter, 6);
248 root.info(MSG); assertEquals(caRoot.counter, 6);
249 root.log(Level.WARN, MSG); assertEquals(caRoot.counter, 6);
250 root.error(MSG); assertEquals(caRoot.counter, 6);
251 root.log(Level.ERROR, MSG); assertEquals(caRoot.counter, 6);
252 root.log(Level.FATAL, MSG); assertEquals(caRoot.counter, 6);
253 }
254
255
256 public
257 void testRB1() {
258 Logger root = Logger.getRootLogger();
259 root.setResourceBundle(rbUS);
260 ResourceBundle t = root.getResourceBundle();
261 assertSame(t, rbUS);
262
263 Logger x = Logger.getLogger("x");
264 Logger x_y = Logger.getLogger("x.y");
265 Logger x_y_z = Logger.getLogger("x.y.z");
266
267 t = x.getResourceBundle(); assertSame(t, rbUS);
268 t = x_y.getResourceBundle(); assertSame(t, rbUS);
269 t = x_y_z.getResourceBundle(); assertSame(t, rbUS);
270 }
271
272 public
273 void testRB2() {
274 Logger root = Logger.getRootLogger();
275 root.setResourceBundle(rbUS);
276 ResourceBundle t = root.getResourceBundle();
277 assertSame(t, rbUS);
278
279 Logger x = Logger.getLogger("x");
280 Logger x_y = Logger.getLogger("x.y");
281 Logger x_y_z = Logger.getLogger("x.y.z");
282
283 x_y.setResourceBundle(rbFR);
284 t = x.getResourceBundle(); assertSame(t, rbUS);
285 t = x_y.getResourceBundle(); assertSame(t, rbFR);
286 t = x_y_z.getResourceBundle(); assertSame(t, rbFR);
287 }
288
289
290 public
291 void testRB3() {
292 Logger root = Logger.getRootLogger();
293 root.setResourceBundle(rbUS);
294 ResourceBundle t = root.getResourceBundle();
295 assertSame(t, rbUS);
296
297 Logger x = Logger.getLogger("x");
298 Logger x_y = Logger.getLogger("x.y");
299 Logger x_y_z = Logger.getLogger("x.y.z");
300
301 x_y.setResourceBundle(rbFR);
302 x_y_z.setResourceBundle(rbCH);
303 t = x.getResourceBundle(); assertSame(t, rbUS);
304 t = x_y.getResourceBundle(); assertSame(t, rbFR);
305 t = x_y_z.getResourceBundle(); assertSame(t, rbCH);
306 }
307
308 public
309 void testExists() {
310 Logger a = Logger.getLogger("a");
311 Logger a_b = Logger.getLogger("a.b");
312 Logger a_b_c = Logger.getLogger("a.b.c");
313
314 Logger t;
315 t = LogManager.exists("xx"); assertNull(t);
316 t = LogManager.exists("a"); assertSame(a, t);
317 t = LogManager.exists("a.b"); assertSame(a_b, t);
318 t = LogManager.exists("a.b.c"); assertSame(a_b_c, t);
319 }
320
321 public
322 void testHierarchy1() {
323 Hierarchy h = new Hierarchy(new RootLogger((Level) Level.ERROR));
324 Logger a0 = h.getLogger("a");
325 assertEquals("a", a0.getName());
326 assertNull(a0.getLevel());
327 assertSame(Level.ERROR, a0.getEffectiveLevel());
328
329 Logger a1 = h.getLogger("a");
330 assertSame(a0, a1);
331 }
332
333 /***
334 * Tests logger.trace(Object).
335 * @since 1.2.12
336 */
337 public void testTrace() {
338 VectorAppender appender = new VectorAppender();
339 appender.activateOptions();
340 Logger root = Logger.getRootLogger();
341 root.addAppender(appender);
342 root.setLevel(Level.INFO);
343
344 Logger tracer = Logger.getLogger("com.example.Tracer");
345 tracer.setLevel(Level.TRACE);
346
347 tracer.trace("Message 1");
348 root.trace("Discarded Message");
349 root.trace("Discarded Message");
350
351 Vector msgs = appender.getVector();
352 assertEquals(1, msgs.size());
353 LoggingEvent event = (LoggingEvent) msgs.elementAt(0);
354 assertEquals(Level.TRACE, event.getLevel());
355 assertEquals("Message 1", event.getMessage());
356 }
357
358 /***
359 * Tests logger.trace(Object, Exception).
360 * @since 1.2.12
361 */
362 public void testTraceWithException() {
363 VectorAppender appender = new VectorAppender();
364 appender.activateOptions();
365 Logger root = Logger.getRootLogger();
366 root.addAppender(appender);
367 root.setLevel(Level.INFO);
368
369 Logger tracer = Logger.getLogger("com.example.Tracer");
370 tracer.setLevel(Level.TRACE);
371 NullPointerException ex = new NullPointerException();
372
373 tracer.trace("Message 1", ex);
374 root.trace("Discarded Message", ex);
375 root.trace("Discarded Message", ex);
376
377 Vector msgs = appender.getVector();
378 assertEquals(1, msgs.size());
379 LoggingEvent event = (LoggingEvent) msgs.elementAt(0);
380 assertEquals(Level.TRACE, event.getLevel());
381 assertEquals("Message 1", event.getMessage());
382 }
383
384 /***
385 * Tests isTraceEnabled.
386 * @since 1.2.12
387 */
388 public void testIsTraceEnabled() {
389 VectorAppender appender = new VectorAppender();
390 appender.activateOptions();
391 Logger root = Logger.getRootLogger();
392 root.addAppender(appender);
393 root.setLevel(Level.INFO);
394
395 Logger tracer = Logger.getLogger("com.example.Tracer");
396 tracer.setLevel(Level.TRACE);
397
398 assertTrue(tracer.isTraceEnabled());
399 assertFalse(root.isTraceEnabled());
400 }
401
402 private static final class CountingHierarchyEventListener implements HierarchyEventListener {
403 private int addEventCount;
404 private int removeEventCount;
405
406 public CountingHierarchyEventListener() {
407 addEventCount = removeEventCount = 0;
408 }
409 public void addAppenderEvent(Category cat, Appender appender) {
410 addEventCount++;
411 }
412
413 public void removeAppenderEvent(Category cat, Appender appender) {
414 removeEventCount++;
415 }
416
417 public int getAddEventCount() {
418 return addEventCount;
419 }
420 public int getRemoveEventCount() {
421 return removeEventCount;
422 }
423 }
424
425
426 public void testAppenderEvent1() {
427 CountingHierarchyEventListener listener = new CountingHierarchyEventListener();
428 LogManager.getLoggerRepository().addHierarchyEventListener(listener);
429 CountingAppender appender = new CountingAppender();
430 Logger root = Logger.getRootLogger();
431 root.addAppender(appender);
432 assertEquals(1, listener.getAddEventCount());
433 assertEquals(0, listener.getRemoveEventCount());
434 root.removeAppender(appender);
435 assertEquals(1, listener.getAddEventCount());
436 assertEquals(1, listener.getRemoveEventCount());
437 }
438
439 public void testAppenderEvent2() {
440 CountingHierarchyEventListener listener = new CountingHierarchyEventListener();
441 LogManager.getLoggerRepository().addHierarchyEventListener(listener);
442 CountingAppender appender = new CountingAppender();
443 appender.setName("A1");
444 Logger root = Logger.getRootLogger();
445 root.addAppender(appender);
446 assertEquals(1, listener.getAddEventCount());
447 assertEquals(0, listener.getRemoveEventCount());
448 root.removeAppender(appender.getName());
449 assertEquals(1, listener.getAddEventCount());
450 assertEquals(1, listener.getRemoveEventCount());
451 }
452
453 public void testAppenderEvent3() {
454 CountingHierarchyEventListener listener = new CountingHierarchyEventListener();
455 LogManager.getLoggerRepository().addHierarchyEventListener(listener);
456 CountingAppender appender = new CountingAppender();
457 Logger root = Logger.getRootLogger();
458 root.addAppender(appender);
459 assertEquals(1, listener.getAddEventCount());
460 assertEquals(0, listener.getRemoveEventCount());
461 root.removeAllAppenders();
462 assertEquals(1, listener.getAddEventCount());
463 assertEquals(1, listener.getRemoveEventCount());
464 }
465
466
467 public void testAppenderEvent4() {
468 CountingHierarchyEventListener listener = new CountingHierarchyEventListener();
469 LogManager.getLoggerRepository().addHierarchyEventListener(listener);
470 CountingAppender appender = new CountingAppender();
471 Logger root = Logger.getRootLogger();
472 root.addAppender(appender);
473 assertEquals(1, listener.getAddEventCount());
474 assertEquals(0, listener.getRemoveEventCount());
475 LogManager.resetConfiguration();
476 assertEquals(1, listener.getAddEventCount());
477 assertEquals(1, listener.getRemoveEventCount());
478 }
479
480 static private class CountingAppender extends AppenderSkeleton {
481
482 int counter;
483
484 CountingAppender() {
485 counter = 0;
486 }
487 public void close() {
488 }
489
490 public
491 void append(LoggingEvent event) {
492 counter++;
493 }
494
495 public
496 boolean requiresLayout() {
497 return true;
498 }
499 }
500 }