TestLogSF xref


1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
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 }