/* ==================================================================== * The Apache Software License, Version 1.1 * * Copyright (c) 2002-2003 The Apache Software Foundation. All rights * reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * 3. The end-user documentation included with the redistribution, if * any, must include the following acknowledgement: * "This product includes software developed by the * Apache Software Foundation (http://www.apache.org/)." * Alternately, this acknowledgement may appear in the software itself, * if and wherever such third-party acknowledgements normally appear. * * 4. The names "The Jakarta Project", "Commons", and "Apache Software * Foundation" must not be used to endorse or promote products derived * from this software without prior written permission. For written * permission, please contact apache@apache.org. * * 5. Products derived from this software may not be called "Apache" * nor may "Apache" appear in their names without prior written * permission of the Apache Software Foundation. * * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * ==================================================================== * * This software consists of voluntary contributions made by many * individuals on behalf of the Apache Software Foundation. For more * information on the Apache Software Foundation, please see * . */ package org.apache.commons.lang.exception; import java.io.ByteArrayOutputStream; import java.io.PrintStream; import java.io.PrintWriter; import java.io.StringWriter; import java.lang.reflect.InvocationTargetException; import java.sql.SQLException; import org.apache.commons.lang.SystemUtils; import junit.framework.Test; import junit.framework.TestSuite; /** * Tests {@link org.apache.commons.lang.exception.ExceptionUtils}. * * @author Daniel Rall * @author Steven Caswell * @author Stephen Colebourne * @since 1.0 */ public class ExceptionUtilsTestCase extends junit.framework.TestCase { private NestableException nested; private Throwable withCause; private Throwable withoutCause; public ExceptionUtilsTestCase(String name) { super(name); } public static Test suite() { return new TestSuite(ExceptionUtilsTestCase.class); } public void setUp() { withoutCause = createExceptionWithoutCause(); nested = new NestableException(withoutCause); withCause = new ExceptionWithCause(nested); } //----------------------------------------------------------------------- private Throwable createExceptionWithoutCause() { try { throw new ExceptionWithoutCause(); } catch (Throwable t) { return t; } } private Throwable createExceptionWithCause() { try { try { throw new ExceptionWithCause(createExceptionWithoutCause()); } catch (Throwable t) { throw new ExceptionWithCause(t); } } catch (Throwable t) { return t; } } //----------------------------------------------------------------------- public void testGetCause_Throwable() { assertSame(null, ExceptionUtils.getCause(null)); assertSame(null, ExceptionUtils.getCause(withoutCause)); assertSame(withoutCause, ExceptionUtils.getCause(nested)); assertSame(nested, ExceptionUtils.getCause(withCause)); } public void testGetCause_ThrowableArray() { assertSame(null, ExceptionUtils.getCause(null, null)); assertSame(null, ExceptionUtils.getCause(null, new String[0])); // match because known type assertSame(withoutCause, ExceptionUtils.getCause(nested, null)); assertSame(withoutCause, ExceptionUtils.getCause(nested, new String[0])); assertSame(withoutCause, ExceptionUtils.getCause(nested, new String[] {"getCause"})); // not known type, so match on supplied method names assertSame(nested, ExceptionUtils.getCause(withCause, null)); // default names assertSame(null, ExceptionUtils.getCause(withCause, new String[0])); assertSame(null, ExceptionUtils.getCause(withCause, new String[] {null})); assertSame(nested, ExceptionUtils.getCause(withCause, new String[] {"getCause"})); // not known type, so match on supplied method names assertSame(null, ExceptionUtils.getCause(withoutCause, null)); assertSame(null, ExceptionUtils.getCause(withoutCause, new String[0])); assertSame(null, ExceptionUtils.getCause(withoutCause, new String[] {null})); assertSame(null, ExceptionUtils.getCause(withoutCause, new String[] {"getCause"})); assertSame(null, ExceptionUtils.getCause(withoutCause, new String[] {"getTargetException"})); } public void testGetRootCause_Throwable() { assertSame(null, ExceptionUtils.getRootCause(null)); assertSame(null, ExceptionUtils.getRootCause(withoutCause)); assertSame(withoutCause, ExceptionUtils.getRootCause(nested)); assertSame(withoutCause, ExceptionUtils.getRootCause(withCause)); } //----------------------------------------------------------------------- public void testIsThrowableNested() { if (SystemUtils.isJavaVersionAtLeast(140)) { assertEquals(true, ExceptionUtils.isThrowableNested()); } else { assertEquals(false, ExceptionUtils.isThrowableNested()); } } public void testIsNestedThrowable_Throwable() { assertEquals(true, ExceptionUtils.isNestedThrowable(new SQLException())); assertEquals(true, ExceptionUtils.isNestedThrowable(new InvocationTargetException(new Exception()))); assertEquals(true, ExceptionUtils.isNestedThrowable(new NestableRuntimeException())); assertEquals(true, ExceptionUtils.isNestedThrowable(withCause)); assertEquals(true, ExceptionUtils.isNestedThrowable(nested)); if (SystemUtils.isJavaVersionAtLeast(140)) { assertEquals(true, ExceptionUtils.isNestedThrowable(withoutCause)); assertEquals(true, ExceptionUtils.isNestedThrowable(new Throwable())); } else { assertEquals(false, ExceptionUtils.isNestedThrowable(withoutCause)); assertEquals(false, ExceptionUtils.isNestedThrowable(new Throwable())); } } //----------------------------------------------------------------------- public void testGetThrowableCount_Throwable() { assertEquals(0, ExceptionUtils.getThrowableCount(null)); assertEquals(1, ExceptionUtils.getThrowableCount(withoutCause)); assertEquals(2, ExceptionUtils.getThrowableCount(nested)); assertEquals(3, ExceptionUtils.getThrowableCount(withCause)); } public void testGetThrowables_Throwable() { assertEquals(0, ExceptionUtils.getThrowables(null).length); assertEquals(1, ExceptionUtils.getThrowables(withoutCause).length); assertSame(withoutCause, ExceptionUtils.getThrowables(withoutCause)[0]); assertEquals(2, ExceptionUtils.getThrowables(nested).length); assertSame(nested, ExceptionUtils.getThrowables(nested)[0]); assertSame(withoutCause, ExceptionUtils.getThrowables(nested)[1]); assertEquals(3, ExceptionUtils.getThrowables(withCause).length); assertSame(withCause, ExceptionUtils.getThrowables(withCause)[0]); assertSame(nested, ExceptionUtils.getThrowables(withCause)[1]); assertSame(withoutCause, ExceptionUtils.getThrowables(withCause)[2]); } //----------------------------------------------------------------------- public void testIndexOf_ThrowableClass() { assertEquals(-1, ExceptionUtils.indexOfThrowable(null, null)); assertEquals(-1, ExceptionUtils.indexOfThrowable(null, NestableException.class)); assertEquals(-1, ExceptionUtils.indexOfThrowable(withoutCause, null)); assertEquals(-1, ExceptionUtils.indexOfThrowable(withoutCause, ExceptionWithCause.class)); assertEquals(-1, ExceptionUtils.indexOfThrowable(withoutCause, NestableException.class)); assertEquals(0, ExceptionUtils.indexOfThrowable(withoutCause, ExceptionWithoutCause.class)); assertEquals(-1, ExceptionUtils.indexOfThrowable(nested, null)); assertEquals(-1, ExceptionUtils.indexOfThrowable(nested, ExceptionWithCause.class)); assertEquals(0, ExceptionUtils.indexOfThrowable(nested, NestableException.class)); assertEquals(1, ExceptionUtils.indexOfThrowable(nested, ExceptionWithoutCause.class)); assertEquals(-1, ExceptionUtils.indexOfThrowable(withCause, null)); assertEquals(0, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithCause.class)); assertEquals(1, ExceptionUtils.indexOfThrowable(withCause, NestableException.class)); assertEquals(2, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithoutCause.class)); } public void testIndexOf_ThrowableClassInt() { assertEquals(-1, ExceptionUtils.indexOfThrowable(null, null, 0)); assertEquals(-1, ExceptionUtils.indexOfThrowable(null, NestableException.class, 0)); assertEquals(-1, ExceptionUtils.indexOfThrowable(withoutCause, null)); assertEquals(-1, ExceptionUtils.indexOfThrowable(withoutCause, ExceptionWithCause.class, 0)); assertEquals(-1, ExceptionUtils.indexOfThrowable(withoutCause, NestableException.class, 0)); assertEquals(0, ExceptionUtils.indexOfThrowable(withoutCause, ExceptionWithoutCause.class, 0)); assertEquals(-1, ExceptionUtils.indexOfThrowable(nested, null, 0)); assertEquals(-1, ExceptionUtils.indexOfThrowable(nested, ExceptionWithCause.class, 0)); assertEquals(0, ExceptionUtils.indexOfThrowable(nested, NestableException.class, 0)); assertEquals(1, ExceptionUtils.indexOfThrowable(nested, ExceptionWithoutCause.class, 0)); assertEquals(-1, ExceptionUtils.indexOfThrowable(withCause, null)); assertEquals(0, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithCause.class, 0)); assertEquals(1, ExceptionUtils.indexOfThrowable(withCause, NestableException.class, 0)); assertEquals(2, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithoutCause.class, 0)); assertEquals(0, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithCause.class, -1)); assertEquals(0, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithCause.class, 0)); assertEquals(-1, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithCause.class, 1)); assertEquals(-1, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithCause.class, 9)); } //----------------------------------------------------------------------- public void testPrintRootCauseStackTrace_Throwable() throws Exception { ExceptionUtils.printRootCauseStackTrace(null); // could pipe system.err to a known stream, but not much point as // internally this method calls stram method anyway } public void testPrintRootCauseStackTrace_ThrowableStream() throws Exception { ByteArrayOutputStream out = new ByteArrayOutputStream(1024); ExceptionUtils.printRootCauseStackTrace(null, (PrintStream) null); ExceptionUtils.printRootCauseStackTrace(null, new PrintStream(out)); assertEquals(0, out.toString().length()); out = new ByteArrayOutputStream(1024); try { ExceptionUtils.printRootCauseStackTrace(withCause, (PrintStream) null); fail(); } catch (IllegalArgumentException ex) { } out = new ByteArrayOutputStream(1024); Throwable withCause = createExceptionWithCause(); ExceptionUtils.printRootCauseStackTrace(withCause, new PrintStream(out)); String stackTrace = out.toString(); assertTrue(stackTrace.indexOf(ExceptionUtils.WRAPPED_MARKER) != -1); out = new ByteArrayOutputStream(1024); ExceptionUtils.printRootCauseStackTrace(withoutCause, new PrintStream(out)); stackTrace = out.toString(); assertTrue(stackTrace.indexOf(ExceptionUtils.WRAPPED_MARKER) == -1); } public void testPrintRootCauseStackTrace_ThrowableWriter() throws Exception { StringWriter writer = new StringWriter(1024); ExceptionUtils.printRootCauseStackTrace(null, (PrintWriter) null); ExceptionUtils.printRootCauseStackTrace(null, new PrintWriter(writer)); assertEquals(0, writer.getBuffer().length()); writer = new StringWriter(1024); try { ExceptionUtils.printRootCauseStackTrace(withCause, (PrintWriter) null); fail(); } catch (IllegalArgumentException ex) { } writer = new StringWriter(1024); Throwable withCause = createExceptionWithCause(); ExceptionUtils.printRootCauseStackTrace(withCause, new PrintWriter(writer)); String stackTrace = writer.toString(); assertTrue(stackTrace.indexOf(ExceptionUtils.WRAPPED_MARKER) != -1); writer = new StringWriter(1024); ExceptionUtils.printRootCauseStackTrace(withoutCause, new PrintWriter(writer)); stackTrace = writer.toString(); assertTrue(stackTrace.indexOf(ExceptionUtils.WRAPPED_MARKER) == -1); } //----------------------------------------------------------------------- public void testGetRootCauseStackTrace_Throwable() throws Exception { assertEquals(0, ExceptionUtils.getRootCauseStackTrace(null).length); Throwable withCause = createExceptionWithCause(); String[] stackTrace = ExceptionUtils.getRootCauseStackTrace(withCause); boolean match = false; for (int i = 0; i < stackTrace.length; i++) { if (stackTrace[i].startsWith(ExceptionUtils.WRAPPED_MARKER)) { match = true; break; } } assertEquals(true, match); stackTrace = ExceptionUtils.getRootCauseStackTrace(withoutCause); match = false; for (int i = 0; i < stackTrace.length; i++) { if (stackTrace[i].startsWith(ExceptionUtils.WRAPPED_MARKER)) { match = true; break; } } assertEquals(false, match); } public void testRemoveCommonFrames_ListList() throws Exception { try { ExceptionUtils.removeCommonFrames(null, null); fail(); } catch (IllegalArgumentException ex) { } } //----------------------------------------------------------------------- /** * Provides a method with a well known chained/nested exception * name which matches the full signature (e.g. has a return value * of Throwable. */ private static class ExceptionWithCause extends Exception { private Throwable cause; public ExceptionWithCause(Throwable cause) { this.cause = cause; } public Throwable getCause() { return cause; } } /** * Provides a method with a well known chained/nested exception * name which does not match the full signature (e.g. lacks a * return value of Throwable. */ private static class ExceptionWithoutCause extends Exception { public void getTargetException() { } } }