Fix compatibility issue with AssertJ > 3.9.1

Author: VanRoy

pom.xml

@@ -12,7 +12,6 @@
  */
 package org.assertj.db.api;
 
-import org.assertj.core.internal.Failures;
 import org.assertj.core.util.Lists;
 
 import java.util.List;
@@ -30,31 +29,6 @@ public <T, V> V proxy(Class<V> assertClass, Class<T> actualClass, T actual) {
     return this.proxies.create(assertClass, actualClass, actual);
   }
 
-  public void fail(String failureMessage) {
-    AssertionError error = Failures.instance().failure(failureMessage);
-    this.proxies.collectError(error);
-  }
-
-  public void fail(String failureMessage, Object... args) {
-    AssertionError error = Failures.instance().failure(String.format(failureMessage, args));
-    this.proxies.collectError(error);
-  }
-
-  public void fail(String failureMessage, Throwable realCause) {
-    AssertionError error = Failures.instance().failure(failureMessage);
-    error.initCause(realCause);
-    this.proxies.collectError(error);
-  }
-
-  public void failBecauseExceptionWasNotThrown(Class<? extends Throwable> throwableClass) {
-    this.shouldHaveThrown(throwableClass);
-  }
-
-  public void shouldHaveThrown(Class<? extends Throwable> throwableClass) {
-    AssertionError error = Failures.instance().expectedThrowableNotThrown(throwableClass);
-    this.proxies.collectError(error);
-  }
-
   public List<Throwable> errorsCollected() {
     return Lists.newArrayList(this.proxies.errorsCollected());
   }

src/main/java/org/assertj/db/api/AbstractSoftAssertions.java

@@ -0,0 +1,115 @@
+/**
+ * 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.
+ *
+ * Copyright 2012-2016 the original author or authors.
+ */
+package org.assertj.db.api;
+
+import net.sf.cglib.proxy.MethodInterceptor;
+import net.sf.cglib.proxy.MethodProxy;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/** Collects error messages of all AssertionErrors thrown by the proxied method. */
+class ErrorCollector implements MethodInterceptor {
+
+  private static final String INTERCEPT_METHOD_NAME = "intercept";
+
+  private static final String CLASS_NAME = ErrorCollector.class.getName();
+
+  // scope : the current soft-assertion object
+  private final List<Throwable> errors = new ArrayList<>();
+  // scope : the last assertion call (might be nested)
+  private final LastResult lastResult = new LastResult();
+
+  @Override
+  public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
+    Object result = obj;
+    try {
+      result = proxy.invokeSuper(obj, args);
+      lastResult.setSuccess(true);
+    } catch (AssertionError e) {
+      if (isNestedErrorCollectorProxyCall()) {
+        // let the most outer call handle the assertion error
+        throw e;
+      }
+      addError(e);
+    }
+    return result;
+  }
+
+  public void addError(Throwable error) {
+    errors.add(error);
+    lastResult.recordError();
+  }
+
+  public List<Throwable> errors() {
+    return Collections.unmodifiableList(errors);
+  }
+
+  public boolean wasSuccess() {
+    return lastResult.wasSuccess();
+  }
+
+  private boolean isNestedErrorCollectorProxyCall() {
+    return countErrorCollectorProxyCalls() > 1;
+  }
+
+  private static int countErrorCollectorProxyCalls() {
+    int nbCalls = 0;
+    for (StackTraceElement stackTraceElement : Thread.currentThread().getStackTrace()) {
+      if (CLASS_NAME.equals(stackTraceElement.getClassName())
+          && INTERCEPT_METHOD_NAME.equals(stackTraceElement.getMethodName()))
+        nbCalls++;
+    }
+    return nbCalls;
+  }
+
+  private static class LastResult {
+    private boolean wasSuccess = true;
+    private boolean errorFound = false;
+
+    private boolean wasSuccess() {
+      return wasSuccess;
+    }
+
+    private void recordError() {
+      errorFound = true;
+      wasSuccess = false;
+    }
+
+    private void setSuccess(boolean success) {
+
+      // errorFound must be true if any nested call ends up in error
+      // Nested call Example : softly.assertThat(true).isFalse()
+      // call chain :
+      // -- softly.assertThat(true).isFalse()
+      // ----- proxied isFalse() -> calls isEqualTo(false) which is proxied
+      // ------- proxied isEqualTo(false) : catch AssertionError => last result success = false, back to outer call
+      // ---- proxied isFalse() : no AssertionError caught => last result success = true
+      // The overall last result success should not be true as one of the nested calls was not a success.
+      errorFound |= !success;
+
+      if (resolvingOutermostErrorCollectorProxyNestedCall()) {
+        // we are resolving the last nested call (if any), we can set a relevant value for wasSuccess
+        wasSuccess = !errorFound;
+        // need to reset errorFound for the next soft assertion
+        errorFound = false;
+      }
+    }
+
+    private boolean resolvingOutermostErrorCollectorProxyNestedCall() {
+      return countErrorCollectorProxyCalls() == 1;
+    }
+  }
+}

src/main/java/org/assertj/db/api/ErrorCollector.java

@@ -12,19 +12,15 @@
  */
 package org.assertj.db.api;
 
-import org.assertj.core.api.ObjectArrayAssert;
-import org.assertj.core.internal.cglib.proxy.MethodInterceptor;
-import org.assertj.core.internal.cglib.proxy.MethodProxy;
+import net.sf.cglib.proxy.MethodInterceptor;
+import net.sf.cglib.proxy.MethodProxy;
 import org.assertj.core.util.Arrays;
 import org.assertj.db.type.Change;
 import org.assertj.db.type.Column;
 import org.assertj.db.type.Row;
 import org.assertj.db.type.Value;
 
-import java.lang.reflect.Array;
 import java.lang.reflect.Method;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
 
 import static org.assertj.db.util.Proxies.isProxified;
 import static org.assertj.db.util.Proxies.unProxy;
@@ -44,7 +40,7 @@ class ProxifyPositionResult implements MethodInterceptor {
 
   public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
     Object result = proxy.invokeSuper(obj, args);
-    if (isProxified(result.getClass()) || actual(result) == null) {
+    if (isProxified(result.getClass()) || Arrays.isNullOrEmpty(actual(result))) {
       return result;
     }
     return this.proxies.create(result.getClass(), actualClass(result), actual(result));
@@ -79,14 +75,8 @@ private static Class[] actualClass(Object result) {
           Value.class,
           Value.class
       );
-    } else if (result instanceof ObjectArrayAssert) {
-      return Arrays.array(Array.newInstance(Object.class, 0).getClass());
     } else {
-      Type actualType = ((ParameterizedType) result.getClass().getGenericSuperclass()).getActualTypeArguments()[1];
-      Class type = actualType instanceof ParameterizedType ?
-          (Class) ((ParameterizedType) actualType).getRawType() :
-          (Class) actualType;
-      return Arrays.array(type);
+      return Arrays.array();
     }
   }
 
@@ -119,7 +109,7 @@ private static Object[] actual(Object result) {
           ((ChangeColumnAssert) result).valueAtEndPoint
       );
     } else {
-      return null;
+      return Arrays.array();
     }
   }
 }

src/main/java/org/assertj/db/api/ProxifyPositionResult.java

@@ -12,10 +12,9 @@
  */
 package org.assertj.db.api;
 
-import org.assertj.core.api.ErrorCollector;
-import org.assertj.core.internal.cglib.proxy.Callback;
-import org.assertj.core.internal.cglib.proxy.CallbackFilter;
-import org.assertj.core.internal.cglib.proxy.Enhancer;
+import net.sf.cglib.proxy.Callback;
+import net.sf.cglib.proxy.CallbackFilter;
+import net.sf.cglib.proxy.Enhancer;
 import org.assertj.core.util.Arrays;
 
 import java.lang.reflect.Method;
@@ -32,10 +31,6 @@ class SoftProxies {
   SoftProxies() {
   }
 
-  void collectError(Throwable error) {
-    this.collector.addError(error);
-  }
-
   List<Throwable> errorsCollected() {
     return this.collector.errors();
   }

src/main/java/org/assertj/db/api/SoftProxies.java

@@ -12,7 +12,7 @@
  */
 package org.assertj.db.util;
 
-import org.assertj.core.internal.cglib.proxy.Enhancer;
+import net.sf.cglib.proxy.Enhancer;
 
 /**
  * Utilities for manage proxies.

src/main/java/org/assertj/db/util/Proxies.java

@@ -51,6 +51,7 @@ public void test_soft_assert_table() {
           .returnToColumn()
           .column("var1").value().isEqualTo(0);
 
+    assertThat(softly.wasSuccess()).isFalse();
     assertThat(softly.errorsCollected()).hasSize(8);
 
     assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
@@ -79,6 +80,7 @@ public void test_soft_assert_request() {
           .returnToColumn()
           .column("var1").value().isEqualTo(0);
 
+    assertThat(softly.wasSuccess()).isFalse();
     assertThat(softly.errorsCollected()).hasSize(8);
 
     assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
@@ -102,6 +104,8 @@ public void test_soft_assert_changes() {
     final SoftAssertions softly = new SoftAssertions();
     softly.assertThat(changes).change().column("var1").hasValues(0);
     softly.assertThat(changes).change().rowAtStartPoint().changeOfModification().column("var1").hasValues(0);
+
+    assertThat(softly.wasSuccess()).isFalse();
     assertThat(softly.errorsCollected()).hasSize(2);
 
     assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {

src/test/java/org/assertj/db/api/SoftAssertions_Test.java

@@ -12,8 +12,8 @@
  */
 package org.assertj.db.util;
 
-import org.assertj.core.internal.cglib.proxy.Enhancer;
-import org.assertj.core.internal.cglib.proxy.NoOp;
+import net.sf.cglib.proxy.Enhancer;
+import net.sf.cglib.proxy.NoOp;
 import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;