1.x: Fix Completable using JDK 7 suppressed exceptions feature

Author: akarnokd

src/main/java/rx/Completable.java

@@ -938,8 +938,7 @@ public void onError(Throwable e) {
                                 try {
                                     disposer.call(resource);
                                 } catch (Throwable ex) {
-                                    ex.addSuppressed(e);
-                                    e = ex;
+                                    e = new CompositeException(Arrays.asList(e, ex));
                                 }
                             }
                         }
@@ -1298,8 +1297,7 @@ public void onError(Throwable e) {
                         try {
                             onError.call(e);
                         } catch (Throwable ex) {
-                            ex.addSuppressed(e);
-                            e = ex;
+                            e = new CompositeException(Arrays.asList(e, ex));
                         }
 
                         s.onError(e);
@@ -1619,8 +1617,7 @@ public void onError(Throwable e) {
                         try {
                             b = predicate.call(e);
                         } catch (Throwable ex) {
-                            e.addSuppressed(ex);
-                            s.onError(e);
+                            e = new CompositeException(Arrays.asList(e, ex));
                             return;
                         }
 
@@ -1669,15 +1666,15 @@ public void onError(Throwable e) {
                         try {
                             c = errorMapper.call(e);
                         } catch (Throwable ex) {
-                            ex.addSuppressed(e);
-                            s.onError(ex);
+                            e = new CompositeException(Arrays.asList(e, ex));
+                            s.onError(e);
                             return;
                         }
 
                         if (c == null) {
                             NullPointerException npe = new NullPointerException("The completable returned is null");
-                            npe.addSuppressed(e);
-                            s.onError(npe);
+                            e = new CompositeException(Arrays.asList(e, npe));
+                            s.onError(e);
                             return;
                         }
 
@@ -1900,7 +1897,7 @@ public void onError(Throwable e) {
                 try {
                     onError.call(e);
                 } catch (Throwable ex) {
-                    e.addSuppressed(ex);
+                    e = new CompositeException(Arrays.asList(e, ex));
                     ERROR_HANDLER.handleError(e);
                 }
             }

src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java

@@ -16,12 +16,14 @@
 
 package rx.internal.operators;
 
-import java.util.Queue;
+import java.util.*;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.*;
 
 import rx.*;
 import rx.Completable.*;
+import rx.exceptions.CompositeException;
+import rx.Observable;
 import rx.plugins.RxJavaPlugins;
 import rx.subscriptions.CompositeSubscription;
 
@@ -197,19 +199,18 @@ void terminate() {
      * @return the Throwable containing all other Throwables as suppressed
      */
     public static Throwable collectErrors(Queue<Throwable> q) {
-        Throwable ex = null;
+        List<Throwable> list = new ArrayList<Throwable>();
 
         Throwable t;
-        int count = 0;
         while ((t = q.poll()) != null) {
-            if (count == 0) {
-                ex = t;
-            } else {
-                ex.addSuppressed(t);
-            }
-            
-            count++;
+            list.add(t);
+        }
+        if (list.isEmpty()) {
+            return null;
+        }
+        if (list.size() == 1) {
+            return list.get(0);
         }
-        return ex;
+        return new CompositeException(list);
     }
 }

src/test/java/rx/CompletableTest.java

@@ -1872,10 +1872,11 @@ public void doOnErrorThrows() {
 
         try {
             c.await();
-        } catch (IllegalStateException ex) {
-            Throwable[] a = ex.getSuppressed();
-            Assert.assertEquals(1, a.length);
-            Assert.assertTrue(a[0] instanceof TestException);
+        } catch (CompositeException ex) {
+            List<Throwable> a = ex.getExceptions();
+            Assert.assertEquals(2, a.size());
+            Assert.assertTrue(a.get(0) instanceof TestException);
+            Assert.assertTrue(a.get(1) instanceof IllegalStateException);
         }
     }
 
@@ -2217,11 +2218,11 @@ public Completable call(Throwable e) {
         try {
             c.await();
             Assert.fail("Did not throw an exception");
-        } catch (NullPointerException ex) {
-            Throwable[] a = ex.getSuppressed();
-                    
-            Assert.assertEquals(1, a.length);
-            Assert.assertTrue(a[0] instanceof TestException);
+        } catch (CompositeException ex) {
+            List<Throwable> a = ex.getExceptions();
+            Assert.assertEquals(2, a.size());
+            Assert.assertTrue(a.get(0) instanceof TestException);
+            Assert.assertTrue(a.get(1) instanceof NullPointerException);
         }
     }
 
@@ -2235,11 +2236,11 @@ public void onErrorResumeNextFunctionThrows() {
         try {
             c.await();
             Assert.fail("Did not throw an exception");
-        } catch (TestException ex) {
-            Throwable[] a = ex.getSuppressed();
-                    
-            Assert.assertEquals(1, a.length);
-            Assert.assertTrue(a[0] instanceof TestException);
+        } catch (CompositeException ex) {
+            List<Throwable> a = ex.getExceptions();
+            Assert.assertEquals(2, a.size());
+            Assert.assertTrue(a.get(0) instanceof TestException);
+            Assert.assertTrue(a.get(1) instanceof TestException);
         }
     }