feat(softassert): back SoftAssert with AssertJ SoftAssertions

Replace the hand-rolled failure collection in org.testng.asserts.SoftAssert
with AssertJ's SoftAssertions engine. assertAll() now aggregates failures
using AssertJ's native "Multiple Failures" report; a custom assertAll(String)
message is kept as a prefix, and each individual failure (with its root cause)
is attached as a suppressed exception so error details remain visible.

Add org.opentest4j:opentest4j as a runtime dependency (AssertJ only declares
it as provided) so failures are aggregated as an AssertJMultipleFailuresError.

Part of #15

Author: juherr

CHANGELOG.md

@@ -19,6 +19,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `Assert.assertEquals(String, String, String)` now delegates to AssertJ, producing a readable
   character-level diff on mismatch. The failure message format changes accordingly
   ([#18](https://github.com/testng-team/testng-asserts/issues/18)).
+- `SoftAssert` is now backed by AssertJ's `SoftAssertions`: collected failures are aggregated with
+  AssertJ's native "Multiple Failures" report instead of the previous
+  `"The following asserts failed:"` format. A custom `assertAll(String)` message is kept as a
+  prefix, and each individual failure (with its root cause) is attached as a suppressed exception.
+  This adds `org.opentest4j:opentest4j` as a runtime dependency (AssertJ only declares it as
+  `provided`).
 
 ### Fixed
 

pom.xml

@@ -63,8 +63,12 @@
 
     <dependencies>
         <!--
-          AssertJ is the only runtime dependency: org.testng.Assert delegates the
-          behaviour-identical assertions (assertNull/NotNull/Same/NotSame, assertThrows) to it.
+          AssertJ is the main runtime dependency: org.testng.Assert delegates the
+          behaviour-identical assertions (assertNull/NotNull/Same/NotSame, assertThrows) to it,
+          and org.testng.asserts.SoftAssert is backed by AssertJ's SoftAssertions.
+          opentest4j is required at runtime so AssertJ aggregates soft-assertion failures as an
+          AssertJMultipleFailuresError, which keeps each failure (and its root cause) as a
+          suppressed exception. AssertJ only declares it as "provided", so we promote it here.
           TestNG is required at test scope only, to run the assertion tests
           (annotations, runner) and for the collection helpers used by the tests.
         -->
@@ -73,6 +77,11 @@
             <artifactId>assertj-core</artifactId>
             <version>3.27.7</version>
         </dependency>
+        <dependency>
+            <groupId>org.opentest4j</groupId>
+            <artifactId>opentest4j</artifactId>
+            <version>1.3.0</version>
+        </dependency>
         <dependency>
             <groupId>org.testng</groupId>
             <artifactId>testng</artifactId>

src/main/java/org/testng/asserts/SoftAssert.java

@@ -1,16 +1,17 @@
 package org.testng.asserts;
 
-import java.util.LinkedHashMap;
-import java.util.Map;
+import org.assertj.core.api.SoftAssertions;
+import org.opentest4j.MultipleFailuresError;
 
 /**
  * When an assertion fails, don't throw an exception but record the failure. Calling {@code
  * assertAll()} will cause an exception to be thrown if at least one assertion failed.
+ *
+ * <p>Failures are collected and aggregated by AssertJ's {@link SoftAssertions}, so {@code
+ * assertAll()} reports them using AssertJ's native multiple-failures format.
  */
 public class SoftAssert extends Assertion {
-  // LinkedHashMap to preserve the order
-  private final Map<AssertionError, IAssert<?>> m_errors = new LinkedHashMap<>();
-  private static final String DEFAULT_SOFT_ASSERT_MESSAGE = "The following asserts failed:";
+  private final SoftAssertions softly = new SoftAssertions();
 
   @Override
   protected void doAssert(IAssert<?> a) {
@@ -20,7 +21,7 @@ protected void doAssert(IAssert<?> a) {
       onAssertSuccess(a);
     } catch (AssertionError ex) {
       onAssertFailure(a, ex);
-      m_errors.put(ex, a);
+      softly.collectAssertionError(ex);
     } finally {
       onAfterAssert(a);
     }
@@ -31,19 +32,21 @@ public void assertAll() {
   }
 
   public void assertAll(String message) {
-    if (!m_errors.isEmpty()) {
-      StringBuilder sb = new StringBuilder(null == message ? DEFAULT_SOFT_ASSERT_MESSAGE : message);
-      boolean first = true;
-      for (AssertionError error : m_errors.keySet()) {
-        if (first) {
-          first = false;
-        } else {
-          sb.append(",");
+    try {
+      softly.assertAll();
+    } catch (AssertionError e) {
+      // AssertJ keeps each failure in MultipleFailuresError#getFailures() but does not wire them
+      // into the stack trace. Expose them (and their root causes) as suppressed exceptions so the
+      // underlying failure details are still surfaced by standard tooling (see GITHUB-1778).
+      if (e instanceof MultipleFailuresError) {
+        for (Throwable failure : ((MultipleFailuresError) e).getFailures()) {
+          e.addSuppressed(failure);
         }
-        sb.append("\n\t");
-        sb.append(getErrorDetails(error));
       }
-      throw new AssertionError(sb.toString());
+      if (message == null) {
+        throw e;
+      }
+      throw new AssertionError(message + System.lineSeparator() + e.getMessage(), e);
     }
   }
 }

src/test/java/test/assertion/SoftAssertTest.java

@@ -36,20 +36,25 @@ public void onAssertFailure(IAssert assertCommand, AssertionError ex) {
 
   @DataProvider(name = "messages")
   public Object[][] getMessages() {
-    String hasMessage = "msg";
-    return new Object[][] {{hasMessage, hasMessage}, {null, "The following asserts failed:"}};
+    // A custom message is used as a prefix; a null message falls back to AssertJ's native
+    // "Multiple Failures" aggregated report.
+    return new Object[][] {{"msg", "msg"}, {null, "Multiple Failures"}};
   }
 
   @Test(dataProvider = "messages")
-  public void testDefaultMessage(String actualMsg, String expectedMsg) {
+  public void testDefaultMessage(String actualMsg, String expectedToken) {
     try {
       final SoftAssert sa = new SoftAssert();
       sa.assertTrue(false);
       sa.assertAll(actualMsg);
       Assert.fail();
     } catch (AssertionError exc) {
       Assert.assertNotNull(exc.getMessage());
-      Assert.assertTrue(exc.getMessage().startsWith(expectedMsg));
+      Assert.assertTrue(exc.getMessage().contains(expectedToken), exc.getMessage());
+      if (actualMsg != null) {
+        // A custom message is reported as a prefix of the aggregated failure report.
+        Assert.assertTrue(exc.getMessage().startsWith(actualMsg), exc.getMessage());
+      }
     }
   }