Move hasSuperclass / hasNoSuperclass implementation to `AbstractC…

…lassAssert`
assertj · Apr 14, 2023 · 48880e2 · 48880e2
1 parent 46c4aa2
commit 48880e2
Show file tree

Hide file tree

Showing 6 changed files with 123 additions and 223 deletions.
diff --git a/assertj-core/src/main/java/org/assertj/core/api/AbstractClassAssert.java b/assertj-core/src/main/java/org/assertj/core/api/AbstractClassAssert.java
@@ -12,6 +12,7 @@
  */
 package org.assertj.core.api;
 
+import static java.util.Objects.requireNonNull;
 import static org.assertj.core.error.ClassModifierShouldBe.shouldBeFinal;
 import static org.assertj.core.error.ClassModifierShouldBe.shouldBePackagePrivate;
 import static org.assertj.core.error.ClassModifierShouldBe.shouldBeProtected;
@@ -22,7 +23,9 @@
 import static org.assertj.core.error.ShouldBeAssignableTo.shouldBeAssignableTo;
 import static org.assertj.core.error.ShouldBeRecord.shouldBeRecord;
 import static org.assertj.core.error.ShouldBeRecord.shouldNotBeRecord;
+import static org.assertj.core.error.ShouldHaveNoSuperclass.shouldHaveNoSuperclass;
 import static org.assertj.core.error.ShouldHaveRecordComponents.shouldHaveRecordComponents;
+import static org.assertj.core.error.ShouldHaveSuperclass.shouldHaveSuperclass;
 import static org.assertj.core.error.ShouldNotBeNull.shouldNotBeNull;
 import static org.assertj.core.util.Arrays.array;
 import static org.assertj.core.util.Sets.newLinkedHashSet;
@@ -650,10 +653,19 @@ public SELF hasAnnotation(Class<? extends Annotation> annotation) {
    * @see #hasNoSuperclass()
    */
   public SELF hasSuperclass(Class<?> superclass) {
-    classes.assertHasSuperclass(info, actual, superclass);
+    isNotNull();
+    assertHasSuperclass(superclass);
     return myself;
   }
 
+  private void assertHasSuperclass(Class<?> superclass) {
+    requireNonNull(superclass, shouldNotBeNull("superclass")::create);
+    Class<?> actualSuperclass = actual.getSuperclass();
+    if (actualSuperclass == null || !actualSuperclass.equals(superclass)) {
+      throw assertionError(shouldHaveSuperclass(actual, superclass));
+    }
+  }
+
   /**
    * Verifies that the actual {@code Class} has no superclass (as in {@link Class#getSuperclass()}, when {@code null}
    * is returned).
@@ -681,10 +693,15 @@ public SELF hasSuperclass(Class<?> superclass) {
    * @see #hasSuperclass(Class)
    */
   public SELF hasNoSuperclass() {
-    classes.assertHasNoSuperclass(info, actual);
+    isNotNull();
+    assertHasNoSuperclass();
     return myself;
   }
 
+  private void assertHasNoSuperclass() {
+    if (actual.getSuperclass() != null) throw assertionError(shouldHaveNoSuperclass(actual));
+  }
+
   /**
    * @deprecated use {@link #hasPublicFields(String...)} instead.
    * @param fields the fields who must be in the class.

diff --git a/assertj-core/src/main/java/org/assertj/core/internal/Classes.java b/assertj-core/src/main/java/org/assertj/core/internal/Classes.java
@@ -27,9 +27,7 @@
 import static org.assertj.core.error.ShouldHaveMethods.shouldNotHaveMethods;
 import static org.assertj.core.error.ShouldHaveNoFields.shouldHaveNoDeclaredFields;
 import static org.assertj.core.error.ShouldHaveNoFields.shouldHaveNoPublicFields;
-import static org.assertj.core.error.ShouldHaveNoSuperclass.shouldHaveNoSuperclass;
 import static org.assertj.core.error.ShouldHavePackage.shouldHavePackage;
-import static org.assertj.core.error.ShouldHaveSuperclass.shouldHaveSuperclass;
 import static org.assertj.core.error.ShouldNotBeNull.shouldNotBeNull;
 import static org.assertj.core.error.ShouldOnlyHaveFields.shouldOnlyHaveDeclaredFields;
 import static org.assertj.core.error.ShouldOnlyHaveFields.shouldOnlyHaveFields;
@@ -185,40 +183,6 @@ public void assertContainsAnnotations(AssertionInfo info, Class<?> actual,
     if (!missing.isEmpty()) throw failures.failure(info, shouldHaveAnnotations(actual, expected, missing));
   }
 
-  /**
-   * Verifies that the actual {@code Class} has the given class as direct {@code superclass}.
-   *
-   * @param info       contains information about the assertion.
-   * @param actual     the "actual" {@code Class}.
-   * @param superclass the direct superclass, which should not be null.
-   * @throws NullPointerException if {@code superclass} is {@code null}.
-   * @throws AssertionError if {@code actual} is {@code null}.
-   * @throws AssertionError if the actual {@code Class} does not have the expected superclass.
-   */
-  public void assertHasSuperclass(AssertionInfo info, Class<?> actual, Class<?> superclass) {
-    assertNotNull(info, actual);
-    requireNonNull(superclass, shouldNotBeNull("superclass")::create);
-    Class<?> actualSuperclass = actual.getSuperclass();
-    if (actualSuperclass == null || !actualSuperclass.equals(superclass)) {
-      throw failures.failure(info, shouldHaveSuperclass(actual, superclass));
-    }
-  }
-
-  /**
-   * Verifies that the actual {@code Class} has no superclass.
-   *
-   * @param info       contains information about the assertion.
-   * @param actual     the "actual" {@code Class}.
-   * @throws AssertionError if {@code actual} is {@code null}.
-   * @throws AssertionError if the actual {@code Class} has a superclass.
-   */
-  public void assertHasNoSuperclass(AssertionInfo info, Class<?> actual) {
-    assertNotNull(info, actual);
-    if (actual.getSuperclass() != null) {
-      throw failures.failure(info, shouldHaveNoSuperclass(actual));
-    }
-  }
-
   /**
    * Verifies that the actual {@code Class} has the {@code fields}.
    * 

diff --git a/...rtj-core/src/test/java/org/assertj/core/api/classes/ClassAssert_hasNoSuperclass_Test.java b/...rtj-core/src/test/java/org/assertj/core/api/classes/ClassAssert_hasNoSuperclass_Test.java
@@ -12,26 +12,59 @@
  */
 package org.assertj.core.api.classes;
 
-import static org.mockito.Mockito.verify;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.BDDAssertions.then;
+import static org.assertj.core.error.ShouldHaveNoSuperclass.shouldHaveNoSuperclass;
+import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
+import static org.assertj.core.util.FailureMessages.actualIsNull;
 
-import org.assertj.core.api.ClassAssert;
-import org.assertj.core.api.ClassAssertBaseTest;
+import java.util.stream.Stream;
 
-/**
- * Tests for <code>{@link ClassAssert#hasNoSuperclass()}</code>.
- * 
- * @author Stefano Cordio
- */
-class ClassAssert_hasNoSuperclass_Test extends ClassAssertBaseTest {
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class ClassAssert_hasNoSuperclass_Test {
+
+  @Test
+  void should_fail_if_actual_is_null() {
+    // GIVEN
+    Class<?> actual = null;
+    // WHEN
+    AssertionError assertionError = expectAssertionError(() -> assertThat(actual).hasNoSuperclass());
+    // THEN
+    then(assertionError).hasMessage(actualIsNull());
+  }
+
+  @Test
+  void should_fail_if_actual_has_a_superclass() {
+    // GIVEN
+    Class<?> actual = Integer.class;
+    // WHEN
+    AssertionError assertionError = expectAssertionError(() -> assertThat(actual).hasNoSuperclass());
+    // THEN
+    then(assertionError).hasMessage(shouldHaveNoSuperclass(actual).create());
+  }
 
-  @Override
-  protected ClassAssert invoke_api_method() {
-    return assertions.hasNoSuperclass();
+  @ParameterizedTest
+  @MethodSource("nullSuperclassTypes")
+  void should_pass_if_actual_has_no_superclass(Class<?> actual) {
+    // WHEN/THEN
+    assertThat(actual).hasNoSuperclass();
   }
 
-  @Override
-  protected void verify_internal_effects() {
-    verify(classes).assertHasNoSuperclass(getInfo(assertions), getActual(assertions));
+  private static Stream<Class<?>> nullSuperclassTypes() {
+    return Stream.of(Object.class,
+                     Cloneable.class, // any interface
+                     Boolean.TYPE,
+                     Byte.TYPE,
+                     Character.TYPE,
+                     Double.TYPE,
+                     Float.TYPE,
+                     Integer.TYPE,
+                     Long.TYPE,
+                     Short.TYPE,
+                     Void.TYPE);
   }
 
 }
diff --git a/assertj-core/src/test/java/org/assertj/core/api/classes/ClassAssert_hasSuperclass_Test.java b/assertj-core/src/test/java/org/assertj/core/api/classes/ClassAssert_hasSuperclass_Test.java
@@ -12,26 +12,67 @@
  */
 package org.assertj.core.api.classes;
 
-import static org.mockito.Mockito.verify;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.catchThrowable;
+import static org.assertj.core.api.BDDAssertions.then;
+import static org.assertj.core.error.ShouldHaveSuperclass.shouldHaveSuperclass;
+import static org.assertj.core.error.ShouldNotBeNull.shouldNotBeNull;
+import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
+import static org.assertj.core.util.FailureMessages.actualIsNull;
 
-import org.assertj.core.api.ClassAssert;
-import org.assertj.core.api.ClassAssertBaseTest;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
-/**
- * Tests for <code>{@link ClassAssert#hasSuperclass(Class)}</code>.
- * 
- * @author Stefano Cordio
- */
-class ClassAssert_hasSuperclass_Test extends ClassAssertBaseTest {
+class ClassAssert_hasSuperclass_Test {
+
+  @Test
+  void should_fail_if_actual_is_null() {
+    // GIVEN
+    Class<?> actual = null;
+    // WHEN
+    AssertionError assertionError = expectAssertionError(() -> assertThat(actual).hasSuperclass(Object.class));
+    // THEN
+    then(assertionError).hasMessage(actualIsNull());
+  }
+
+  @Test
+  void should_fail_if_null_class_is_given() {
+    // GIVEN
+    Class<?> actual = Integer.class;
+    Class<?> superclass = null;
+    // WHEN
+    Throwable thrown = catchThrowable(() -> assertThat(actual).hasSuperclass(superclass));
+    // THEN
+    then(thrown).isInstanceOf(NullPointerException.class).hasMessage(shouldNotBeNull("superclass").create());
+  }
+
+  @Test
+  void should_pass_if_actual_has_given_class_as_direct_superclass() {
+    // GIVEN
+    Class<?> actual = Integer.class;
+    Class<?> superclass = Number.class;
+    // WHEN/THEN
+    assertThat(actual).hasSuperclass(superclass);
+  }
 
-  @Override
-  protected ClassAssert invoke_api_method() {
-    return assertions.hasSuperclass(Object.class);
+  @ParameterizedTest
+  @ValueSource(classes = { Object.class, Comparable.class, String.class })
+  void should_fail_if_actual_has_not_given_class_as_direct_superclass(Class<?> superclass) {
+    // GIVEN
+    Class<?> actual = Integer.class;
+    // WHEN
+    AssertionError assertionError = expectAssertionError(() -> assertThat(actual).hasSuperclass(superclass));
+    // THEN
+    then(assertionError).hasMessage(shouldHaveSuperclass(actual, superclass).create());
   }
 
-  @Override
-  protected void verify_internal_effects() {
-    verify(classes).assertHasSuperclass(getInfo(assertions), getActual(assertions), Object.class);
+  @Test
+  void should_pass_if_actual_is_an_array_class_and_object_class_is_given() {
+    // GIVEN
+    Class<?> actual = Integer[].class;
+    // WHEN/THEN
+    assertThat(actual).hasSuperclass(Object.class);
   }
 
 }
diff --git a/...e/src/test/java/org/assertj/core/internal/classes/Classes_assertHasNoSuperclass_Test.java b/...e/src/test/java/org/assertj/core/internal/classes/Classes_assertHasNoSuperclass_Test.java