Add Static class assertions

Fix assertj#2455

Author: WojciechZankowski

src/main/java/org/assertj/core/api/AbstractClassAssert.java

@@ -289,6 +289,54 @@ public SELF isPackagePrivate() {
     return myself;
   }
 
+  /**
+   * Verifies that the actual {@code Class} is static (has {@code static} modifier).
+   * <p>
+   * Example:
+   * <pre><code class='java'> class OuterClass {
+   *    static class StaticNestedClass { }
+   * }
+   * // this assertion succeeds:
+   * assertThat(OuterClass.StaticNestedClass.class).isStatic();
+   *
+   * // these assertions fail:
+   * assertThat(Object.class).isStatic();
+   * assertThat(Throwable.class).isStatic();</code></pre>
+   *
+   * @return {@code this} assertions object
+   * @throws AssertionError if {@code actual} is {@code null}.
+   * @throws AssertionError if the actual {@code Class} is not static.
+   * @since 3.23.0
+   */
+  public SELF isStatic() {
+    classes.assertIsStatic(info, actual);
+    return myself;
+  }
+
+  /**
+   * Verifies that the actual {@code Class} is not static (does not have {@code static} modifier).
+   * <p>
+   * Example:
+   * <pre><code class='java'> // these assertions succeed:
+   * assertThat(Object.class).isNotStatic();
+   * assertThat(Throwable.class).isNotStatic();
+   *
+   * class OuterClass {
+   *    static class StaticNestedClass { }
+   * }
+   * // this assertion fails:
+   * assertThat(OuterClass.StaticNestedClass.class).isNotStatic();</code></pre>
+   *
+   * @return {@code this} assertions object
+   * @throws AssertionError if {@code actual} is {@code null}.
+   * @throws AssertionError if the actual {@code Class} is static.
+   * @since 3.23.0
+   */
+  public SELF isNotStatic() {
+    classes.assertIsNotStatic(info, actual);
+    return myself;
+  }
+
   /**
    * Verifies that the actual {@code Class} has the given {@code Annotation}s.
    * <p>

src/main/java/org/assertj/core/error/ClassModifierShouldBe.java

@@ -83,6 +83,26 @@ public static ErrorMessageFactory shouldBePackagePrivate(Class<?> actual) {
     return new ClassModifierShouldBe(actual, true, PACKAGE_PRIVATE);
   }
 
+  /**
+   * Creates a new instance for a positive check of the {@code static} modifier.
+   *
+   * @param actual the actual value in the failed assertion.
+   * @return the created {@code ErrorMessageFactory}.
+   */
+  public static ErrorMessageFactory shouldBeStatic(Class<?> actual) {
+    return new ClassModifierShouldBe(actual, true, Modifier.toString(Modifier.STATIC));
+  }
+
+  /**
+   * Creates a new instance for a negative check of the {@code static} modifier.
+   *
+   * @param actual the actual value in the failed assertion.
+   * @return the created {@code ErrorMessageFactory}.
+   */
+  public static ErrorMessageFactory shouldNotBeStatic(Class<?> actual) {
+    return new ClassModifierShouldBe(actual, false, Modifier.toString(Modifier.STATIC));
+  }
+
   private static String modifiers(Class<?> actual) {
     int modifiers = actual.getModifiers();
     boolean isPackagePrivate = !isPublic(modifiers) && !isProtected(modifiers) && !isPrivate(modifiers);

src/main/java/org/assertj/core/internal/Classes.java

@@ -18,7 +18,9 @@
 import static org.assertj.core.error.ClassModifierShouldBe.shouldBePackagePrivate;
 import static org.assertj.core.error.ClassModifierShouldBe.shouldBeProtected;
 import static org.assertj.core.error.ClassModifierShouldBe.shouldBePublic;
+import static org.assertj.core.error.ClassModifierShouldBe.shouldBeStatic;
 import static org.assertj.core.error.ClassModifierShouldBe.shouldNotBeFinal;
+import static org.assertj.core.error.ClassModifierShouldBe.shouldNotBeStatic;
 import static org.assertj.core.error.ShouldBeAbstract.shouldBeAbstract;
 import static org.assertj.core.error.ShouldBeAnnotation.shouldBeAnnotation;
 import static org.assertj.core.error.ShouldBeAnnotation.shouldNotBeAnnotation;
@@ -240,6 +242,36 @@ public void assertIsNotFinal(AssertionInfo info, Class<?> actual) {
     if (Modifier.isFinal(actual.getModifiers())) throw failures.failure(info, shouldNotBeFinal(actual));
   }
 
+  /**
+   * Verifies that the actual {@code Class} is static.
+   *
+   * @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} is not static.
+   */
+  public void assertIsStatic(AssertionInfo info, Class<?> actual) {
+    assertNotNull(info, actual);
+    if (!Modifier.isStatic(actual.getModifiers())) {
+      throw failures.failure(info, shouldBeStatic(actual));
+    }
+  }
+
+  /**
+   * Verifies that the actual {@code Class} is not static.
+   *
+   * @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} is static.
+   */
+  public void assertIsNotStatic(AssertionInfo info, Class<?> actual) {
+    assertNotNull(info, actual);
+    if (Modifier.isStatic(actual.getModifiers())) {
+      throw failures.failure(info, shouldNotBeStatic(actual));
+    }
+  }
+
   /**
    * Verifies that the actual {@code Class} contains the given {@code Annotation}s.
    * 

src/test/java/org/assertj/core/api/classes/ClassAssert_isNotStatic_Test.java

@@ -0,0 +1,31 @@
+/*
+ * 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-2022 the original author or authors.
+ */
+package org.assertj.core.api.classes;
+
+import static org.mockito.Mockito.verify;
+
+import org.assertj.core.api.ClassAssert;
+import org.assertj.core.api.ClassAssertBaseTest;
+
+class ClassAssert_isNotStatic_Test extends ClassAssertBaseTest {
+
+  @Override
+  protected ClassAssert invoke_api_method() {
+    return assertions.isNotStatic();
+  }
+
+  @Override
+  protected void verify_internal_effects() {
+    verify(classes).assertIsNotStatic(getInfo(assertions), getActual(assertions));
+  }
+}

src/test/java/org/assertj/core/api/classes/ClassAssert_isStatic_Test.java

@@ -0,0 +1,32 @@
+/*
+ * 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-2022 the original author or authors.
+ */
+package org.assertj.core.api.classes;
+
+import static org.mockito.Mockito.verify;
+
+import org.assertj.core.api.ClassAssert;
+import org.assertj.core.api.ClassAssertBaseTest;
+
+class ClassAssert_isStatic_Test extends ClassAssertBaseTest {
+
+  @Override
+  protected ClassAssert invoke_api_method() {
+    return assertions.isStatic();
+  }
+
+  @Override
+  protected void verify_internal_effects() {
+    verify(classes).assertIsStatic(getInfo(assertions), getActual(assertions));
+  }
+
+}

src/test/java/org/assertj/core/internal/classes/Classes_assertIsNotStatic_Test.java

@@ -0,0 +1,64 @@
+/*
+ * 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-2022 the original author or authors.
+ */
+package org.assertj.core.internal.classes;
+
+import static org.assertj.core.api.BDDAssertions.then;
+import static org.assertj.core.error.ClassModifierShouldBe.shouldNotBeStatic;
+import static org.assertj.core.test.TestData.someInfo;
+import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
+import static org.assertj.core.util.FailureMessages.actualIsNull;
+
+import org.assertj.core.internal.ClassesBaseTest;
+import org.junit.jupiter.api.Test;
+
+class Classes_assertIsNotStatic_Test extends ClassesBaseTest {
+
+  @Test
+  void should_fail_if_actual_is_null() {
+    // GIVEN
+    Class<?> actual = null;
+    // WHEN
+    AssertionError assertionError = expectAssertionError(() -> classes.assertIsNotStatic(someInfo(), actual));
+    // THEN
+    then(assertionError).hasMessage(actualIsNull());
+  }
+
+  @Test
+  void should_pass_if_actual_is_not_a_static_class() {
+    // GIVEN
+    Class<?> actual = Math.class;
+    // WHEN/THEN
+    classes.assertIsNotStatic(someInfo(), actual);
+  }
+
+  @Test
+  void should_fail_if_actual_is_an_interface() {
+    // GIVEN
+    Class<?> actual = Classes_assertIsStatic_Test.NestedInterface.class;
+    // WHEN
+    AssertionError assertionError = expectAssertionError(() -> classes.assertIsNotStatic(someInfo(), actual));
+    // THEN
+    then(assertionError).hasMessage(shouldNotBeStatic(actual).create());
+  }
+
+  @Test
+  void should_fail_if_actual_is_not_a_static_class() {
+    // GIVEN
+    Class<?> actual = Classes_assertIsStatic_Test.StaticNestedClass.class;
+    // WHEN
+    AssertionError assertionError = expectAssertionError(() -> classes.assertIsNotStatic(someInfo(), actual));
+    // THEN
+    then(assertionError).hasMessage(shouldNotBeStatic(actual).create());
+  }
+
+}

src/test/java/org/assertj/core/internal/classes/Classes_assertIsStatic_Test.java

@@ -0,0 +1,68 @@
+/*
+ * 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-2022 the original author or authors.
+ */
+package org.assertj.core.internal.classes;
+
+import static org.assertj.core.api.BDDAssertions.then;
+import static org.assertj.core.error.ClassModifierShouldBe.shouldBeStatic;
+import static org.assertj.core.test.TestData.someInfo;
+import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
+import static org.assertj.core.util.FailureMessages.actualIsNull;
+
+import org.assertj.core.internal.ClassesBaseTest;
+import org.junit.jupiter.api.Test;
+
+class Classes_assertIsStatic_Test extends ClassesBaseTest {
+
+  @Test
+  void should_fail_if_actual_is_null() {
+    // GIVEN
+    Class<?> actual = null;
+    // WHEN
+    AssertionError assertionError = expectAssertionError(() -> classes.assertIsStatic(someInfo(), actual));
+    // THEN
+    then(assertionError).hasMessage(actualIsNull());
+  }
+
+  @Test
+  void should_pass_if_actual_is_a_static_class() {
+    // GIVEN
+    Class<?> actual = StaticNestedClass.class;
+    // WHEN/THEN
+    classes.assertIsStatic(someInfo(), actual);
+  }
+
+  @Test
+  void should_pass_if_actual_is_an_interface() {
+    // GIVEN
+    Class<?> actual = NestedInterface.class;
+    // WHEN/THEN
+    classes.assertIsStatic(someInfo(), actual);
+  }
+
+  @Test
+  void should_fail_if_actual_is_not_a_static_class() {
+    // GIVEN
+    Class<?> actual = Math.class;
+    // WHEN
+    AssertionError assertionError = expectAssertionError(() -> classes.assertIsStatic(someInfo(), actual));
+    // THEN
+    then(assertionError).hasMessage(shouldBeStatic(actual).create());
+  }
+
+  static class StaticNestedClass {
+  }
+
+  interface NestedInterface {
+  }
+
+}