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