refactor: implement boolean assertions directly in AbstractBooleanAss…

…ert and remove Booleans internal class (cherry picked from commit 35e85a2)
assertj · May 5, 2024 · 714c136 · 714c136
1 parent c960fe8
commit 714c136
Show file tree

Hide file tree

Showing 11 changed files with 108 additions and 381 deletions.
diff --git a/assertj-core/src/main/java/org/assertj/core/api/AbstractBooleanAssert.java b/assertj-core/src/main/java/org/assertj/core/api/AbstractBooleanAssert.java
@@ -12,14 +12,14 @@
  */
 package org.assertj.core.api;
 
+import static org.assertj.core.error.ShouldBeEqual.shouldBeEqual;
 import static org.assertj.core.error.ShouldBeFalse.shouldBeFalse;
 import static org.assertj.core.error.ShouldBeTrue.shouldBeTrue;
+import static org.assertj.core.error.ShouldNotBeEqual.shouldNotBeEqual;
 
 import java.util.Comparator;
 
-import org.assertj.core.internal.Booleans;
 import org.assertj.core.internal.Failures;
-import org.assertj.core.util.VisibleForTesting;
 
 /**
  * Base class for all implementations of assertions for {@link Boolean}s.
@@ -36,9 +36,6 @@
  */
 public abstract class AbstractBooleanAssert<SELF extends AbstractBooleanAssert<SELF>> extends AbstractAssert<SELF, Boolean> {
 
-  @VisibleForTesting
-  Booleans booleans = Booleans.instance();
-
   protected AbstractBooleanAssert(Boolean actual, Class<?> selfType) {
     super(actual, selfType);
   }
@@ -47,11 +44,11 @@ protected AbstractBooleanAssert(Boolean actual, Class<?> selfType) {
    * Verifies that the actual value is {@code true}.
    * <p>
    * Example:
-   * <pre><code class='java'> // assertions will pass
+   * <pre><code class='java'> // assertions succeed:
    * assertThat(true).isTrue();
    * assertThat(Boolean.TRUE).isTrue();
    *
-   * // assertions will fail
+   * // assertions fail:
    * assertThat(false).isTrue();
    * assertThat(Boolean.FALSE).isTrue();</code></pre>
    *
@@ -69,11 +66,11 @@ public SELF isTrue() {
    * Verifies that the actual value is {@code false}.
    * <p>
    * Example:
-   * <pre><code class='java'> // assertions will pass
+   * <pre><code class='java'> // assertions succeed:
    * assertThat(false).isFalse();
    * assertThat(Boolean.FALSE).isFalse();
    *
-   * // assertions will fail
+   * // assertions fail:
    * assertThat(true).isFalse();
    * assertThat(Boolean.TRUE).isFalse();</code></pre>
    *
@@ -91,11 +88,11 @@ public SELF isFalse() {
    * Verifies that the actual value is equal to the given one.
    * <p>
    * Example:
-   * <pre><code class='java'> // assertions will pass
+   * <pre><code class='java'> // assertions succeed:
    * assertThat(true).isEqualTo(true);
    * assertThat(Boolean.FALSE).isEqualTo(false);
    *
-   * // assertions will fail
+   * // assertions fail:
    * assertThat(true).isEqualTo(false);
    * assertThat(Boolean.TRUE).isEqualTo(false);</code></pre>
    *
@@ -105,19 +102,20 @@ public SELF isFalse() {
    * @throws AssertionError if the actual value is not equal to the given one.
    */
   public SELF isEqualTo(boolean expected) {
-    booleans.assertEqual(info, actual, expected);
+    if (actual == null || actual != expected)
+      throw Failures.instance().failure(info, shouldBeEqual(actual, expected, info.representation()));
     return myself;
   }
 
   /**
    * Verifies that the actual value is not equal to the given one.
    * <p>
    * Example:
-   * <pre><code class='java'> // assertions will pass
+   * <pre><code class='java'> // assertions succeed:
    * assertThat(true).isNotEqualTo(false);
    * assertThat(Boolean.FALSE).isNotEqualTo(true);
    *
-   * // assertions will fail
+   * // assertions fail:
    * assertThat(true).isNotEqualTo(true);
    * assertThat(Boolean.FALSE).isNotEqualTo(false);</code></pre>
    *
@@ -127,7 +125,7 @@ public SELF isEqualTo(boolean expected) {
    * @throws AssertionError if the actual value is equal to the given one.
    */
   public SELF isNotEqualTo(boolean other) {
-    booleans.assertNotEqual(info, actual, other);
+    if (actual != null && actual == other) throwAssertionError(shouldNotBeEqual(actual, other));
     return myself;
   }
 

diff --git a/assertj-core/src/main/java/org/assertj/core/api/AtomicBooleanAssert.java b/assertj-core/src/main/java/org/assertj/core/api/AtomicBooleanAssert.java
@@ -17,14 +17,8 @@
 import java.util.Comparator;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import org.assertj.core.internal.Booleans;
-import org.assertj.core.util.VisibleForTesting;
-
 public class AtomicBooleanAssert extends AbstractAssert<AtomicBooleanAssert, AtomicBoolean> {
 
-  @VisibleForTesting
-  Booleans booleans = Booleans.instance();
-
   public AtomicBooleanAssert(AtomicBoolean actual) {
     super(actual, AtomicBooleanAssert.class);
   }

diff --git a/assertj-core/src/main/java/org/assertj/core/internal/Booleans.java b/assertj-core/src/main/java/org/assertj/core/internal/Booleans.java
diff --git a/assertj-core/src/test/java/org/assertj/core/api/BooleanAssertBaseTest.java b/assertj-core/src/test/java/org/assertj/core/api/BooleanAssertBaseTest.java
diff --git a/...ore/src/test/java/org/assertj/core/api/boolean_/BooleanAssert_isEqualTo_boolean_Test.java b/...ore/src/test/java/org/assertj/core/api/boolean_/BooleanAssert_isEqualTo_boolean_Test.java
@@ -12,25 +12,51 @@
  */
 package org.assertj.core.api.boolean_;
 
-import static org.mockito.Mockito.verify;
+import static java.lang.Boolean.FALSE;
+import static java.lang.Boolean.TRUE;
+import static java.lang.String.format;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.BDDAssertions.then;
+import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
 
-import org.assertj.core.api.BooleanAssert;
-import org.assertj.core.api.BooleanAssertBaseTest;
+import org.junit.jupiter.api.Test;
 
-/**
- * Tests for <code>{@link BooleanAssert#isEqualTo(boolean)}</code>.
- * 
- * @author Alex Ruiz
- */
-class BooleanAssert_isEqualTo_boolean_Test extends BooleanAssertBaseTest {
+class BooleanAssert_isEqualTo_boolean_Test {
+
+  @Test
+  void should_fail_if_actual_is_null_since_the_expected_argument_cannot_be_null() {
+    // GIVEN
+    Boolean actual = null;
+    // WHEN
+    AssertionError assertionError = expectAssertionError(() -> assertThat(actual).isEqualTo(true));
+    // THEN
+    then(assertionError).hasMessage(format("%n" +
+                                           "expected: true%n" +
+                                           " but was: null"));
+  }
 
-  @Override
-  protected BooleanAssert invoke_api_method() {
-    return assertions.isEqualTo(false);
+  @Test
+  void should_pass_if_booleans_are_equal() {
+    assertThat(true).isEqualTo(true);
+    assertThat(true).isEqualTo(TRUE);
+    assertThat(TRUE).isEqualTo(true);
+    assertThat(TRUE).isEqualTo(TRUE);
+    assertThat(false).isEqualTo(false);
+    assertThat(false).isEqualTo(FALSE);
+    assertThat(FALSE).isEqualTo(false);
+    assertThat(FALSE).isEqualTo(FALSE);
   }
 
-  @Override
-  protected void verify_internal_effects() {
-    verify(booleans).assertEqual(getInfo(assertions), getActual(assertions), false);
+  @Test
+  void should_fail_if_booleans_are_not_equal() {
+    // GIVEN
+    boolean actual = false;
+    boolean expected = true;
+    // WHEN
+    AssertionError assertionError = expectAssertionError(() -> assertThat(actual).isEqualTo(expected));
+    // THEN
+    then(assertionError).hasMessage(format("%n" +
+                                           "expected: true%n" +
+                                           " but was: false"));
   }
 }
diff --git a/.../src/test/java/org/assertj/core/api/boolean_/BooleanAssert_isNotEqualTo_boolean_Test.java b/.../src/test/java/org/assertj/core/api/boolean_/BooleanAssert_isNotEqualTo_boolean_Test.java
@@ -12,25 +12,46 @@
  */
 package org.assertj.core.api.boolean_;
 
-import static org.mockito.Mockito.verify;
+import static java.lang.Boolean.FALSE;
+import static java.lang.Boolean.TRUE;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.BDDAssertions.then;
+import static org.assertj.core.error.ShouldNotBeEqual.shouldNotBeEqual;
+import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
 
-import org.assertj.core.api.BooleanAssert;
-import org.assertj.core.api.BooleanAssertBaseTest;
+import org.junit.jupiter.api.Test;
 
-/**
- * Tests for <code>{@link BooleanAssert#isNotEqualTo(boolean)}</code>.
- * 
- * @author Alex Ruiz
- */
-class BooleanAssert_isNotEqualTo_boolean_Test extends BooleanAssertBaseTest {
+class BooleanAssert_isNotEqualTo_boolean_Test {
+
+  @Test
+  void should_pass_if_actual_is_null_since_the_other_argument_cannot_be_null() {
+    Boolean actual = null;
+    assertThat(actual).isNotEqualTo(false);
+    assertThat(actual).isNotEqualTo(FALSE);
+    assertThat(actual).isNotEqualTo(true);
+    assertThat(actual).isNotEqualTo(TRUE);
+  }
 
-  @Override
-  protected BooleanAssert invoke_api_method() {
-    return assertions.isNotEqualTo(false);
+  @Test
+  void should_pass_if_booleans_are_not_equal() {
+    assertThat(true).isNotEqualTo(FALSE);
+    assertThat(true).isNotEqualTo(false);
+    assertThat(TRUE).isNotEqualTo(FALSE);
+    assertThat(TRUE).isNotEqualTo(false);
+    assertThat(false).isNotEqualTo(true);
+    assertThat(false).isNotEqualTo(TRUE);
+    assertThat(FALSE).isNotEqualTo(true);
+    assertThat(FALSE).isNotEqualTo(TRUE);
   }
 
-  @Override
-  protected void verify_internal_effects() {
-    verify(booleans).assertNotEqual(getInfo(assertions), getActual(assertions), false);
+  @Test
+  void should_fail_if_booleans_are_equal() {
+    // GIVEN
+    boolean actual = TRUE;
+    boolean expected = true;
+    // WHEN
+    AssertionError assertionError = expectAssertionError(() -> assertThat(actual).isNotEqualTo(expected));
+    // THEN
+    then(assertionError).hasMessage(shouldNotBeEqual(actual, expected).create());
   }
 }