Apache
/
commons-lang
mirror of https://github.com/apache/commons-lang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update null handling in ExceptionUtils 

git-svn-id: https://svn.apache.org/repos/asf/jakarta/commons/proper/lang/trunk@137509 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Stephen Colebourne 2003-07-26 13:11:21 +00:00
parent 96de08907e
commit ccb2c966f9
1 changed files with 240 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

309
src/test/org/apache/commons/lang/exception/ExceptionUtilsTestCase.java
View File

@ -53,8 +53,14 @@
*/
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;
@ -63,121 +69,287 @@ import junit.framework.TestSuite;
* Tests {@link org.apache.commons.lang.exception.ExceptionUtils}.
*
* @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
* @aithor <a href="mailto:steven@caswell.name">Steven Caswell</a>
* @author <a href="mailto:steven@caswell.name">Steven Caswell</a>
* @author Stephen Colebourne
* @since 1.0
*/
public class ExceptionUtilsTestCase extends junit.framework.TestCase
{
public class ExceptionUtilsTestCase extends junit.framework.TestCase {
private NestableException nested;
private Throwable withCause;
private Throwable withoutCause;
public ExceptionUtilsTestCase(String name)
{
public ExceptionUtilsTestCase(String name) {
super(name);
}
public static Test suite()
{
public static Test suite() {
return new TestSuite(ExceptionUtilsTestCase.class);
}
public void setUp()
{
public void setUp() {
withoutCause = createExceptionWithoutCause();
nested = new NestableException(withoutCause);
withCause = new ExceptionWithCause(nested);
}
private Throwable createExceptionWithoutCause(){
//-----------------------------------------------------------------------
private Throwable createExceptionWithoutCause() {
try {
throw new ExceptionWithoutCause();
}
catch (Throwable t){
} catch (Throwable t) {
return t;
}
}
private Throwable createExceptionWithCause(){
private Throwable createExceptionWithCause() {
try {
try {
throw new ExceptionWithCause(createExceptionWithoutCause());
}
catch (Throwable t){
} catch (Throwable t) {
throw new ExceptionWithCause(t);
}
}
catch (Throwable 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 testGetCause()
{
assertNull(ExceptionUtils.getCause(withoutCause));
assertTrue(ExceptionUtils.getCause(nested) == withoutCause);
assertTrue(ExceptionUtils.getCause(withCause) == nested);
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 testGetRootCause()
{
assertNull(ExceptionUtils.getRootCause(withoutCause));
assertTrue(ExceptionUtils.getRootCause(withCause) == withoutCause);
assertTrue(ExceptionUtils.getRootCause(withCause) == withoutCause);
//-----------------------------------------------------------------------
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 testGetThrowableCount()
{
assertEquals(ExceptionUtils.getThrowableCount(null), 0);
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 testPrintThrowables()
throws Exception
{
StringWriter writer = new StringWriter(1024);
//-----------------------------------------------------------------------
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 PrintWriter(writer));
String stackTrace = writer.toString();
assertTrue("printRootCauseStackTrace(Throwable, PrintWriter) failed",
stackTrace.indexOf(ExceptionUtils.WRAPPED_MARKER) != -1);
writer = new StringWriter(1024);
ExceptionUtils.printRootCauseStackTrace(withoutCause,
new PrintWriter(writer));
stackTrace = writer.toString();
assertTrue("printRootCauseStackTrace(Throwable, PrintWriter) failed",
stackTrace.indexOf(ExceptionUtils.WRAPPED_MARKER) == -1);
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 testIsNestedThrowable() {
assertTrue("SQLException not nested",
ExceptionUtils.isNestedThrowable(new java.sql.SQLException() ) );
assertTrue("InvocationTargetException not nested",
ExceptionUtils.isNestedThrowable(new java.lang.reflect.InvocationTargetException( new Exception() ) ) );
assertTrue("NestableRuntimeException not nested",
ExceptionUtils.isNestedThrowable(new NestableRuntimeException() ) );
// TODO: Come up with a way to test if java.lang.Throwable is nested.
// bearing in mind that in JDK 1.4 it is, and in 1.3 and previous
// it isn't.
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 <code>Throwable</code>.
*/
private static class ExceptionWithCause extends Exception
{
private static class ExceptionWithCause extends Exception {
private Throwable cause;
public ExceptionWithCause(Throwable cause)
{
public ExceptionWithCause(Throwable cause) {
this.cause = cause;
}
public Throwable getCause()
{
public Throwable getCause() {
return cause;
}
}
@ -187,10 +359,9 @@ public class ExceptionUtilsTestCase extends junit.framework.TestCase
* name which does not match the full signature (e.g. lacks a
* return value of <code>Throwable</code>.
*/
private static class ExceptionWithoutCause extends Exception
{
public void getTargetException()
{
private static class ExceptionWithoutCause extends Exception {
public void getTargetException() {
}
}
}