CompositeException

- reverting to version that just does printStackTrace
- see #1405

Author: abersnaze

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

@@ -15,46 +15,47 @@
  */
 package rx.exceptions;
 
+import java.io.PrintStream;
+import java.io.PrintWriter;
 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;
 
 /**
  * Exception that is a composite of 1 or more other exceptions.
- * <p>
- * Use <code>getMessage()</code> to retrieve a concatenation of the composite exceptions.
+ * A CompositeException does not modify the structure of any exception it wraps, but at print-time
+ * iterates through the list of contained Throwables to print them all.
+ *
+ * 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()}
  */
 public final class CompositeException extends RuntimeException {
 
     private static final long serialVersionUID = 3026362227162912146L;
 
     private final List<Throwable> exceptions;
     private final String message;
-    private final Throwable cause;
 
-    public CompositeException(String messagePrefix, Collection<Throwable> errors) {
+    public CompositeException(String messagePrefix, Collection<? extends Throwable> errors) {
+        Set<Throwable> deDupedExceptions = new LinkedHashSet<Throwable>();
         List<Throwable> _exceptions = new ArrayList<Throwable>();
-        CompositeExceptionCausalChain _cause = new CompositeExceptionCausalChain();
-        int count = errors.size();
-        errors = removeDuplicatedCauses(errors);
-        for (Throwable e : errors) {
-            attachCallingThreadStack(_cause, e);
-            _exceptions.add(e);
+        for (Throwable ex: errors) {
+            if (ex instanceof CompositeException) {
+                deDupedExceptions.addAll(((CompositeException) ex).getExceptions());
+            } else {
+                deDupedExceptions.add(ex);
+            }
         }
+
+        _exceptions.addAll(deDupedExceptions);
         this.exceptions = Collections.unmodifiableList(_exceptions);
-        
-        String msg = count + " exceptions occurred. See them in causal chain below.";
-        if(messagePrefix != null) {
-            msg = messagePrefix + " " + msg;
-        }
-        this.message = msg;
-        this.cause = _cause;
+        this.message = exceptions.size() + " exceptions occurred. See them in causal chain below.";
     }
 
-    public CompositeException(Collection<Throwable> errors) {
+    public CompositeException(Collection<? extends Throwable> errors) {
         this(null, errors);
     }
 
@@ -75,80 +76,106 @@ public String getMessage() {
 
     @Override
     public synchronized Throwable getCause() {
-        return cause;
+        return null;
     }
 
-    private Collection<Throwable> removeDuplicatedCauses(Collection<Throwable> errors) {
-        Set<Throwable> duplicated = new HashSet<Throwable>();
-        for (Throwable cause : errors) {
-            for (Throwable error : errors) {
-                if(cause == error || duplicated.contains(error)) {
-                    continue;
-                }
-                while (error.getCause() != null) {
-                    error = error.getCause();
-                    if (error == cause) {
-                        duplicated.add(cause);
-                        break;
-                    }
-                }
-            }
+    /**
+     * All of the following printStackTrace functionality is derived from JDK Throwable printStackTrace.
+     * In particular, the PrintStreamOrWriter abstraction is copied wholesale.
+     *
+     * Changes from the official JDK implementation:
+     * * No infinite loop detection
+     * * Smaller critical section holding printStream lock
+     * * Explicit knowledge about exceptions List that this loops through
+     */
+    @Override
+    public void printStackTrace() {
+        printStackTrace(System.err);
+    }
+
+    @Override
+    public void printStackTrace(PrintStream s) {
+        printStackTrace(new WrappedPrintStream(s));
+    }
+
+    @Override
+    public void printStackTrace(PrintWriter s) {
+        printStackTrace(new WrappedPrintWriter(s));
+    }
+
+    /**
+     * Special handling for printing out a CompositeException
+     * Loop through all inner exceptions and print them out
+     * @param s stream to print to
+     */
+    private void printStackTrace(PrintStreamOrWriter s) {
+        StringBuilder bldr = new StringBuilder();
+        bldr.append(this).append("\n");
+        for (StackTraceElement myStackElement: getStackTrace()) {
+            bldr.append("\tat ").append(myStackElement).append("\n");
         }
-        if (!duplicated.isEmpty()) {
-            errors = new ArrayList<Throwable>(errors);
-            errors.removeAll(duplicated);
+        int i = 1;
+        for (Throwable ex: exceptions) {
+            bldr.append("  ComposedException ").append(i).append(" :").append("\n");
+            appendStackTrace(bldr, ex, "\t");
+            i++;
+        }
+        synchronized (s.lock()) {
+            s.println(bldr.toString());
         }
-        return errors;
     }
 
-    @SuppressWarnings("unused")
-    // useful when debugging but don't want to make part of publicly supported API
-    private static String getStackTraceAsString(StackTraceElement[] stack) {
-        StringBuilder s = new StringBuilder();
-        boolean firstLine = true;
-        for (StackTraceElement e : stack) {
-            if (e.toString().startsWith("java.lang.Thread.getStackTrace")) {
-                // we'll ignore this one
-                continue;
-            }
-            if (!firstLine) {
-                s.append("\n\t");
-            }
-            s.append(e.toString());
-            firstLine = false;
+    private void appendStackTrace(StringBuilder bldr, Throwable ex, String prefix) {
+        bldr.append(prefix).append(ex).append("\n");
+        for (StackTraceElement stackElement: ex.getStackTrace()) {
+            bldr.append("\t\tat ").append(stackElement).append("\n");
+        }
+        if (ex.getCause() != null) {
+            bldr.append("\tCaused by: ");
+            appendStackTrace(bldr, ex.getCause(), "");
         }
-        return s.toString();
     }
 
-    /* package-private */ static void attachCallingThreadStack(Throwable e, Throwable cause) {
-        Set<Throwable> seenCauses = new HashSet<Throwable>();
+    private abstract static class PrintStreamOrWriter {
+        /** Returns the object to be locked when using this StreamOrWriter */
+        abstract Object lock();
 
-        while (e.getCause() != null) {
-            e = e.getCause();
-            if (seenCauses.contains(e.getCause())) {
-                break;
-            } else {
-                seenCauses.add(e.getCause());
-            }
+        /** Prints the specified string as a line on this StreamOrWriter */
+        abstract void println(Object o);
+    }
+
+    /**
+     * Same abstraction and implementation as in JDK to allow PrintStream and PrintWriter to share implementation
+     */
+    private static class WrappedPrintStream extends PrintStreamOrWriter {
+        private final PrintStream printStream;
+
+        WrappedPrintStream(PrintStream printStream) {
+            this.printStream = printStream;
         }
-        // we now have 'e' as the last in the chain
-        try {
-            e.initCause(cause);
-        } 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
+
+        Object lock() {
+            return printStream;
+        }
+
+        void println(Object o) {
+            printStream.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 =>";
+    private static class WrappedPrintWriter extends PrintStreamOrWriter {
+        private final PrintWriter printWriter;
 
-        @Override
-        public String getMessage() {
-            return MESSAGE;
+        WrappedPrintWriter(PrintWriter printWriter) {
+            this.printWriter = printWriter;
         }
-    }
 
+        Object lock() {
+            return printWriter;
+        }
+
+        void println(Object o) {
+            printWriter.println(o);
+        }
+    }
 }

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

@@ -17,20 +17,22 @@
 
 import static org.junit.Assert.assertEquals;
 
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.io.StringWriter;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
-import org.junit.Test;
-
 public class CompositeExceptionTest {
 
     private final Throwable ex1 = new Throwable("Ex1");
     private final Throwable ex2 = new Throwable("Ex2", ex1);
     private final Throwable ex3 = new Throwable("Ex3", ex2);
 
     public CompositeExceptionTest() {
-        ex1.initCause(ex2);
     }
 
     private CompositeException getNewCompositeExceptionWithEx123() {
@@ -50,56 +52,58 @@ public void testMultipleWithSameCause() {
         CompositeException ce = new CompositeException("3 failures with same root cause", Arrays.asList(e1, e2, e3));
 
         assertEquals(3, ce.getExceptions().size());
-        
+        assertNoCircularReferences(ce);
     }
 
     @Test(timeout = 1000)
-    public void testOneIsCauseOfAnother() {
-        Throwable rootCause = new Throwable("RootCause");
-        Throwable throwable = new Throwable("1", rootCause);
-        CompositeException ce = new CompositeException("One is the cause of another",
-                Arrays.asList(rootCause, throwable));
-
-        assertEquals(1, ce.getExceptions().size());
+    public void testCompositeExceptionFromParentThenChild() {
+        CompositeException cex = new CompositeException(Arrays.asList(ex1, ex2));
+        assertNoCircularReferences(cex);
+        assertEquals(2, cex.getExceptions().size());
     }
 
     @Test(timeout = 1000)
-    public void testAttachCallingThreadStackParentThenChild() {
-        CompositeException.attachCallingThreadStack(ex1, ex2);
-        assertEquals("Ex2", ex1.getCause().getMessage());
+    public void testCompositeExceptionFromChildThenParent() {
+        CompositeException cex = new CompositeException(Arrays.asList(ex2, ex1));
+        assertNoCircularReferences(cex);
+        assertEquals(2, cex.getExceptions().size());
     }
 
     @Test(timeout = 1000)
-    public void testAttachCallingThreadStackChildThenParent() {
-        CompositeException.attachCallingThreadStack(ex2, ex1);
-        assertEquals("Ex1", ex2.getCause().getMessage());
+    public void testCompositeExceptionFromChildAndComposite() {
+        CompositeException cex = new CompositeException(Arrays.asList(ex1, getNewCompositeExceptionWithEx123()));
+        assertNoCircularReferences(cex);
+        assertEquals(3, cex.getExceptions().size());
     }
 
     @Test(timeout = 1000)
-    public void testAttachCallingThreadStackAddComposite() {
-        CompositeException.attachCallingThreadStack(ex1, getNewCompositeExceptionWithEx123());
-        assertEquals("Ex2", ex1.getCause().getMessage());
+    public void testCompositeExceptionFromCompositeAndChild() {
+        CompositeException cex = new CompositeException(Arrays.asList(getNewCompositeExceptionWithEx123(), ex1));
+        assertNoCircularReferences(cex);
+        assertEquals(3, cex.getExceptions().size());
     }
 
     @Test(timeout = 1000)
-    public void testAttachCallingThreadStackAddToComposite() {
-        CompositeException compositeEx = getNewCompositeExceptionWithEx123();
-        CompositeException.attachCallingThreadStack(compositeEx, ex1);
-        assertEquals(CompositeException.CompositeExceptionCausalChain.MESSAGE, compositeEx.getCause().getMessage());
+    public void testCompositeExceptionFromTwoDuplicateComposites() {
+        List<Throwable> exs = new ArrayList<Throwable>();
+        exs.add(getNewCompositeExceptionWithEx123());
+        exs.add(getNewCompositeExceptionWithEx123());
+        CompositeException cex = new CompositeException(exs);
+        assertNoCircularReferences(cex);
+        assertEquals(3, cex.getExceptions().size());
     }
 
-    @Test(timeout = 1000)
-    public void testAttachCallingThreadStackAddCompositeToItself() {
-        CompositeException compositeEx = getNewCompositeExceptionWithEx123();
-        CompositeException.attachCallingThreadStack(compositeEx, compositeEx);
-        assertEquals(CompositeException.CompositeExceptionCausalChain.MESSAGE, compositeEx.getCause().getMessage());
-    }
-
-    @Test(timeout = 1000)
-    public void testAttachCallingThreadStackAddExceptionsToEachOther() {
-        CompositeException.attachCallingThreadStack(ex1, ex2);
-        CompositeException.attachCallingThreadStack(ex2, ex1);
-        assertEquals("Ex2", ex1.getCause().getMessage());
-        assertEquals("Ex1", ex2.getCause().getMessage());
+    /**
+     * This hijacks the Throwable.printStackTrace() output and puts it in a string, where we can look for
+     * "CIRCULAR REFERENCE" (a String added by Throwable.printEnclosedStackTrace)
+     */
+    private static void assertNoCircularReferences(Throwable ex) {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        PrintStream printStream = new PrintStream(baos);
+        StringWriter writer = new StringWriter();
+
+        ex.printStackTrace();
+        //ex.printStackTrace(printStream);
+        //assertFalse(baos.toString().contains("CIRCULAR REFERENCE"));
     }
 }