1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.log4j;
18
19 import junit.framework.TestCase;
20
21 import java.io.CharArrayWriter;
22 import java.text.MessageFormat;
23 import java.util.Date;
24
25
26 /***
27 * Unit test for LogMF.
28 */
29 public class TestLogMF extends TestCase {
30 /***
31 * Trace level.
32 */
33 private static final Level TRACE = getTraceLevel();
34
35 /***
36 * Gets Trace level.
37 * Trace level was not defined prior to log4j 1.2.12.
38 * @return trace level
39 */
40 private static Level getTraceLevel() {
41 try {
42 return (Level) Level.class.getField("TRACE").get(null);
43 } catch(Exception ex) {
44 return new Level(5000, "TRACE", 7);
45 }
46 }
47
48 /***
49 * Logger.
50 */
51 private final Logger logger = Logger.getLogger(
52 "org.apache.log4j.formatter.TestLogMF");
53
54 /***
55 * Create the test case
56 *
57 * @param testName name of the test case
58 */
59 public TestLogMF(String testName) {
60 super(testName);
61 }
62
63
64 /***
65 * Post test clean up.
66 */
67 public void tearDown() {
68 LogManager.resetConfiguration();
69 }
70
71 /***
72 * Test class name when logging through LogMF.
73 */
74 public void testClassName() {
75 CharArrayWriter writer = new CharArrayWriter();
76 PatternLayout layout = new PatternLayout("%C");
77 WriterAppender appender = new WriterAppender(layout, writer);
78 appender.activateOptions();
79 Logger.getRootLogger().addAppender(appender);
80 LogMF.debug(logger, null, Math.PI);
81 assertEquals(TestLogMF.class.getName(), writer.toString());
82 }
83
84 /***
85 * Test LogMF.trace with null pattern.
86 */
87 public void testTraceNullPattern() {
88 LogCapture capture = new LogCapture(TRACE);
89 logger.setLevel(TRACE);
90 LogMF.trace(logger, null, Math.PI);
91 assertNull(capture.getMessage());
92 }
93
94 /***
95 * Test LogMF.trace with no-field pattern.
96 */
97 public void testTraceNoArg() {
98 LogCapture capture = new LogCapture(TRACE);
99 logger.setLevel(TRACE);
100 LogMF.trace(logger, "Hello, World", Math.PI);
101 assertEquals("Hello, World", capture.getMessage());
102 }
103
104 /***
105 * Test LogMF.trace with malformed pattern.
106 */
107 public void testTraceBadPattern() {
108 LogCapture capture = new LogCapture(TRACE);
109 logger.setLevel(TRACE);
110 LogMF.trace(logger, "Hello, {.", Math.PI);
111 assertEquals("Hello, {.", capture.getMessage());
112 }
113
114 /***
115 * Test LogMF.trace with missing argument.
116 */
117 public void testTraceMissingArg() {
118 LogCapture capture = new LogCapture(TRACE);
119 logger.setLevel(TRACE);
120 LogMF.trace(logger, "Hello, {0}World", new Object[0]);
121 assertEquals("Hello, {0}World", capture.getMessage());
122 }
123
124 /***
125 * Test LogMF.trace with single field pattern with string argument.
126 */
127 public void testTraceString() {
128 LogCapture capture = new LogCapture(TRACE);
129 logger.setLevel(TRACE);
130 LogMF.trace(logger, "Hello, {0}", "World");
131 assertEquals("Hello, World", capture.getMessage());
132 }
133
134 /***
135 * Test LogMF.trace with single field pattern with null argument.
136 */
137 public void testTraceNull() {
138 LogCapture capture = new LogCapture(TRACE);
139 logger.setLevel(TRACE);
140 LogMF.trace(logger, "Hello, {0}", (Object) null);
141 assertEquals("Hello, null", capture.getMessage());
142 }
143
144 /***
145 * Test LogMF.trace with single field pattern with int argument.
146 */
147 public void testTraceInt() {
148 LogCapture capture = new LogCapture(TRACE);
149 logger.setLevel(TRACE);
150
151 int val = 42;
152 LogMF.trace(logger, "Iteration {0}", val);
153 assertEquals("Iteration 42", capture.getMessage());
154 }
155
156 /***
157 * Test LogMF.trace with single field pattern with byte argument.
158 */
159 public void testTraceByte() {
160 LogCapture capture = new LogCapture(TRACE);
161 logger.setLevel(TRACE);
162
163 byte val = 42;
164 LogMF.trace(logger, "Iteration {0}", val);
165 assertEquals("Iteration 42", capture.getMessage());
166 }
167
168 /***
169 * Test LogMF.trace with single field pattern with short argument.
170 */
171 public void testTraceShort() {
172 LogCapture capture = new LogCapture(TRACE);
173 logger.setLevel(TRACE);
174
175 short val = 42;
176 LogMF.trace(logger, "Iteration {0}", val);
177 assertEquals("Iteration 42", capture.getMessage());
178 }
179
180 /***
181 * Test LogMF.trace with single field pattern with long argument.
182 */
183 public void testTraceLong() {
184 LogCapture capture = new LogCapture(TRACE);
185 logger.setLevel(TRACE);
186
187 long val = 42;
188 LogMF.trace(logger, "Iteration {0}", val);
189 assertEquals("Iteration 42", capture.getMessage());
190 }
191
192 /***
193 * Test LogMF.trace with single field pattern with char argument.
194 */
195 public void testTraceChar() {
196 LogCapture capture = new LogCapture(TRACE);
197 logger.setLevel(TRACE);
198
199 char val = 'C';
200 LogMF.trace(logger, "Iteration {0}", val);
201 assertEquals("Iteration C", capture.getMessage());
202 }
203
204 /***
205 * Test LogMF.trace with single field pattern with boolean argument.
206 */
207 public void testTraceBoolean() {
208 LogCapture capture = new LogCapture(TRACE);
209 logger.setLevel(TRACE);
210
211 boolean val = true;
212 LogMF.trace(logger, "Iteration {0}", val);
213 assertEquals("Iteration true", capture.getMessage());
214 }
215
216 /***
217 * Test LogMF.trace with single field pattern with float argument.
218 */
219 public void testTraceFloat() {
220 LogCapture capture = new LogCapture(TRACE);
221 logger.setLevel(TRACE);
222
223 float val = 3.14f;
224 LogMF.trace(logger, "Iteration {0}", val);
225 assertEquals("Iteration 3.14", capture.getMessage());
226 }
227
228 /***
229 * Test LogMF.trace with single field pattern with double argument.
230 */
231 public void testTraceDouble() {
232 LogCapture capture = new LogCapture(TRACE);
233 logger.setLevel(TRACE);
234
235 double val = 3.14;
236 LogMF.trace(logger, "Iteration {0}", val);
237 assertEquals("Iteration 3.14", capture.getMessage());
238 }
239
240 /***
241 * Test LogMF.trace with two arguments.
242 */
243 public void testTraceTwoArg() {
244 LogCapture capture = new LogCapture(TRACE);
245 logger.setLevel(TRACE);
246 LogMF.trace(logger, "{1}, {0}.", "World", "Hello");
247 assertEquals("Hello, World.", capture.getMessage());
248 }
249
250 /***
251 * Test LogMF.trace with three arguments.
252 */
253 public void testTraceThreeArg() {
254 LogCapture capture = new LogCapture(TRACE);
255 logger.setLevel(TRACE);
256 LogMF.trace(logger, "{1}{2} {0}.", "World", "Hello", ",");
257 assertEquals("Hello, World.", capture.getMessage());
258 }
259
260 /***
261 * Test LogMF.trace with four arguments.
262 */
263 public void testTraceFourArg() {
264 LogCapture capture = new LogCapture(TRACE);
265 logger.setLevel(TRACE);
266 LogMF.trace(logger, "{1}{2} {0}{3}", "World", "Hello", ",", ".");
267 assertEquals("Hello, World.", capture.getMessage());
268 }
269
270 /***
271 * Test LogMF.trace with Object[] argument.
272 */
273 public void testTraceArrayArg() {
274 LogCapture capture = new LogCapture(TRACE);
275 logger.setLevel(TRACE);
276
277 Object[] args = new Object[] { "World", "Hello", ",", "." };
278 LogMF.trace(logger, "{1}{2} {0}{3}", args);
279 assertEquals("Hello, World.", capture.getMessage());
280 }
281
282 /***
283 * Test LogMF.trace with null Object[] argument.
284 */
285 public void testTraceNullArrayArg() {
286 LogCapture capture = new LogCapture(TRACE);
287 logger.setLevel(TRACE);
288
289 Object[] args = null;
290 LogMF.trace(logger, "{1}{2} {0}{3}", args);
291 assertEquals("{1}{2} {0}{3}", capture.getMessage());
292 }
293
294
295 /***
296 * Test LogMF.debug with null pattern.
297 */
298 public void testDebugNullPattern() {
299 LogCapture capture = new LogCapture(Level.DEBUG);
300 LogMF.debug(logger, null, Math.PI);
301 assertEquals(null, capture.getMessage());
302 }
303
304 /***
305 * Test LogMF.debug with no-field pattern.
306 */
307 public void testDebugNoArg() {
308 LogCapture capture = new LogCapture(Level.DEBUG);
309 LogMF.debug(logger, "Hello, World", Math.PI);
310 assertEquals("Hello, World", capture.getMessage());
311 }
312
313 /***
314 * Test LogMF.debug with malformed pattern.
315 */
316 public void testDebugBadPattern() {
317 LogCapture capture = new LogCapture(Level.DEBUG);
318 LogMF.debug(logger, "Hello, {.", Math.PI);
319 assertEquals("Hello, {.", capture.getMessage());
320 }
321
322 /***
323 * Test LogMF.debug with missing argument.
324 */
325 public void testDebugMissingArg() {
326 LogCapture capture = new LogCapture(Level.DEBUG);
327 LogMF.debug(logger, "Hello, {0}World", new Object[0]);
328 assertEquals("Hello, {0}World", capture.getMessage());
329 }
330
331 /***
332 * Test LogMF.debug with single field pattern with string argument.
333 */
334 public void testDebugString() {
335 LogCapture capture = new LogCapture(Level.DEBUG);
336 LogMF.debug(logger, "Hello, {0}", "World");
337 assertEquals("Hello, World", capture.getMessage());
338 }
339
340 /***
341 * Test LogMF.debug with single field pattern with null argument.
342 */
343 public void testDebugNull() {
344 LogCapture capture = new LogCapture(Level.DEBUG);
345 LogMF.debug(logger, "Hello, {0}", (Object) null);
346 assertEquals("Hello, null", capture.getMessage());
347 }
348
349 /***
350 * Test LogMF.debug with single field pattern with int argument.
351 */
352 public void testDebugInt() {
353 LogCapture capture = new LogCapture(Level.DEBUG);
354 int val = 42;
355 LogMF.debug(logger, "Iteration {0}", val);
356 assertEquals("Iteration 42", capture.getMessage());
357 }
358
359 /***
360 * Test LogMF.debug with single field pattern with byte argument.
361 */
362 public void testDebugByte() {
363 LogCapture capture = new LogCapture(Level.DEBUG);
364 byte val = 42;
365 LogMF.debug(logger, "Iteration {0}", val);
366 assertEquals("Iteration 42", capture.getMessage());
367 }
368
369 /***
370 * Test LogMF.debug with single field pattern with short argument.
371 */
372 public void testDebugShort() {
373 LogCapture capture = new LogCapture(Level.DEBUG);
374 short val = 42;
375 LogMF.debug(logger, "Iteration {0}", val);
376 assertEquals("Iteration 42", capture.getMessage());
377 }
378
379 /***
380 * Test LogMF.debug with single field pattern with long argument.
381 */
382 public void testDebugLong() {
383 LogCapture capture = new LogCapture(Level.DEBUG);
384 long val = 42;
385 LogMF.debug(logger, "Iteration {0}", val);
386 assertEquals("Iteration 42", capture.getMessage());
387 }
388
389 /***
390 * Test LogMF.debug with single field pattern with char argument.
391 */
392 public void testDebugChar() {
393 LogCapture capture = new LogCapture(Level.DEBUG);
394 char val = 'C';
395 LogMF.debug(logger, "Iteration {0}", val);
396 assertEquals("Iteration C", capture.getMessage());
397 }
398
399 /***
400 * Test LogMF.debug with single field pattern with boolean argument.
401 */
402 public void testDebugBoolean() {
403 LogCapture capture = new LogCapture(Level.DEBUG);
404 boolean val = true;
405 LogMF.debug(logger, "Iteration {0}", val);
406 assertEquals("Iteration true", capture.getMessage());
407 }
408
409 /***
410 * Test LogMF.debug with single field pattern with float argument.
411 */
412 public void testDebugFloat() {
413 LogCapture capture = new LogCapture(Level.DEBUG);
414 LogMF.debug(logger, "Iteration {0}", (float) Math.PI);
415
416 String expected = MessageFormat.format("Iteration {0}",
417 new Object[] { new Float(Math.PI) });
418 assertEquals(expected, capture.getMessage());
419 }
420
421 /***
422 * Test LogMF.debug with single field pattern with double argument.
423 */
424 public void testDebugDouble() {
425 LogCapture capture = new LogCapture(Level.DEBUG);
426 LogMF.debug(logger, "Iteration {0}", Math.PI);
427
428 String expected = MessageFormat.format("Iteration {0}",
429 new Object[] { new Double(Math.PI) });
430 assertEquals(expected, capture.getMessage());
431 }
432
433 /***
434 * Test LogMF.debug with two arguments.
435 */
436 public void testDebugTwoArg() {
437 LogCapture capture = new LogCapture(Level.DEBUG);
438 LogMF.debug(logger, "{1}, {0}.", "World", "Hello");
439 assertEquals("Hello, World.", capture.getMessage());
440 }
441
442 /***
443 * Test LogMF.debug with three arguments.
444 */
445 public void testDebugThreeArg() {
446 LogCapture capture = new LogCapture(Level.DEBUG);
447 LogMF.debug(logger, "{1}{2} {0}.", "World", "Hello", ",");
448 assertEquals("Hello, World.", capture.getMessage());
449 }
450
451 /***
452 * Test LogMF.debug with four arguments.
453 */
454 public void testDebugFourArg() {
455 LogCapture capture = new LogCapture(Level.DEBUG);
456 LogMF.debug(logger, "{1}{2} {0}{3}", "World", "Hello", ",", ".");
457 assertEquals("Hello, World.", capture.getMessage());
458 }
459
460 /***
461 * Test LogMF.debug with Object[] argument.
462 */
463 public void testDebugArrayArg() {
464 LogCapture capture = new LogCapture(Level.DEBUG);
465 Object[] args = new Object[] { "World", "Hello", ",", "." };
466 LogMF.debug(logger, "{1}{2} {0}{3}", args);
467 assertEquals("Hello, World.", capture.getMessage());
468 }
469
470 /***
471 * Test LogMF.debug with single field pattern with double argument.
472 */
473 public void testDebugDate() {
474 LogCapture capture = new LogCapture(Level.DEBUG);
475 Date epoch = new Date(0);
476 LogMF.debug(logger, "Iteration {0}", epoch);
477
478 String expected = MessageFormat.format("Iteration {0}",
479 new Object[] { epoch });
480 assertEquals(expected, capture.getMessage());
481 }
482
483 /***
484 * Test LogMF.debug with null Object[] argument.
485 */
486 public void testDebugNullArrayArg() {
487 LogCapture capture = new LogCapture(Level.DEBUG);
488 Object[] args = null;
489 LogMF.debug(logger, "{1}{2} {0}{3}", args);
490 assertEquals("{1}{2} {0}{3}", capture.getMessage());
491 }
492
493 public void testDebugPercent() {
494 LogCapture capture = new LogCapture(Level.DEBUG);
495 LogMF.debug(logger, "{0, number, percent}", Math.PI);
496
497 String expected = java.text.MessageFormat.format("{0, number, percent}",
498 new Object[] { new Double(Math.PI) });
499 assertEquals(expected, capture.getMessage());
500 }
501
502 public void testDebugFullPrecisionAndPercent() {
503 LogCapture capture = new LogCapture(Level.DEBUG);
504 LogMF.debug(logger, "{0}{0, number, percent}", Math.PI);
505
506 String expected = java.text.MessageFormat.format("{0}{0, number, percent}",
507 new Object[] { new Double(Math.PI) });
508 assertEquals(expected, capture.getMessage());
509 }
510
511 public void testDebugQuoted() {
512 LogCapture capture = new LogCapture(Level.DEBUG);
513 LogMF.debug(logger, "'{0}'", "World");
514 assertEquals("{0}", capture.getMessage());
515 }
516
517 /***
518 * Test LogMF.info with null pattern.
519 */
520 public void testInfoNullPattern() {
521 LogCapture capture = new LogCapture(Level.INFO);
522 LogMF.info(logger, null, Math.PI);
523 assertNull(capture.getMessage());
524 }
525
526 /***
527 * Test LogMF.info with no-field pattern.
528 */
529 public void testInfoNoArg() {
530 LogCapture capture = new LogCapture(Level.INFO);
531 LogMF.info(logger, "Hello, World", Math.PI);
532 assertEquals("Hello, World", capture.getMessage());
533 }
534
535 /***
536 * Test LogMF.info with malformed pattern.
537 */
538 public void testInfoBadPattern() {
539 LogCapture capture = new LogCapture(Level.INFO);
540 LogMF.info(logger, "Hello, {.", Math.PI);
541 assertEquals("Hello, {.", capture.getMessage());
542 }
543
544 /***
545 * Test LogMF.info with missing argument.
546 */
547 public void testInfoMissingArg() {
548 LogCapture capture = new LogCapture(Level.INFO);
549 LogMF.info(logger, "Hello, {0}World", new Object[0]);
550 assertEquals("Hello, {0}World", capture.getMessage());
551 }
552
553 /***
554 * Test LogMF.info with single field pattern with string argument.
555 */
556 public void testInfoString() {
557 LogCapture capture = new LogCapture(Level.INFO);
558 LogMF.info(logger, "Hello, {0}", "World");
559 assertEquals("Hello, World", capture.getMessage());
560 }
561
562 /***
563 * Test LogMF.info with single field pattern with null argument.
564 */
565 public void testInfoNull() {
566 LogCapture capture = new LogCapture(Level.INFO);
567 LogMF.info(logger, "Hello, {0}", (Object) null);
568 assertEquals("Hello, null", capture.getMessage());
569 }
570
571 /***
572 * Test LogMF.info with single field pattern with int argument.
573 */
574 public void testInfoInt() {
575 LogCapture capture = new LogCapture(Level.INFO);
576 int val = 42;
577 LogMF.info(logger, "Iteration {0}", val);
578 assertEquals("Iteration 42", capture.getMessage());
579 }
580
581 /***
582 * Test LogMF.info with single field pattern with byte argument.
583 */
584 public void testInfoByte() {
585 LogCapture capture = new LogCapture(Level.INFO);
586 byte val = 42;
587 LogMF.info(logger, "Iteration {0}", val);
588 assertEquals("Iteration 42", capture.getMessage());
589 }
590
591 /***
592 * Test LogMF.info with single field pattern with short argument.
593 */
594 public void testInfoShort() {
595 LogCapture capture = new LogCapture(Level.INFO);
596 short val = 42;
597 LogMF.info(logger, "Iteration {0}", val);
598 assertEquals("Iteration 42", capture.getMessage());
599 }
600
601 /***
602 * Test LogMF.info with single field pattern with long argument.
603 */
604 public void testInfoLong() {
605 LogCapture capture = new LogCapture(Level.INFO);
606 long val = 42;
607 LogMF.info(logger, "Iteration {0}", val);
608 assertEquals("Iteration 42", capture.getMessage());
609 }
610
611 /***
612 * Test LogMF.info with single field pattern with char argument.
613 */
614 public void testInfoChar() {
615 LogCapture capture = new LogCapture(Level.INFO);
616 char val = 'C';
617 LogMF.info(logger, "Iteration {0}", val);
618 assertEquals("Iteration C", capture.getMessage());
619 }
620
621 /***
622 * Test LogMF.info with single field pattern with boolean argument.
623 */
624 public void testInfoBoolean() {
625 LogCapture capture = new LogCapture(Level.INFO);
626 boolean val = true;
627 LogMF.info(logger, "Iteration {0}", val);
628 assertEquals("Iteration true", capture.getMessage());
629 }
630
631 /***
632 * Test LogMF.info with single field pattern with float argument.
633 */
634 public void testInfoFloat() {
635 LogCapture capture = new LogCapture(Level.INFO);
636 LogMF.info(logger, "Iteration {0}", (float) Math.PI);
637
638 String expected = MessageFormat.format("Iteration {0}",
639 new Object[] { new Float(Math.PI) });
640 assertEquals(expected, capture.getMessage());
641 }
642
643 /***
644 * Test LogMF.info with single field pattern with double argument.
645 */
646 public void testInfoDouble() {
647 LogCapture capture = new LogCapture(Level.INFO);
648 LogMF.info(logger, "Iteration {0}", Math.PI);
649
650 String expected = MessageFormat.format("Iteration {0}",
651 new Object[] { new Double(Math.PI) });
652 assertEquals(expected, capture.getMessage());
653 }
654
655 /***
656 * Test LogMF.info with two arguments.
657 */
658 public void testInfoTwoArg() {
659 LogCapture capture = new LogCapture(Level.INFO);
660 LogMF.info(logger, "{1}, {0}.", "World", "Hello");
661 assertEquals("Hello, World.", capture.getMessage());
662 }
663
664 /***
665 * Test LogMF.info with three arguments.
666 */
667 public void testInfoThreeArg() {
668 LogCapture capture = new LogCapture(Level.INFO);
669 LogMF.info(logger, "{1}{2} {0}.", "World", "Hello", ",");
670 assertEquals("Hello, World.", capture.getMessage());
671 }
672
673 /***
674 * Test LogMF.info with four arguments.
675 */
676 public void testInfoFourArg() {
677 LogCapture capture = new LogCapture(Level.INFO);
678 LogMF.info(logger, "{1}{2} {0}{3}", "World", "Hello", ",", ".");
679 assertEquals("Hello, World.", capture.getMessage());
680 }
681
682 /***
683 * Test LogMF.info with Object[] argument.
684 */
685 public void testInfoArrayArg() {
686 LogCapture capture = new LogCapture(Level.INFO);
687 Object[] args = new Object[] { "World", "Hello", ",", "." };
688 LogMF.info(logger, "{1}{2} {0}{3}", args);
689 assertEquals("Hello, World.", capture.getMessage());
690 }
691
692 /***
693 * Test LogMF.warn with null pattern.
694 */
695 public void testWarnNullPattern() {
696 LogCapture capture = new LogCapture(Level.WARN);
697 LogMF.warn(logger, null, Math.PI);
698 assertNull(capture.getMessage());
699 }
700
701 /***
702 * Test LogMF.warn with no-field pattern.
703 */
704 public void testWarnNoArg() {
705 LogCapture capture = new LogCapture(Level.WARN);
706 LogMF.warn(logger, "Hello, World", Math.PI);
707 assertEquals("Hello, World", capture.getMessage());
708 }
709
710 /***
711 * Test LogMF.warn with malformed pattern.
712 */
713 public void testWarnBadPattern() {
714 LogCapture capture = new LogCapture(Level.WARN);
715 LogMF.warn(logger, "Hello, {.", Math.PI);
716 assertEquals("Hello, {.", capture.getMessage());
717 }
718
719 /***
720 * Test LogMF.warn with missing argument.
721 */
722 public void testWarnMissingArg() {
723 LogCapture capture = new LogCapture(Level.WARN);
724 LogMF.warn(logger, "Hello, {0}World", new Object[0]);
725 assertEquals("Hello, {0}World", capture.getMessage());
726 }
727
728 /***
729 * Test LogMF.warn with single field pattern with string argument.
730 */
731 public void testWarnString() {
732 LogCapture capture = new LogCapture(Level.WARN);
733 LogMF.warn(logger, "Hello, {0}", "World");
734 assertEquals("Hello, World", capture.getMessage());
735 }
736
737 /***
738 * Test LogMF.warn with single field pattern with null argument.
739 */
740 public void testWarnNull() {
741 LogCapture capture = new LogCapture(Level.WARN);
742 LogMF.warn(logger, "Hello, {0}", (Object) null);
743 assertEquals("Hello, null", capture.getMessage());
744 }
745
746 /***
747 * Test LogMF.warn with single field pattern with int argument.
748 */
749 public void testWarnInt() {
750 LogCapture capture = new LogCapture(Level.WARN);
751 int val = 42;
752 LogMF.warn(logger, "Iteration {0}", val);
753 assertEquals("Iteration 42", capture.getMessage());
754 }
755
756 /***
757 * Test LogMF.warn with single field pattern with byte argument.
758 */
759 public void testWarnByte() {
760 LogCapture capture = new LogCapture(Level.WARN);
761 byte val = 42;
762 LogMF.warn(logger, "Iteration {0}", val);
763 assertEquals("Iteration 42", capture.getMessage());
764 }
765
766 /***
767 * Test LogMF.warn with single field pattern with short argument.
768 */
769 public void testWarnShort() {
770 LogCapture capture = new LogCapture(Level.WARN);
771 short val = 42;
772 LogMF.warn(logger, "Iteration {0}", val);
773 assertEquals("Iteration 42", capture.getMessage());
774 }
775
776 /***
777 * Test LogMF.warn with single field pattern with long argument.
778 */
779 public void testWarnLong() {
780 LogCapture capture = new LogCapture(Level.WARN);
781 long val = 42;
782 LogMF.warn(logger, "Iteration {0}", val);
783 assertEquals("Iteration 42", capture.getMessage());
784 }
785
786 /***
787 * Test LogMF.warn with single field pattern with char argument.
788 */
789 public void testWarnChar() {
790 LogCapture capture = new LogCapture(Level.WARN);
791 char val = 'C';
792 LogMF.warn(logger, "Iteration {0}", val);
793 assertEquals("Iteration C", capture.getMessage());
794 }
795
796 /***
797 * Test LogMF.warn with single field pattern with boolean argument.
798 */
799 public void testWarnBoolean() {
800 LogCapture capture = new LogCapture(Level.WARN);
801 boolean val = true;
802 LogMF.warn(logger, "Iteration {0}", val);
803 assertEquals("Iteration true", capture.getMessage());
804 }
805
806 /***
807 * Test LogMF.warn with single field pattern with float argument.
808 */
809 public void testWarnFloat() {
810 LogCapture capture = new LogCapture(Level.WARN);
811 LogMF.warn(logger, "Iteration {0}", (float) Math.PI);
812
813 String expected = MessageFormat.format("Iteration {0}",
814 new Object[] { new Float(Math.PI) });
815 assertEquals(expected, capture.getMessage());
816 }
817
818 /***
819 * Test LogMF.debug with single field pattern with double argument.
820 */
821 public void testWarnDouble() {
822 LogCapture capture = new LogCapture(Level.WARN);
823 LogMF.warn(logger, "Iteration {0}", Math.PI);
824
825 String expected = MessageFormat.format("Iteration {0}",
826 new Object[] { new Double(Math.PI) });
827 assertEquals(expected, capture.getMessage());
828 }
829
830 /***
831 * Test LogMF.warn with two arguments.
832 */
833 public void testWarnTwoArg() {
834 LogCapture capture = new LogCapture(Level.WARN);
835 LogMF.warn(logger, "{1}, {0}.", "World", "Hello");
836 assertEquals("Hello, World.", capture.getMessage());
837 }
838
839 /***
840 * Test LogMF.warn with three arguments.
841 */
842 public void testWarnThreeArg() {
843 LogCapture capture = new LogCapture(Level.WARN);
844 LogMF.warn(logger, "{1}{2} {0}.", "World", "Hello", ",");
845 assertEquals("Hello, World.", capture.getMessage());
846 }
847
848 /***
849 * Test LogMF.debug with four arguments.
850 */
851 public void testWarnFourArg() {
852 LogCapture capture = new LogCapture(Level.WARN);
853 LogMF.warn(logger, "{1}{2} {0}{3}", "World", "Hello", ",", ".");
854 assertEquals("Hello, World.", capture.getMessage());
855 }
856
857 /***
858 * Test LogMF.warn with Object[] argument.
859 */
860 public void testWarnArrayArg() {
861 LogCapture capture = new LogCapture(Level.WARN);
862 Object[] args = new Object[] { "World", "Hello", ",", "." };
863 LogMF.warn(logger, "{1}{2} {0}{3}", args);
864 assertEquals("Hello, World.", capture.getMessage());
865 }
866
867 /***
868 * Test LogMF.log with null pattern.
869 */
870 public void testLogNullPattern() {
871 LogCapture capture = new LogCapture(Level.ERROR);
872 LogMF.log(logger, Level.ERROR, null, Math.PI);
873 assertNull(capture.getMessage());
874 }
875
876 /***
877 * Test LogMF.log with no-field pattern.
878 */
879 public void testLogNoArg() {
880 LogCapture capture = new LogCapture(Level.ERROR);
881 LogMF.log(logger, Level.ERROR, "Hello, World", Math.PI);
882 assertEquals("Hello, World", capture.getMessage());
883 }
884
885 /***
886 * Test LogMF.log with malformed pattern.
887 */
888 public void testLogBadPattern() {
889 LogCapture capture = new LogCapture(Level.ERROR);
890 LogMF.log(logger, Level.ERROR, "Hello, {.", Math.PI);
891 assertEquals("Hello, {.", capture.getMessage());
892 }
893
894 /***
895 * Test LogMF.log with missing argument.
896 */
897 public void testLogMissingArg() {
898 LogCapture capture = new LogCapture(Level.ERROR);
899 LogMF.log(logger, Level.ERROR, "Hello, {0}World", new Object[0]);
900 assertEquals("Hello, {0}World", capture.getMessage());
901 }
902
903 /***
904 * Test LogMF.log with single field pattern with string argument.
905 */
906 public void testLogString() {
907 LogCapture capture = new LogCapture(Level.ERROR);
908 LogMF.log(logger, Level.ERROR, "Hello, {0}", "World");
909 assertEquals("Hello, World", capture.getMessage());
910 }
911
912 /***
913 * Test LogMF.log with single field pattern with null argument.
914 */
915 public void testLogNull() {
916 LogCapture capture = new LogCapture(Level.ERROR);
917 LogMF.log(logger, Level.ERROR, "Hello, {0}", (Object) null);
918 assertEquals("Hello, null", capture.getMessage());
919 }
920
921 /***
922 * Test LogMF.log with single field pattern with int argument.
923 */
924 public void testLogInt() {
925 LogCapture capture = new LogCapture(Level.ERROR);
926 int val = 42;
927 LogMF.log(logger, Level.ERROR, "Iteration {0}", val);
928 assertEquals("Iteration 42", capture.getMessage());
929 }
930
931 /***
932 * Test LogMF.log with single field pattern with byte argument.
933 */
934 public void testLogByte() {
935 LogCapture capture = new LogCapture(Level.ERROR);
936 byte val = 42;
937 LogMF.log(logger, Level.ERROR, "Iteration {0}", val);
938 assertEquals("Iteration 42", capture.getMessage());
939 }
940
941 /***
942 * Test LogMF.log with single field pattern with short argument.
943 */
944 public void testLogShort() {
945 LogCapture capture = new LogCapture(Level.ERROR);
946 short val = 42;
947 LogMF.log(logger, Level.ERROR, "Iteration {0}", val);
948 assertEquals("Iteration 42", capture.getMessage());
949 }
950
951 /***
952 * Test LogMF.log with single field pattern with long argument.
953 */
954 public void testLogLong() {
955 LogCapture capture = new LogCapture(Level.ERROR);
956 long val = 42;
957 LogMF.log(logger, Level.ERROR, "Iteration {0}", val);
958 assertEquals("Iteration 42", capture.getMessage());
959 }
960
961 /***
962 * Test LogMF.log with single field pattern with char argument.
963 */
964 public void testLogChar() {
965 LogCapture capture = new LogCapture(Level.ERROR);
966 char val = 'C';
967 LogMF.log(logger, Level.ERROR, "Iteration {0}", val);
968 assertEquals("Iteration C", capture.getMessage());
969 }
970
971 /***
972 * Test LogMF.log with single field pattern with boolean argument.
973 */
974 public void testLogBoolean() {
975 LogCapture capture = new LogCapture(Level.ERROR);
976 boolean val = true;
977 LogMF.log(logger, Level.ERROR, "Iteration {0}", val);
978 assertEquals("Iteration true", capture.getMessage());
979 }
980
981 /***
982 * Test LogMF.log with single field pattern with float argument.
983 */
984 public void testLogFloat() {
985 LogCapture capture = new LogCapture(Level.ERROR);
986 LogMF.log(logger, Level.ERROR, "Iteration {0}", (float) Math.PI);
987
988 String expected = MessageFormat.format("Iteration {0}",
989 new Object[] { new Float(Math.PI) });
990 assertEquals(expected, capture.getMessage());
991 }
992
993 /***
994 * Test LogMF.log with single field pattern with double argument.
995 */
996 public void testLogDouble() {
997 LogCapture capture = new LogCapture(Level.ERROR);
998 LogMF.log(logger, Level.ERROR, "Iteration {0}", Math.PI);
999
1000 String expected = MessageFormat.format("Iteration {0}",
1001 new Object[] { new Double(Math.PI) });
1002 assertEquals(expected, capture.getMessage());
1003 }
1004
1005 /***
1006 * Test LogMF.log with two arguments.
1007 */
1008 public void testLogTwoArg() {
1009 LogCapture capture = new LogCapture(Level.ERROR);
1010 LogMF.log(logger, Level.ERROR, "{1}, {0}.", "World", "Hello");
1011 assertEquals("Hello, World.", capture.getMessage());
1012 }
1013
1014 /***
1015 * Test LogMF.log with three arguments.
1016 */
1017 public void testLogThreeArg() {
1018 LogCapture capture = new LogCapture(Level.ERROR);
1019 LogMF.log(logger, Level.ERROR, "{1}{2} {0}.", "World", "Hello", ",");
1020 assertEquals("Hello, World.", capture.getMessage());
1021 }
1022
1023 /***
1024 * Test LogMF.log with four arguments.
1025 */
1026 public void testLogFourArg() {
1027 LogCapture capture = new LogCapture(Level.ERROR);
1028 LogMF.log(logger, Level.ERROR, "{1}{2} {0}{3}", "World", "Hello", ",", ".");
1029 assertEquals("Hello, World.", capture.getMessage());
1030 }
1031
1032 /***
1033 * Test LogMF.log with Object[] argument.
1034 */
1035 public void testLogArrayArg() {
1036 LogCapture capture = new LogCapture(Level.ERROR);
1037 Object[] args = new Object[] { "World", "Hello", ",", "." };
1038 LogMF.log(logger, Level.ERROR, "{1}{2} {0}{3}", args);
1039 assertEquals("Hello, World.", capture.getMessage());
1040 }
1041
1042 /***
1043 * Bundle name for resource bundle tests.
1044 */
1045 private static final String BUNDLE_NAME =
1046 "org.apache.log4j.TestLogMFPatterns";
1047
1048 /***
1049 * Test LogMF.logrb with null bundle name.
1050 */
1051 public void testLogrbNullBundle() {
1052 LogCapture capture = new LogCapture(Level.ERROR);
1053 LogMF.logrb(logger, Level.ERROR, null, "Iteration0", Math.PI);
1054 assertEquals("Iteration0", capture.getMessage());
1055 }
1056
1057 /***
1058 * Test LogMF.logrb with null key.
1059 */
1060 public void testLogrbNullKey() {
1061 LogCapture capture = new LogCapture(Level.ERROR);
1062 LogMF.logrb(logger, Level.ERROR, BUNDLE_NAME, null, Math.PI);
1063 assertNull(capture.getMessage());
1064 }
1065
1066 /***
1067 * Test LogMF.logrb with no-field pattern.
1068 */
1069 public void testLogrbNoArg() {
1070 LogCapture capture = new LogCapture(Level.ERROR);
1071 LogMF.logrb(logger, Level.ERROR, BUNDLE_NAME, "Hello1", Math.PI);
1072 assertEquals("Hello, World", capture.getMessage());
1073 }
1074
1075 /***
1076 * Test LogMF.logrb with malformed pattern.
1077 */
1078 public void testLogrbBadPattern() {
1079 LogCapture capture = new LogCapture(Level.ERROR);
1080 LogMF.logrb(logger, Level.ERROR, BUNDLE_NAME, "Malformed", Math.PI);
1081 assertEquals("Hello, {.", capture.getMessage());
1082 }
1083
1084 /***
1085 * Test LogMF.logrb with missing argument.
1086 */
1087 public void testLogrbMissingArg() {
1088 LogCapture capture = new LogCapture(Level.ERROR);
1089 LogMF.logrb(logger, Level.ERROR, BUNDLE_NAME, "Hello2", new Object[0]);
1090 assertEquals("Hello, {0}World", capture.getMessage());
1091 }
1092
1093 /***
1094 * Test LogMF.logrb with single field pattern with string argument.
1095 */
1096 public void testLogrbString() {
1097 LogCapture capture = new LogCapture(Level.ERROR);
1098 LogMF.logrb(logger, Level.ERROR, BUNDLE_NAME, "Hello3", "World");
1099 assertEquals("Hello, World", capture.getMessage());
1100 }
1101
1102 /***
1103 * Test LogMF.logrb with single field pattern with null argument.
1104 */
1105 public void testLogrbNull() {
1106 LogCapture capture = new LogCapture(Level.ERROR);
1107 LogMF.logrb(logger, Level.ERROR, BUNDLE_NAME, "Hello3", (Object) null);
1108 assertEquals("Hello, null", capture.getMessage());
1109 }
1110
1111 /***
1112 * Test LogMF.logrb with single field pattern with int argument.
1113 */
1114 public void testLogrbInt() {
1115 LogCapture capture = new LogCapture(Level.ERROR);
1116 int val = 42;
1117 LogMF.logrb(logger, Level.ERROR, BUNDLE_NAME, "Iteration0", val);
1118 assertEquals("Iteration 42", capture.getMessage());
1119 }
1120
1121 /***
1122 * Test LogMF.logrb with single field pattern with byte argument.
1123 */
1124 public void testLogrbByte() {
1125 LogCapture capture = new LogCapture(Level.ERROR);
1126 byte val = 42;
1127 LogMF.logrb(logger, Level.ERROR, BUNDLE_NAME, "Iteration0", val);
1128 assertEquals("Iteration 42", capture.getMessage());
1129 }
1130
1131 /***
1132 * Test LogMF.logrb with single field pattern with short argument.
1133 */
1134 public void testLogrbShort() {
1135 LogCapture capture = new LogCapture(Level.ERROR);
1136 short val = 42;
1137 LogMF.logrb(logger, Level.ERROR, BUNDLE_NAME, "Iteration0", val);
1138 assertEquals("Iteration 42", capture.getMessage());
1139 }
1140
1141 /***
1142 * Test LogMF.logrb with single field pattern with long argument.
1143 */
1144 public void testLogrbLong() {
1145 LogCapture capture = new LogCapture(Level.ERROR);
1146 long val = 42;
1147 LogMF.logrb(logger, Level.ERROR, BUNDLE_NAME, "Iteration0", val);
1148 assertEquals("Iteration 42", capture.getMessage());
1149 }
1150
1151 /***
1152 * Test LogMF.logrb with single field pattern with char argument.
1153 */
1154 public void testLogrbChar() {
1155 LogCapture capture = new LogCapture(Level.ERROR);
1156 char val = 'C';
1157 LogMF.logrb(logger, Level.ERROR, BUNDLE_NAME, "Iteration0", val);
1158 assertEquals("Iteration C", capture.getMessage());
1159 }
1160
1161 /***
1162 * Test LogMF.logrb with single field pattern with boolean argument.
1163 */
1164 public void testLogrbBoolean() {
1165 LogCapture capture = new LogCapture(Level.ERROR);
1166 boolean val = true;
1167 LogMF.logrb(logger, Level.ERROR, BUNDLE_NAME, "Iteration0", val);
1168 assertEquals("Iteration true", capture.getMessage());
1169 }
1170
1171 /***
1172 * Test LogMF.logrb with single field pattern with float argument.
1173 */
1174 public void testLogrbFloat() {
1175 LogCapture capture = new LogCapture(Level.ERROR);
1176 LogMF.logrb(logger, Level.ERROR, BUNDLE_NAME, "Iteration0", (float) Math.PI);
1177
1178 String expected = MessageFormat.format("Iteration {0}",
1179 new Object[] { new Float(Math.PI) });
1180 assertEquals(expected, capture.getMessage());
1181 }
1182
1183 /***
1184 * Test LogMF.logrb with single field pattern with double argument.
1185 */
1186 public void testLogrbDouble() {
1187 LogCapture capture = new LogCapture(Level.ERROR);
1188 LogMF.logrb(logger, Level.ERROR, BUNDLE_NAME, "Iteration0", Math.PI);
1189
1190 String expected = MessageFormat.format("Iteration {0}",
1191 new Object[] { new Double(Math.PI) });
1192 assertEquals(expected, capture.getMessage());
1193 }
1194
1195 /***
1196 * Test LogMF.logrb with two arguments.
1197 */
1198 public void testLogrbTwoArg() {
1199 LogCapture capture = new LogCapture(Level.ERROR);
1200 LogMF.logrb(logger, Level.ERROR,
1201 BUNDLE_NAME, "Hello4", "World", "Hello");
1202 assertEquals("Hello, World.", capture.getMessage());
1203 }
1204
1205 /***
1206 * Test LogMF.logrb with three arguments.
1207 */
1208 public void testLogrbThreeArg() {
1209 LogCapture capture = new LogCapture(Level.ERROR);
1210 LogMF.logrb(logger, Level.ERROR,
1211 BUNDLE_NAME, "Hello5", "World", "Hello", ",");
1212 assertEquals("Hello, World.", capture.getMessage());
1213 }
1214
1215 /***
1216 * Test LogMF.logrb with four arguments.
1217 */
1218 public void testLogrbFourArg() {
1219 LogCapture capture = new LogCapture(Level.ERROR);
1220 LogMF.logrb(logger, Level.ERROR,
1221 BUNDLE_NAME, "Hello6", "World", "Hello", ",", ".");
1222 assertEquals("Hello, World.", capture.getMessage());
1223 }
1224
1225 /***
1226 * Test LogMF.logrb with Object[] argument.
1227 */
1228 public void testLogrbArrayArg() {
1229 LogCapture capture = new LogCapture(Level.ERROR);
1230 Object[] args = new Object[] { "World", "Hello", ",", "." };
1231 LogMF.logrb(logger, Level.ERROR,
1232 BUNDLE_NAME, "Hello6", args);
1233 assertEquals("Hello, World.", capture.getMessage());
1234 }
1235
1236 }