printStackTrace and getCause implementation

The printStackTrace and getCause implementations have different approaches to handling circular references.
If on a JVM where printStackTrace is called directly, the full causal chain will always be printed. If on one such as Dalvik
where getCause is invoked directly then it will cut the causal chain if it sees a duplicate.

Author: benjchristensen

rxjava-core/src/main/java/rx/exceptions/CompositeException.java

@@ -20,6 +20,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
@@ -31,6 +32,12 @@
  *
  * Its invariant is to contains an immutable, ordered (by insertion order), unique list of non-composite exceptions.
  * This list may be queried by {@code #getExceptions()}
+ * 
+ * The `printStackTrace()` implementation does custom handling of the StackTrace instead of using `getCause()` so it
+ * can avoid circular references.
+ * 
+ * If `getCause()` is invoked, it will lazily create the causal chain but stop if it finds any Throwable in the chain
+ * that it has already seen.
  */
 public final class CompositeException extends RuntimeException {
 
@@ -42,7 +49,7 @@ public final class CompositeException extends RuntimeException {
     public CompositeException(String messagePrefix, Collection<? extends Throwable> errors) {
         Set<Throwable> deDupedExceptions = new LinkedHashSet<Throwable>();
         List<Throwable> _exceptions = new ArrayList<Throwable>();
-        for (Throwable ex: errors) {
+        for (Throwable ex : errors) {
             if (ex instanceof CompositeException) {
                 deDupedExceptions.addAll(((CompositeException) ex).getExceptions());
             } else {
@@ -52,7 +59,7 @@ public CompositeException(String messagePrefix, Collection<? extends Throwable>
 
         _exceptions.addAll(deDupedExceptions);
         this.exceptions = Collections.unmodifiableList(_exceptions);
-        this.message = exceptions.size() + " exceptions occurred. See them in causal chain below.";
+        this.message = exceptions.size() + " exceptions occurred. ";
     }
 
     public CompositeException(Collection<? extends Throwable> errors) {
@@ -62,8 +69,7 @@ public CompositeException(Collection<? extends Throwable> errors) {
     /**
      * Retrieves the list of exceptions that make up the {@code CompositeException}
      *
-     * @return the exceptions that make up the {@code CompositeException}, as a {@link List} of
-     *         {@link Throwable}s
+     * @return the exceptions that make up the {@code CompositeException}, as a {@link List} of {@link Throwable}s
      */
     public List<Throwable> getExceptions() {
         return exceptions;
@@ -74,9 +80,47 @@ public String getMessage() {
         return message;
     }
 
+    private Throwable cause = null;
+
     @Override
     public synchronized Throwable getCause() {
-        return null;
+        if (cause == null) {
+            // we lazily generate this causal chain if this is called
+            CompositeExceptionCausalChain _cause = new CompositeExceptionCausalChain();
+            Set<Throwable> seenCauses = new HashSet<Throwable>();
+
+            Throwable chain = _cause;
+            for (Throwable e : exceptions) {
+                if (seenCauses.contains(e)) {
+                    // already seen this outer Throwable so skip
+                    continue;
+                }
+                seenCauses.add(e);
+                
+                List<Throwable> listOfCauses = getListOfCauses(e);
+                // check if any of them have been seen before
+                for(Throwable child : listOfCauses) {
+                    if (seenCauses.contains(child)) {
+                        // already seen this outer Throwable so skip
+                        e = new RuntimeException("Duplicate found in causal chain so cropping to prevent loop ...");
+                        continue;
+                    }
+                    seenCauses.add(child);
+                }
+
+                // we now have 'e' as the last in the chain
+                try {
+                    chain.initCause(e);
+                } catch (Throwable t) {
+                    // ignore
+                    // the javadocs say that some Throwables (depending on how they're made) will never
+                    // let me call initCause without blowing up even if it returns null
+                }
+                chain = chain.getCause();
+            }
+            cause = _cause;
+        }
+        return cause;
     }
 
     /**
@@ -106,16 +150,18 @@ public void printStackTrace(PrintWriter s) {
     /**
      * Special handling for printing out a CompositeException
      * Loop through all inner exceptions and print them out
-     * @param s stream to print to
+     * 
+     * @param s
+     *            stream to print to
      */
     private void printStackTrace(PrintStreamOrWriter s) {
         StringBuilder bldr = new StringBuilder();
         bldr.append(this).append("\n");
-        for (StackTraceElement myStackElement: getStackTrace()) {
+        for (StackTraceElement myStackElement : getStackTrace()) {
             bldr.append("\tat ").append(myStackElement).append("\n");
         }
         int i = 1;
-        for (Throwable ex: exceptions) {
+        for (Throwable ex : exceptions) {
             bldr.append("  ComposedException ").append(i).append(" :").append("\n");
             appendStackTrace(bldr, ex, "\t");
             i++;
@@ -127,7 +173,7 @@ private void printStackTrace(PrintStreamOrWriter s) {
 
     private void appendStackTrace(StringBuilder bldr, Throwable ex, String prefix) {
         bldr.append(prefix).append(ex).append("\n");
-        for (StackTraceElement stackElement: ex.getStackTrace()) {
+        for (StackTraceElement stackElement : ex.getStackTrace()) {
             bldr.append("\t\tat ").append(stackElement).append("\n");
         }
         if (ex.getCause() != null) {
@@ -178,4 +224,31 @@ void println(Object o) {
             printWriter.println(o);
         }
     }
+
+    /* package-private */final static class CompositeExceptionCausalChain extends RuntimeException {
+        private static final long serialVersionUID = 3875212506787802066L;
+        /* package-private */static String MESSAGE = "Chain of Causes for CompositeException In Order Received =>";
+
+        @Override
+        public String getMessage() {
+            return MESSAGE;
+        }
+    }
+
+    private final List<Throwable> getListOfCauses(Throwable ex) {
+        List<Throwable> list = new ArrayList<Throwable>();
+        Throwable root = ex.getCause();
+        if (root == null) {
+            return list;
+        } else {
+            while(true) {
+                list.add(root);
+                if (root.getCause() == null) {
+                    return list;
+                } else {
+                    root = root.getCause();
+                }
+            }
+        }
+    }
 }

rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java

@@ -16,8 +16,8 @@
 package rx.exceptions;
 
 import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
 
 import java.io.ByteArrayOutputStream;
 import java.io.PrintStream;
@@ -26,6 +26,8 @@
 import java.util.Arrays;
 import java.util.List;
 
+import org.junit.Test;
+
 public class CompositeExceptionTest {
 
     private final Throwable ex1 = new Throwable("Ex1");
@@ -50,37 +52,75 @@ public void testMultipleWithSameCause() {
         Throwable e2 = new Throwable("2", rootCause);
         Throwable e3 = new Throwable("3", rootCause);
         CompositeException ce = new CompositeException("3 failures with same root cause", Arrays.asList(e1, e2, e3));
-        
+
+        System.err.println("----------------------------- print composite stacktrace");
+        ce.printStackTrace();
         assertEquals(3, ce.getExceptions().size());
+        
         assertNoCircularReferences(ce);
+        assertNotNull(getRootCause(ce));
+        System.err.println("----------------------------- print cause stacktrace");
+        ce.getCause().printStackTrace();
     }
 
     @Test(timeout = 1000)
     public void testCompositeExceptionFromParentThenChild() {
         CompositeException cex = new CompositeException(Arrays.asList(ex1, ex2));
-        assertNoCircularReferences(cex);
+        
+        System.err.println("----------------------------- print composite stacktrace");
+        cex.printStackTrace();
         assertEquals(2, cex.getExceptions().size());
+        
+        assertNoCircularReferences(cex);
+        assertNotNull(getRootCause(cex));
+        
+        System.err.println("----------------------------- print cause stacktrace");
+        cex.getCause().printStackTrace();
     }
 
     @Test(timeout = 1000)
     public void testCompositeExceptionFromChildThenParent() {
         CompositeException cex = new CompositeException(Arrays.asList(ex2, ex1));
-        assertNoCircularReferences(cex);
+        
+        System.err.println("----------------------------- print composite stacktrace");
+        cex.printStackTrace();
         assertEquals(2, cex.getExceptions().size());
+        
+        assertNoCircularReferences(cex);
+        assertNotNull(getRootCause(cex));
+        
+        System.err.println("----------------------------- print cause stacktrace");
+        cex.getCause().printStackTrace();
     }
 
     @Test(timeout = 1000)
     public void testCompositeExceptionFromChildAndComposite() {
         CompositeException cex = new CompositeException(Arrays.asList(ex1, getNewCompositeExceptionWithEx123()));
-        assertNoCircularReferences(cex);
+        
+        System.err.println("----------------------------- print composite stacktrace");
+        cex.printStackTrace();
         assertEquals(3, cex.getExceptions().size());
+        
+        assertNoCircularReferences(cex);
+        assertNotNull(getRootCause(cex));
+
+        System.err.println("----------------------------- print cause stacktrace");
+        cex.getCause().printStackTrace();
     }
 
     @Test(timeout = 1000)
     public void testCompositeExceptionFromCompositeAndChild() {
         CompositeException cex = new CompositeException(Arrays.asList(getNewCompositeExceptionWithEx123(), ex1));
-        assertNoCircularReferences(cex);
+        
+        System.err.println("----------------------------- print composite stacktrace");
+        cex.printStackTrace();
         assertEquals(3, cex.getExceptions().size());
+        
+        assertNoCircularReferences(cex);
+        assertNotNull(getRootCause(cex));
+
+        System.err.println("----------------------------- print cause stacktrace");
+        cex.getCause().printStackTrace();
     }
 
     @Test(timeout = 1000)
@@ -89,8 +129,16 @@ public void testCompositeExceptionFromTwoDuplicateComposites() {
         exs.add(getNewCompositeExceptionWithEx123());
         exs.add(getNewCompositeExceptionWithEx123());
         CompositeException cex = new CompositeException(exs);
-        assertNoCircularReferences(cex);
+        
+        System.err.println("----------------------------- print composite stacktrace");
+        cex.printStackTrace();
         assertEquals(3, cex.getExceptions().size());
+        
+        assertNoCircularReferences(cex);
+        assertNotNull(getRootCause(cex));
+
+        System.err.println("----------------------------- print cause stacktrace");
+        cex.getCause().printStackTrace();
     }
 
     /**
@@ -101,9 +149,22 @@ private static void assertNoCircularReferences(Throwable ex) {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         PrintStream printStream = new PrintStream(baos);
         StringWriter writer = new StringWriter();
+        ex.printStackTrace(printStream);
+        assertFalse(baos.toString().contains("CIRCULAR REFERENCE"));
+    }
 
-        ex.printStackTrace();
-        //ex.printStackTrace(printStream);
-        //assertFalse(baos.toString().contains("CIRCULAR REFERENCE"));
+    private static Throwable getRootCause(Throwable ex) {
+        Throwable root = ex.getCause();
+        if (root == null) {
+            return null;
+        } else {
+            while(true) {
+                if (root.getCause() == null) {
+                    return root;
+                } else {
+                    root = root.getCause();
+                }
+            }
+        }
     }
 }