feat(assert): array-delta assertNotEquals + collection/string fixes

- Add assertNotEquals(float[]/double[], delta) overloads (with and without a
  message), the missing counterparts of the existing assertEquals(...delta)
  array assertions.
- Fix assertNotEquals(Collection, Collection) to be the exact inverse of
  assertEquals(Collection, Collection): compare by size and element order
  instead of relying on the collections' own equals(), so a List and a Set
  with the same ordered content are no longer reported as both equal and
  not-equal.
- Delegate assertEquals(String, String, String) to AssertJ, producing a
  readable character-level diff on mismatch. The failure message format
  changes accordingly.
- Add regression tests documenting that assertThrows/expectThrows already
  cover the requested exception assertion (#8) and that assertSame now yields
  an explicit identity-vs-equality message via AssertJ (#10).

fix #11
fix #14
fix #18

Author: juherr

CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- `Assert.assertNotEquals(float[], float[], delta)` and
+  `Assert.assertNotEquals(double[], double[], delta)` overloads (with and without a message),
+  the missing counterparts of the existing `assertEquals(...delta)` array assertions
+  ([#11](https://github.com/testng-team/testng-asserts/issues/11)).
+
+### Changed
+
+- `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)).
+
+### Fixed
+
+- `Assert.assertNotEquals(Collection, Collection)` is now the exact inverse of
+  `assertEquals(Collection, Collection)`: it compares by size and element order instead of relying
+  on the collections' `equals()`, so a `List` and a `Set` with the same ordered content are no
+  longer reported as both equal and not-equal
+  ([#14](https://github.com/testng-team/testng-asserts/issues/14)).
+
 ## [1.0.0]
 
 First standalone release of `org.testng:testng-asserts`.

src/main/java/org/testng/Assert.java

@@ -670,7 +670,8 @@ public static void assertEquals(Object actual, Object expected) {
    * @param message the assertion error message
    */
   public static void assertEquals(String actual, String expected, String message) {
-    assertEquals((Object) actual, (Object) expected, message);
+    // Delegated to AssertJ to produce a readable character-level diff on mismatch (GITHUB-18).
+    assertThat(actual).as(message).isEqualTo(expected);
   }
 
   /**
@@ -1972,8 +1973,10 @@ private static String getNotEqualReason(Collection<?> actual, Collection<?> expe
       return "Collections not equal: expected: " + expected + " and actual: " + actual;
     }
 
-    if (!Objects.equals(actual, expected)) {
-      return "Collections differ: expected " + expected + " but got " + actual;
+    // Mirror assertEquals(Collection): compare by size + element order so that assertNotEquals is
+    // the exact inverse of assertEquals, regardless of the collections' own equals() (GITHUB-14).
+    if (actual.size() != expected.size()) {
+      return "Collections differ in size: expected " + expected + " but got " + actual;
     }
 
     return getNotEqualReason(actual.iterator(), expected.iterator());
@@ -2304,6 +2307,92 @@ public static void assertNotEquals(double actual, double expected, double delta,
     }
   }
 
+  /**
+   * Asserts that two float arrays are not equal within the given delta. If they are equal, an
+   * AssertionError is thrown.
+   *
+   * @param actual the actual value
+   * @param expected the expected value
+   * @param delta the absolute tolerable difference between the actual and expected values
+   */
+  public static void assertNotEquals(float[] actual, float[] expected, float delta) {
+    assertNotEquals(actual, expected, delta, null);
+  }
+
+  /**
+   * Asserts that two float arrays are not equal within the given delta. If they are equal, an
+   * AssertionError, with the given message, is thrown.
+   *
+   * @param actual the actual value
+   * @param expected the expected value
+   * @param delta the absolute tolerable difference between the actual and expected values
+   * @param message the assertion error message
+   */
+  public static void assertNotEquals(
+      float[] actual, float[] expected, float delta, String message) {
+    if (areEqual(actual, expected, delta)) {
+      Assert.fail(format(actual, expected, message, false));
+    }
+  }
+
+  private static boolean areEqual(float[] actual, float[] expected, float delta) {
+    if (actual == expected) {
+      return true;
+    }
+    if (actual == null || expected == null || actual.length != expected.length) {
+      return false;
+    }
+    for (int i = 0; i < expected.length; i++) {
+      if (!areEqual(actual[i], expected[i], delta)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Asserts that two double arrays are not equal within the given delta. If they are equal, an
+   * AssertionError is thrown.
+   *
+   * @param actual the actual value
+   * @param expected the expected value
+   * @param delta the absolute tolerable difference between the actual and expected values
+   */
+  public static void assertNotEquals(double[] actual, double[] expected, double delta) {
+    assertNotEquals(actual, expected, delta, null);
+  }
+
+  /**
+   * Asserts that two double arrays are not equal within the given delta. If they are equal, an
+   * AssertionError, with the given message, is thrown.
+   *
+   * @param actual the actual value
+   * @param expected the expected value
+   * @param delta the absolute tolerable difference between the actual and expected values
+   * @param message the assertion error message
+   */
+  public static void assertNotEquals(
+      double[] actual, double[] expected, double delta, String message) {
+    if (areEqual(actual, expected, delta)) {
+      Assert.fail(format(actual, expected, message, false));
+    }
+  }
+
+  private static boolean areEqual(double[] actual, double[] expected, double delta) {
+    if (actual == expected) {
+      return true;
+    }
+    if (actual == null || expected == null || actual.length != expected.length) {
+      return false;
+    }
+    for (int i = 0; i < expected.length; i++) {
+      if (!areEqual(actual[i], expected[i], delta)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   public static void assertNotEquals(Set<?> actual, Set<?> expected) {
     assertNotEquals(actual, expected, null);
   }

src/test/java/org/testng/AssertTest.java

@@ -349,9 +349,10 @@ public void testAssertEqualsWithNull() {
   }
 
   @Test(
-      description = "GITHUB-1935",
+      description = "GITHUB-1935, GITHUB-18",
       expectedExceptions = AssertionError.class,
-      expectedExceptionsMessageRegExp = "expected \\[y\\] but found \\[x\\]")
+      // String equality now delegates to AssertJ, which produces a readable diff (GITHUB-18).
+      expectedExceptionsMessageRegExp = "[\\s\\S]*expected: \"y\"[\\s\\S]*but was: \"x\"[\\s\\S]*")
   public void testInequalityMessage() {
     Assert.assertEquals("x", "y");
   }

src/test/java/test/asserttests/AssertTest.java

@@ -640,4 +640,79 @@ protected void assertMapsNotEqual(Map m1, Map m2) {
     assertNotEquals((Object) m1, (Object) m2);
     assertNotEquals(m1, m2);
   }
+
+  @Test(
+      description = "GITHUB-11",
+      expectedExceptions = AssertionError.class)
+  public void assertNotEqualsFloatArrayWithinDeltaFails() {
+    assertNotEquals(new float[] {1.0f, 2.0f}, new float[] {1.05f, 2.0f}, 0.1f);
+  }
+
+  @Test(description = "GITHUB-11")
+  public void assertNotEqualsFloatArrayOutsideDeltaPasses() {
+    assertNotEquals(new float[] {1.0f, 2.0f}, new float[] {1.5f, 2.0f}, 0.1f);
+  }
+
+  @Test(description = "GITHUB-11")
+  public void assertNotEqualsFloatArrayDifferentLengthPasses() {
+    assertNotEquals(new float[] {1.0f}, new float[] {1.0f, 2.0f}, 0.1f);
+  }
+
+  @Test(
+      description = "GITHUB-11",
+      expectedExceptions = AssertionError.class)
+  public void assertNotEqualsDoubleArrayWithinDeltaFails() {
+    assertNotEquals(new double[] {1.0, 2.0}, new double[] {1.05, 2.0}, 0.1);
+  }
+
+  @Test(description = "GITHUB-11")
+  public void assertNotEqualsDoubleArrayOutsideDeltaPasses() {
+    assertNotEquals(new double[] {1.0, 2.0}, new double[] {1.5, 2.0}, 0.1);
+  }
+
+  @Test(description = "GITHUB-14")
+  public void assertNotEqualsListVsSetSameContentFails() {
+    Collection<String> list = List.of("a", "b", "c");
+    Collection<String> set = new LinkedHashSet<>(list);
+    // assertEquals passes for these (same size + order); a failure here is a real regression, not
+    // swallowed by the expected AssertionError of the assertNotEquals under test.
+    assertEquals(list, set);
+    // assertNotEquals must be the exact inverse of assertEquals, so it must throw here.
+    assertThrows(AssertionError.class, () -> assertNotEquals(list, set));
+  }
+
+  @Test(description = "GITHUB-18")
+  public void assertEqualsStringShowsDiff() {
+    try {
+      assertEquals("Root", "Not Root", "Transform JSON");
+      fail("should have thrown");
+    } catch (AssertionError e) {
+      assertTrue(e.getMessage().contains("Transform JSON"), e.getMessage());
+      assertTrue(e.getMessage().contains("Not Root"), e.getMessage());
+    }
+  }
+
+  @Test(description = "GITHUB-8")
+  public void assertThrowsCoversAssertException() {
+    assertThrows(NullPointerException.class, () -> {
+      throw new NullPointerException();
+    });
+    IllegalStateException ex =
+        expectThrows(
+            IllegalStateException.class,
+            () -> {
+              throw new IllegalStateException("boom");
+            });
+    assertEquals(ex.getMessage(), "boom");
+  }
+
+  @Test(description = "GITHUB-10")
+  public void assertSameMessageIsExplicit() {
+    try {
+      assertSame(new String("foo"), "foo");
+      fail("should have thrown");
+    } catch (AssertionError e) {
+      assertTrue(e.getMessage().contains("same"), e.getMessage());
+    }
+  }
 }