Make CheckedExceptionTunnel show the information of the exception that it...

Make CheckedExceptionTunnel show the information of the exception that it tunnels rather than its own information.

SVN: 24258

base/source/java/ch/systemsx/cisd/base/exceptions/CheckedExceptionTunnel.java

@@ -17,6 +17,8 @@
 package ch.systemsx.cisd.base.exceptions;
 
 import java.io.IOException;
+import java.io.PrintStream;
+import java.io.PrintWriter;
 
 /**
  * An exception for tunneling checked exception through code that doesn't expect it.
@@ -49,6 +51,148 @@ public class CheckedExceptionTunnel extends RuntimeException
     {
     }
 
+    @Override
+    public String getMessage()
+    {
+        if (getCause() != null && getCause().getMessage() != null)
+        {
+            return getCause().getMessage();
+        }
+        return super.getMessage();
+    }
+
+    @Override
+    public String toString()
+    {
+        if (getCause() != null)
+        {
+            return getCause().toString();
+        }
+        return super.toString();
+    }
+
+    @Override
+    public void printStackTrace(PrintStream s)
+    {
+        if (getCause() != null)
+        {
+            getCause().printStackTrace(s);
+        } else
+        {
+            super.printStackTrace(s);
+        }
+    }
+
+    @Override
+    public void printStackTrace(PrintWriter s)
+    {
+        if (getCause() != null)
+        {
+            getCause().printStackTrace(s);
+        } else
+        {
+            super.printStackTrace(s);
+        }
+    }
+
+    /**
+     * Like {@link #printStackTrace()}, but includes the tunnel's stacktrace as well.
+     */
+    public void printFullStackTrace()
+    {
+        printFullStackTrace(System.err);
+    }
+
+    /**
+     * Like {@link #printStackTrace(PrintStream)}, but includes the tunnel's stacktrace as well.
+     */
+    public void printFullStackTrace(PrintStream s)
+    {
+        synchronized (s) {
+            s.println(super.toString());
+            StackTraceElement[] trace = getStackTrace();
+            for (int i=0; i < trace.length; i++)
+                s.println("\tat " + trace[i]);
+
+            Throwable ourCause = getCause();
+            if (ourCause != null)
+            {
+                printStackTraceAsCause(ourCause, s, trace);
+            }
+        }
+    }
+
+    /**
+     * Print our stack trace as a cause for the specified stack trace.
+     */
+    private static void printStackTraceAsCause(Throwable cause, PrintStream s,
+                                        StackTraceElement[] causedTrace)
+    {
+        final StackTraceElement[] trace = cause.getStackTrace();
+        int m = trace.length-1, n = causedTrace.length-1;
+        while (m >= 0 && n >=0 && trace[m].equals(causedTrace[n])) {
+            m--; n--;
+        }
+        final int framesInCommon = trace.length - 1 - m;
+
+        s.println("Caused by: " + cause);
+        for (int i=0; i <= m; i++)
+            s.println("\tat " + trace[i]);
+        if (framesInCommon != 0)
+            s.println("\t... " + framesInCommon + " more");
+
+        final Throwable ourCauseesCause = cause.getCause();
+        if (ourCauseesCause != null)
+        {
+            printStackTraceAsCause(ourCauseesCause, s, trace);
+        }
+    }
+
+    /**
+     * Like {@link #printStackTrace(PrintWriter)}, but includes the tunnel's stacktrace as well.
+     */
+    public void printFullStackTrace(PrintWriter s)
+    {
+        synchronized (s) {
+            s.println(super.toString());
+            StackTraceElement[] trace = getStackTrace();
+            for (int i=0; i < trace.length; i++)
+                s.println("\tat " + trace[i]);
+
+            Throwable ourCause = getCause();
+            if (ourCause != null)
+            {
+                printStackTraceAsCause(ourCause, s, trace);
+            }
+        }
+    }
+
+    /**
+     * Print our stack trace as a cause for the specified stack trace.
+     */
+    private static void printStackTraceAsCause(Throwable cause, PrintWriter s,
+                                        StackTraceElement[] causedTrace)
+    {
+        final StackTraceElement[] trace = cause.getStackTrace();
+        int m = trace.length-1, n = causedTrace.length-1;
+        while (m >= 0 && n >=0 && trace[m].equals(causedTrace[n])) {
+            m--; n--;
+        }
+        final int framesInCommon = trace.length - 1 - m;
+
+        s.println("Caused by: " + cause);
+        for (int i=0; i <= m; i++)
+            s.println("\tat " + trace[i]);
+        if (framesInCommon != 0)
+            s.println("\t... " + framesInCommon + " more");
+
+        final Throwable ourCauseesCause = cause.getCause();
+        if (ourCauseesCause != null)
+        {
+            printStackTraceAsCause(ourCauseesCause, s, trace);
+        }
+    }
+
     /**
      * Convenience wrapper for {@link #wrapIfNecessary(Exception)}. If <var>throwable</var> is an
      * {@link Error}, this method will not return but the error will be thrown.

base/sourceTest/java/ch/systemsx/cisd/base/exceptions/CheckedExceptionTunnelTest.java

+/*
+ * Copyright 2012 ETH Zuerich, CISD
+ *
+ * Licensed 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 ch.systemsx.cisd.base.exceptions;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+import org.apache.commons.lang.StringUtils;
+import org.testng.annotations.Test;
+
+import static org.testng.AssertJUnit.*;
+
+/**
+ * Test cases for {@link CheckedExceptionTunnel}
+ * 
+ * @author Bernd Rinn
+ */
+public class CheckedExceptionTunnelTest
+{
+
+    @Test
+    public void testGetMessage()
+    {
+        final IOException ioe = new IOException("This is the message");
+        final RuntimeException re = CheckedExceptionTunnel.wrapIfNecessary(ioe);
+        assertEquals("This is the message", re.getMessage());
+    }
+
+    @Test
+    public void testToString()
+    {
+        final InterruptedException ioe = new InterruptedException("Somehow got interrupted");
+        final RuntimeException re = CheckedExceptionTunnel.wrapIfNecessary(ioe);
+        assertEquals("java.lang.InterruptedException: Somehow got interrupted", re.toString());
+    }
+
+    @Test
+    public void testPrintStackTrace()
+    {
+        final InterruptedException ie = new InterruptedException("Somehow got interrupted");
+        ie.fillInStackTrace();
+        final RuntimeException re = CheckedExceptionTunnel.wrapIfNecessary(ie);
+        StringWriter sw = new StringWriter();
+        PrintWriter pw = new PrintWriter(sw);
+        re.printStackTrace(pw);
+        final String[] lines = StringUtils.split(sw.toString(), '\n');
+        assertEquals("java.lang.InterruptedException: Somehow got interrupted", lines[0]);
+        assertTrue(
+                lines[1],
+                lines[1].startsWith("\tat ch.systemsx.cisd.base.exceptions.CheckedExceptionTunnelTest."
+                        + "testPrintStackTrace(CheckedExceptionTunnelTest.java"));
+    }
+
+    @Test
+    public void testPrintFullStackTrace()
+    {
+        final Exception e = new Exception("Some exceptional condition");
+        e.fillInStackTrace();
+        final CheckedExceptionTunnel re = new CheckedExceptionTunnel(e);
+        StringWriter sw = new StringWriter();
+        PrintWriter pw = new PrintWriter(sw);
+        re.printFullStackTrace();
+        re.printFullStackTrace(pw);
+        final String[] lines = StringUtils.split(sw.toString(), '\n');
+        assertEquals(
+                "ch.systemsx.cisd.base.exceptions.CheckedExceptionTunnel: Some exceptional condition",
+                lines[0]);
+        assertTrue(
+                lines[1],
+                lines[1].startsWith("\tat ch.systemsx.cisd.base.exceptions.CheckedExceptionTunnelTest."
+                        + "testPrintFullStackTrace(CheckedExceptionTunnelTest.java:"));
+    }
+}