tests/src/java/org/apache/log4j/spi/ThrowableInformationTest.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.log4j.spi;

import junit.framework.TestCase;

import java.io.PrintWriter;


/**
 * Unit tests for ThrowableInformation.
 */
public class ThrowableInformationTest extends TestCase {
    /**
     * Create ThrowableInformationTest.
     *
     * @param name test name.
     */
    public ThrowableInformationTest(final String name) {
        super(name);
    }

    /**
     * Custom throwable that only calls methods
     * overridden by VectorWriter in log4j 1.2.14 and earlier.
     */
    private static final class OverriddenThrowable extends Throwable {
        private static final long serialVersionUID = 1L;
        /**
         * Create new instance.
         */
        public OverriddenThrowable() {
        }

        /**
         * Print stack trace.
         *
         * @param s print writer.
         */
        public void printStackTrace(final PrintWriter s) {
            s.print((Object) "print(Object)");
            s.print("print(char[])".toCharArray());
            s.print("print(String)");
            s.println((Object) "println(Object)");
            s.println("println(char[])".toCharArray());
            s.println("println(String)");
            s.write("write(char[])".toCharArray());
            s.write("write(char[], int, int)".toCharArray(), 2, 8);
            s.write("write(String, int, int)", 2, 8);
        }
    }

    /**
     * Test capturing stack trace from a throwable that only uses the
     * PrintWriter methods overridden in log4j 1.2.14 and earlier.
     */
    public void testOverriddenBehavior() {
        ThrowableInformation ti = new ThrowableInformation(new OverriddenThrowable());
        String[] rep = ti.getThrowableStrRep();
        assertEquals(4, rep.length);
        assertEquals("print(Object)print(char[])print(String)println(Object)", rep[0]);
        assertEquals("println(char[])", rep[1]);
        assertEquals("println(String)", rep[2]);
        assertEquals("write(char[])ite(charite(Stri", rep[3]);
    }

    /**
     * Custom throwable that calls methods
     * not overridden by VectorWriter in log4j 1.2.14 and earlier.
     */
    private static final class NotOverriddenThrowable extends Throwable {
        private static final long serialVersionUID = 1L;
        /**
         * Create new instance.
         */
        public NotOverriddenThrowable() {
        }

        /**
         * Print stack trace.
         *
         * @param s print writer.
         */
        public void printStackTrace(final PrintWriter s) {
            s.print(true);
            s.print('a');
            s.print(1);
            s.print(2L);
            s.print(Float.MAX_VALUE);
            s.print(Double.MIN_VALUE);
            s.println(true);
            s.println('a');
            s.println(1);
            s.println(2L);
            s.println(Float.MAX_VALUE);
            s.println(Double.MIN_VALUE);
            s.write('C');
        }
    }

    /**
     * Test capturing stack trace from a throwable that uses the
     * PrintWriter methods not overridden in log4j 1.2.14 and earlier.
     */
    public void testNotOverriddenBehavior() {
        ThrowableInformation ti = new ThrowableInformation(new NotOverriddenThrowable());
        String[] rep = ti.getThrowableStrRep();
        assertEquals(7, rep.length);
        StringBuffer buf = new StringBuffer(String.valueOf(true));
        buf.append('a');
        buf.append(String.valueOf(1));
        buf.append(String.valueOf(2L));
        buf.append(String.valueOf(Float.MAX_VALUE));
        buf.append(String.valueOf(Double.MIN_VALUE));
        buf.append(String.valueOf(true));
        assertEquals(buf.toString(), rep[0]);
        assertEquals("a", rep[1]);
        assertEquals(String.valueOf(1), rep[2]);
        assertEquals(String.valueOf(2L), rep[3]);
        assertEquals(String.valueOf(Float.MAX_VALUE), rep[4]);
        assertEquals(String.valueOf(Double.MIN_VALUE), rep[5]);
        assertEquals("C", rep[6]);
    }

    /**
     * Custom throwable that calls methods of VectorWriter
     * with null.
     */
    private static final class NullThrowable extends Throwable {
        private static final long serialVersionUID = 1L;
        /**
         * Create new instance.
         */
        public NullThrowable() {
        }

        /**
         * Print stack trace.
         *
         * @param s print writer.
         */
        public void printStackTrace(final PrintWriter s) {
            s.print((Object) null);
            s.print((String) null);
            s.println((Object) null);
            s.println((String) null);
        }
    }

    /**
     * Test capturing stack trace from a throwable that passes
     * null to PrintWriter methods.
     */

    public void testNull() {
        ThrowableInformation ti = new ThrowableInformation(new NullThrowable());
        String[] rep = ti.getThrowableStrRep();
        assertEquals(2, rep.length);
        String nullStr = String.valueOf((Object) null);
        assertEquals(nullStr + nullStr + nullStr, rep[0]);
        assertEquals(nullStr, rep[1]);
    }

    /**
     * Custom throwable that does nothing in printStackTrace.
     */
    private static final class EmptyThrowable extends Throwable {
        private static final long serialVersionUID = 1L;
        /**
         * Create new instance.
         */
        public EmptyThrowable() {
        }

        /**
         * Print stack trace.
         *
         * @param s print writer.
         */
        public void printStackTrace(final PrintWriter s) {
        }
    }

    /**
     * Test capturing stack trace from a throwable that
     * does nothing on a call to printStackTrace.
     */

    public void testEmpty() {
        ThrowableInformation ti = new ThrowableInformation(new EmptyThrowable());
        String[] rep = ti.getThrowableStrRep();
        assertEquals(0, rep.length);
    }

    /**
     * Custom throwable that emits a specified string in printStackTrace.
     */
    private static final class StringThrowable extends Throwable {
        private static final long serialVersionUID = 1L;
        /**
         * Stack trace.
         */
        private final String stackTrace;
        /**
         * Create new instance.
         * @param trace stack trace.
         */
        public StringThrowable(final String trace) {
            stackTrace = trace;
        }

        /**
         * Print stack trace.
         *
         * @param s print writer.
         */
        public void printStackTrace(final PrintWriter s) {
            s.print(stackTrace);
        }
    }

    /**
     * Test capturing stack trace from throwable that just has a line feed.
     */
    public void testLineFeed() {
        ThrowableInformation ti = new ThrowableInformation(new StringThrowable("\n"));
        String[] rep = ti.getThrowableStrRep();
        assertEquals(1, rep.length);
        assertEquals("", rep[0]);
    }

    /**
     * Test capturing stack trace from throwable that just has a carriage return.
     */
    public void testCarriageReturn() {
        ThrowableInformation ti = new ThrowableInformation(new StringThrowable("\r"));
        String[] rep = ti.getThrowableStrRep();
        assertEquals(1, rep.length);
        assertEquals("", rep[0]);
    }

    /**
     * Test parsing of line breaks.
     */
    public void testParsing() {
        ThrowableInformation ti = new ThrowableInformation(
                new StringThrowable("Line1\rLine2\nLine3\r\nLine4\n\rLine6"));
        String[] rep = ti.getThrowableStrRep();
        assertEquals(6, rep.length);
        assertEquals("Line1", rep[0]);
        assertEquals("Line2", rep[1]);
        assertEquals("Line3", rep[2]);
        assertEquals("Line4", rep[3]);
        assertEquals("", rep[4]);
        assertEquals("Line6", rep[5]);
    }

    /**
     * Test capturing stack trace from throwable that a line feed followed by blank.
     */
    public void testLineFeedBlank() {
        ThrowableInformation ti = new ThrowableInformation(new StringThrowable("\n "));
        String[] rep = ti.getThrowableStrRep();
        assertEquals(2, rep.length);
        assertEquals("", rep[0]);
        assertEquals(" ", rep[1]);
    }

    /**
     * Test that getThrowable returns the throwable provided to the constructor.
     */
    public void testGetThrowable() {
        Throwable t = new StringThrowable("Hello, World");
        ThrowableInformation ti = new ThrowableInformation(t);
        assertSame(t, ti.getThrowable());
    }

    /**
     *  Tests isolation of returned string representation
     *     from internal state of ThrowableInformation.
     *      log4j 1.2.15 and earlier did not isolate initial call.
     *      See bug 44032.
     */
    public void testIsolation() {
        ThrowableInformation ti = new ThrowableInformation(
                new StringThrowable("Hello, World"));
        String[] rep = ti.getThrowableStrRep();
        assertEquals("Hello, World", rep[0]);
        rep[0] = "Bonjour, Monde";
        String[] rep2 = ti.getThrowableStrRep();
        assertEquals("Hello, World", rep2[0]);
    }

    /**
     * Custom throwable that throws a runtime exception
     *    when printStackTrace is called.
     */
    private static final class NastyThrowable extends Throwable {
        private static final long serialVersionUID = 1L;
        /**
         * Create new instance.
         */
        public NastyThrowable() {
        }

        /**
         * Print stack trace.
         *
         * @param s print writer.
         */
        public void printStackTrace(final PrintWriter s) {
            s.print("NastyException");
            throw new RuntimeException("Intentional exception");
        }
    }

    /**
     * Tests that a failure in printStackTrace
     *     does not percolate out of getThrowableStrRep().
     *
     */
    public void testNastyException() {
        ThrowableInformation ti = new ThrowableInformation(
                new NastyThrowable());
        String[] rep = ti.getThrowableStrRep();
        assertEquals("NastyException", rep[0]);
    }

}