/*
 * 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]);
    }

}
