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.spi;
    18
    19  import junit.framework.TestCase;
    20
    21  import java.io.PrintWriter;
    22
    23
    24  /***
    25   * Unit tests for ThrowableInformation.
    26   */
    27  public class ThrowableInformationTest extends TestCase {
    28      /***
    29       * Create ThrowableInformationTest.
    30       *
    31       * @param name test name.
    32       */
    33      public ThrowableInformationTest(final String name) {
    34          super(name);
    35      }
    36
    37      /***
    38       * Custom throwable that only calls methods
    39       * overridden by VectorWriter in log4j 1.2.14 and earlier.
    40       */
    41      private static final class OverriddenThrowable extends Throwable {
    42          /***
    43           * Create new instance.
    44           */
    45          public OverriddenThrowable() {
    46          }
    47
    48          /***
    49           * Print stack trace.
    50           *
    51           * @param s print writer.
    52           */
    53          public void printStackTrace(final PrintWriter s) {
    54              s.print((Object) "print(Object)");
    55              s.print("print(char[])".toCharArray());
    56              s.print("print(String)");
    57              s.println((Object) "println(Object)");
    58              s.println("println(char[])".toCharArray());
    59              s.println("println(String)");
    60              s.write("write(char[])".toCharArray());
    61              s.write("write(char[], int, int)".toCharArray(), 2, 8);
    62              s.write("write(String, int, int)", 2, 8);
    63          }
    64      }
    65
    66      /***
    67       * Test capturing stack trace from a throwable that only uses the
    68       * PrintWriter methods overridden in log4j 1.2.14 and earlier.
    69       */
    70      public void testOverriddenBehavior() {
    71          ThrowableInformation ti = new ThrowableInformation(new OverriddenThrowable());
    72          String[] rep = ti.getThrowableStrRep();
    73          assertEquals(4, rep.length);
    74          assertEquals("print(Object)print(char[])print(String)println(Object)", rep[0]);
    75          assertEquals("println(char[])", rep[1]);
    76          assertEquals("println(String)", rep[2]);
    77          assertEquals("write(char[])ite(charite(Stri", rep[3]);
    78      }
    79
    80      /***
    81       * Custom throwable that calls methods
    82       * not overridden by VectorWriter in log4j 1.2.14 and earlier.
    83       */
    84      private static final class NotOverriddenThrowable extends Throwable {
    85          /***
    86           * Create new instance.
    87           */
    88          public NotOverriddenThrowable() {
    89          }
    90
    91          /***
    92           * Print stack trace.
    93           *
    94           * @param s print writer.
    95           */
    96          public void printStackTrace(final PrintWriter s) {
    97              s.print(true);
    98              s.print('a');
    99              s.print(1);
    100             s.print(2L);
    101             s.print(Float.MAX_VALUE);
    102             s.print(Double.MIN_VALUE);
    103             s.println(true);
    104             s.println('a');
    105             s.println(1);
    106             s.println(2L);
    107             s.println(Float.MAX_VALUE);
    108             s.println(Double.MIN_VALUE);
    109             s.write('C');
    110         }
    111     }
    112
    113     /***
    114      * Test capturing stack trace from a throwable that uses the
    115      * PrintWriter methods not overridden in log4j 1.2.14 and earlier.
    116      */
    117     public void testNotOverriddenBehavior() {
    118         ThrowableInformation ti = new ThrowableInformation(new NotOverriddenThrowable());
    119         String[] rep = ti.getThrowableStrRep();
    120         assertEquals(7, rep.length);
    121         StringBuffer buf = new StringBuffer(String.valueOf(true));
    122         buf.append('a');
    123         buf.append(String.valueOf(1));
    124         buf.append(String.valueOf(2L));
    125         buf.append(String.valueOf(Float.MAX_VALUE));
    126         buf.append(String.valueOf(Double.MIN_VALUE));
    127         buf.append(String.valueOf(true));
    128         assertEquals(buf.toString(), rep[0]);
    129         assertEquals("a", rep[1]);
    130         assertEquals(String.valueOf(1), rep[2]);
    131         assertEquals(String.valueOf(2L), rep[3]);
    132         assertEquals(String.valueOf(Float.MAX_VALUE), rep[4]);
    133         assertEquals(String.valueOf(Double.MIN_VALUE), rep[5]);
    134         assertEquals("C", rep[6]);
    135     }
    136
    137     /***
    138      * Custom throwable that calls methods of VectorWriter
    139      * with null.
    140      */
    141     private static final class NullThrowable extends Throwable {
    142         /***
    143          * Create new instance.
    144          */
    145         public NullThrowable() {
    146         }
    147
    148         /***
    149          * Print stack trace.
    150          *
    151          * @param s print writer.
    152          */
    153         public void printStackTrace(final PrintWriter s) {
    154             s.print((Object) null);
    155             s.print((String) null);
    156             s.println((Object) null);
    157             s.println((String) null);
    158         }
    159     }
    160
    161     /***
    162      * Test capturing stack trace from a throwable that passes
    163      * null to PrintWriter methods.
    164      */
    165
    166     public void testNull() {
    167         ThrowableInformation ti = new ThrowableInformation(new NullThrowable());
    168         String[] rep = ti.getThrowableStrRep();
    169         assertEquals(2, rep.length);
    170         String nullStr = String.valueOf((Object) null);
    171         assertEquals(nullStr + nullStr + nullStr, rep[0]);
    172         assertEquals(nullStr, rep[1]);
    173     }
    174
    175     /***
    176      * Custom throwable that does nothing in printStackTrace.
    177      */
    178     private static final class EmptyThrowable extends Throwable {
    179         /***
    180          * Create new instance.
    181          */
    182         public EmptyThrowable() {
    183         }
    184
    185         /***
    186          * Print stack trace.
    187          *
    188          * @param s print writer.
    189          */
    190         public void printStackTrace(final PrintWriter s) {
    191         }
    192     }
    193
    194     /***
    195      * Test capturing stack trace from a throwable that
    196      * does nothing on a call to printStackTrace.
    197      */
    198
    199     public void testEmpty() {
    200         ThrowableInformation ti = new ThrowableInformation(new EmptyThrowable());
    201         String[] rep = ti.getThrowableStrRep();
    202         assertEquals(0, rep.length);
    203     }
    204
    205     /***
    206      * Custom throwable that emits a specified string in printStackTrace.
    207      */
    208     private static final class StringThrowable extends Throwable {
    209         /***
    210          * Stack trace.
    211          */
    212         private final String stackTrace;
    213         /***
    214          * Create new instance.
    215          * @param trace stack trace.
    216          */
    217         public StringThrowable(final String trace) {
    218             stackTrace = trace;
    219         }
    220
    221         /***
    222          * Print stack trace.
    223          *
    224          * @param s print writer.
    225          */
    226         public void printStackTrace(final PrintWriter s) {
    227             s.print(stackTrace);
    228         }
    229     }
    230
    231     /***
    232      * Test capturing stack trace from throwable that just has a line feed.
    233      */
    234     public void testLineFeed() {
    235         ThrowableInformation ti = new ThrowableInformation(new StringThrowable("\n"));
    236         String[] rep = ti.getThrowableStrRep();
    237         assertEquals(1, rep.length);
    238         assertEquals("", rep[0]);
    239     }
    240
    241     /***
    242      * Test capturing stack trace from throwable that just has a carriage return.
    243      */
    244     public void testCarriageReturn() {
    245         ThrowableInformation ti = new ThrowableInformation(new StringThrowable("\r"));
    246         String[] rep = ti.getThrowableStrRep();
    247         assertEquals(1, rep.length);
    248         assertEquals("", rep[0]);
    249     }
    250
    251     /***
    252      * Test parsing of line breaks.
    253      */
    254     public void testParsing() {
    255         ThrowableInformation ti = new ThrowableInformation(
    256                 new StringThrowable("Line1\rLine2\nLine3\r\nLine4\n\rLine6"));
    257         String[] rep = ti.getThrowableStrRep();
    258         assertEquals(6, rep.length);
    259         assertEquals("Line1", rep[0]);
    260         assertEquals("Line2", rep[1]);
    261         assertEquals("Line3", rep[2]);
    262         assertEquals("Line4", rep[3]);
    263         assertEquals("", rep[4]);
    264         assertEquals("Line6", rep[5]);
    265     }
    266
    267     /***
    268      * Test capturing stack trace from throwable that a line feed followed by blank.
    269      */
    270     public void testLineFeedBlank() {
    271         ThrowableInformation ti = new ThrowableInformation(new StringThrowable("\n "));
    272         String[] rep = ti.getThrowableStrRep();
    273         assertEquals(2, rep.length);
    274         assertEquals("", rep[0]);
    275         assertEquals(" ", rep[1]);
    276     }
    277
    278     /***
    279      * Test that getThrowable returns the throwable provided to the constructor.
    280      */
    281     public void testGetThrowable() {
    282         Throwable t = new StringThrowable("Hello, World");
    283         ThrowableInformation ti = new ThrowableInformation(t);
    284         assertSame(t, ti.getThrowable());
    285     }
    286 }