Changing the approach

Let the exception be suppressed, but removing the cause of the suppressed exception by create a new one.

Author: bigmontz

driver/src/main/java/org/neo4j/driver/internal/util/Exceptions.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * 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 org.neo4j.driver.internal.util;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Optional;
+import java.util.function.Function;
+
+public class Exceptions
+{
+    public static Optional<Throwable> copyWithoutCause (Throwable ex) {
+        return getConstructor(ex.getClass(), String.class)
+                .flatMap( copy( ex ) );
+    }
+
+    private static Optional<Constructor<? extends Throwable>> getConstructor (Class<? extends Throwable> clazz, Class<?> ... paramTypes)
+    {
+        try
+        {
+            return Optional.of( clazz.getConstructor( paramTypes ) );
+        }
+        catch ( NoSuchMethodException ignored )
+        {
+            return Optional.empty();
+        }
+    }
+
+    private static Function<Constructor<? extends Throwable>, Optional<Throwable>> copy(Throwable ex) {
+        return constructor ->
+        {
+            try
+            {
+              Throwable result = constructor.newInstance( ex.getMessage() );
+              result.setStackTrace( ex.getStackTrace() );
+              for (Throwable suppressed: ex.getSuppressed()) {
+                  result.addSuppressed( suppressed );
+              }
+              return Optional.of( result );
+            }
+            catch ( IllegalAccessException | InstantiationException | InvocationTargetException ignore )
+            {
+                return Optional.empty();
+            }
+        };
+    }
+
+}

driver/src/main/java/org/neo4j/driver/internal/util/Futures.java

@@ -205,11 +205,16 @@ public static CompletionException combineErrors( Throwable error1, Throwable err
         {
             Throwable cause1 = completionExceptionCause( error1 );
             Throwable cause2 = completionExceptionCause( error2 );
-            if (cause1 != cause2.getCause() && cause1.getCause() != cause2) {
+            if ( cause1.getCause() != cause2 )
+            {
+                if ( cause1 == cause2.getCause() )
+                {
+                    cause2 = Exceptions.copyWithoutCause( cause2 )
+                                       .orElse( cause2 );
+                }
                 addSuppressed( cause1, cause2 );
-            } else if (cause1 == cause2.getCause()) {
-                return asCompletionException( cause2 );
             }
+
             return asCompletionException( cause1 );
         }
         else if ( error1 != null )

driver/src/test/java/org/neo4j/driver/internal/util/FuturesTest.java

@@ -45,6 +45,7 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.neo4j.driver.internal.util.Matchers.blockingOperationInEventLoopError;
@@ -315,18 +316,24 @@ void shouldCombineTwoErrors()
     }
 
     @Test
-    void shouldCombineTwoErrorsUsingErrorCause2()
+    void shouldCombineTwoErrorsUsingErrorCause1()
     {
         RuntimeException error1 = new RuntimeException( "Error1" );
         RuntimeException error2Cause = new RuntimeException( "Error2", error1 );
         CompletionException error2 = new CompletionException( error2Cause );
 
         CompletionException combined = Futures.combineErrors( error1, error2 );
 
-        assertEquals( error2Cause, combined.getCause() );
+        assertEquals( error1, combined.getCause() );
 
         assertNoCircularReferences( combined );
-        assertArrayEquals( new Throwable[]{}, combined.getCause().getSuppressed() );
+
+        assertEquals(1 , combined.getCause().getSuppressed().length );
+        Throwable suppressed = combined.getCause().getSuppressed()[0];
+        assertEquals( error2Cause.getClass(), suppressed.getClass());
+        assertEquals( error2Cause.getMessage(), suppressed.getMessage() );
+        assertArrayEquals( error2Cause.getStackTrace(), suppressed.getStackTrace() );
+        assertArrayEquals( error2Cause.getSuppressed(), suppressed.getSuppressed() );
     }
 
     @Test
@@ -338,10 +345,9 @@ void shouldCombineTwoErrorsUsingError1()
 
         CompletionException combined = Futures.combineErrors( error1, error2 );
 
-        assertEquals( error1, combined.getCause() );
+        assertSame( error1, combined.getCause() );
 
         assertNoCircularReferences( combined );
-        assertArrayEquals( new Throwable[]{}, combined.getCause().getSuppressed() );
     }
 
 

driver/src/test/java/org/neo4j/driver/util/TestUtil.java

@@ -654,28 +654,36 @@ private static void assertNoCircularReferences(Throwable ex, List<Throwable> lis
     {
         list.add( ex );
         if (ex.getCause() != null ) {
-            if (list.contains( ex.getCause() )) {
-                throw new AssertionError("Circular reference detected", ex.getCause());
+            if ( containsReference( list, ex.getCause() ) )
+            {
+                throw new AssertionError( "Circular reference detected", ex.getCause() );
             }
-            assertNoCircularReferences(ex.getCause(), list);
+            assertNoCircularReferences( ex.getCause(), list );
         }
-        for ( Throwable suppressed: ex.getSuppressed()  )
+        for ( Throwable suppressed : ex.getSuppressed() )
         {
-            if(list.contains( suppressed )) {
-                throw new AssertionError("Circular reference detected", suppressed);
+            if ( containsReference( list, suppressed ) )
+            {
+                throw new AssertionError( "Circular reference detected", suppressed );
             }
             assertNoCircularReferences( suppressed, list );
         }
     }
 
+    private static <T> boolean containsReference( List<T> list, T object )
+    {
+        return list.stream()
+                   .anyMatch( element -> element == object );
+    }
+
     private static void setupSuccessfulPullAll( Connection connection, String query )
     {
         doAnswer( invocation ->
-        {
-            ResponseHandler handler = invocation.getArgument( 3 );
-            handler.onSuccess( emptyMap() );
-            return null;
-        } ).when( connection ).writeAndFlush( argThat( runMessageWithQueryMatcher( query ) ), any(), any(), any() );
+                  {
+                      ResponseHandler handler = invocation.getArgument( 3 );
+                      handler.onSuccess( emptyMap() );
+                      return null;
+                  } ).when( connection ).writeAndFlush( argThat( runMessageWithQueryMatcher( query ) ), any(), any(), any() );
     }
 
     private static void setupSuccessResponse( Connection connection, Class<? extends Message> messageType )