View Javadoc

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  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 }