Class AbstractClassAssert<SELF extends AbstractClassAssert<SELF>>

java.lang.Object
org.assertj.core.api.AbstractAssert<SELF,Class<?>>
org.assertj.core.api.AbstractClassAssert<SELF>
Type Parameters:
SELF - the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation" for more details.
All Implemented Interfaces:
Assert<SELF,Class<?>>, Descriptable<SELF>, ExtensionPoints<SELF,Class<?>>
Direct Known Subclasses:
ClassAssert, SoftAssertionClassAssert

public abstract class AbstractClassAssert<SELF extends AbstractClassAssert<SELF>> extends AbstractAssert<SELF,Class<?>>
Base class for all implementations of assertions for Classes.
  • Field Details

  • Constructor Details

    • AbstractClassAssert

      public AbstractClassAssert(Class<?> actual, Class<?> selfType)
  • Method Details

    • isAssignableFrom

      public SELF isAssignableFrom(Class<?>... others)
      Verifies that the actual Class is assignable from others Class

      Example:

       class Jedi {}
       class HumanJedi extends Jedi {}
       
       // this assertion succeeds:
       assertThat(Jedi.class).isAssignableFrom(HumanJedi.class);
       
       // this assertion fails:
       assertThat(HumanJedi.class).isAssignableFrom(Jedi.class);
      Parameters:
      others - Class who can be assignable from.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Class is null.
      IllegalArgumentException - if no others classes have been specified.
      AssertionError - if the actual Class is not assignable from all of the others classes.
      See Also:
    • isNotInterface

      public SELF isNotInterface()
      Verifies that the actual Class is not an interface.

      Example:

       interface Jedi {}
       class HumanJedi implements Jedi {}
       
       // this assertion succeeds:
       assertThat(HumanJedi.class).isNotInterface();
       
       // this assertion fails:
       assertThat(Jedi.class).isNotInterface();
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class is not an interface.
    • isInterface

      public SELF isInterface()
      Verifies that the actual Class is an interface.

      Example:

       interface Jedi {}
       class HumanJedi implements Jedi {}
       
       // this assertion succeeds:
       assertThat(Jedi.class).isInterface();
       
       // this assertion fails:
       assertThat(HumanJedi.class).isInterface();
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class is not an interface.
    • isAnnotation

      public SELF isAnnotation()
      Verifies that the actual Class is an annotation.

      Example:

       public @interface Jedi {}
       
       // these assertions succeed:
       assertThat(Jedi.class).isAnnotation();
       assertThat(Override.class).isAnnotation();
       assertThat(Deprecated.class).isAnnotation();
       
       // this assertion fails:
       assertThat(String.class).isAnnotation();
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class is not an annotation.
    • isNotAnnotation

      public SELF isNotAnnotation()
      Verifies that the actual Class is not an annotation.

      Example:

       public @interface Jedi {}
       
       // this assertion succeeds:
       assertThat(String.class).isNotAnnotation();
       
       // these assertions fail:
       assertThat(Jedi.class).isNotAnnotation();
       assertThat(Override.class).isNotAnnotation();
       assertThat(Deprecated.class).isNotAnnotation();
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class is an annotation.
    • isFinal

      public SELF isFinal()
      Verifies that the actual Class is final (has final modifier).

      Example:

       // these assertions succeed:
       assertThat(String.class).isFinal();
       assertThat(Math.class).isFinal();
      
       // these assertions fail:
       assertThat(Object.class).isFinal();
       assertThat(Throwable.class).isFinal();
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class is not final.
    • isNotFinal

      public SELF isNotFinal()
      Verifies that the actual Class is not final (does not have final modifier).

      Example:

       // these assertions succeed:
       assertThat(Object.class).isNotFinal();
       assertThat(Throwable.class).isNotFinal();
      
       // these assertions fail:
       assertThat(String.class).isNotFinal();
       assertThat(Math.class).isNotFinal();
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class is final.
    • isPublic

      public SELF isPublic()
      Verifies that the actual Class is public (has public modifier).

      Example:

       protected class MyClass { }
      
       // these assertions succeed:
       assertThat(String.class).isPublic();
       assertThat(Math.class).isPublic();
      
       // This assertion fails:
       assertThat(MyClass.class).isPublic();
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class is not public.
      Since:
      2.7.0 / 3.7.0
    • isProtected

      public SELF isProtected()
      Verifies that the actual Class is protected (has protected modifier).

      Example:

       public class MyClass { }
      
       // this assertion succeeds:
       assertThat(MyClass.class).isProtected();
      
       // these assertions fail:
       assertThat(String.class).isProtected();
       assertThat(Math.class).isProtected();
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class is not protected.
      Since:
      2.7.0 / 3.7.0
    • hasAnnotations

      public SELF hasAnnotations(Class<? extends Annotation>... annotations)
      Verifies that the actual Class has the given Annotations.

      Example:

       @Target(ElementType.TYPE)
       @Retention(RetentionPolicy.RUNTIME)
       private static @interface Force { }
       
       @Target(ElementType.TYPE)
       @Retention(RetentionPolicy.RUNTIME)
       private static @interface Hero { }
       
       @Target(ElementType.TYPE)
       @Retention(RetentionPolicy.RUNTIME)
       private static @interface DarkSide { }
       
       @Hero @Force
       class Jedi implements Jedi {}
       
       // this assertion succeeds:
       assertThat(Jedi.class).containsAnnotations(Force.class, Hero.class);
       
       // this assertion fails:
       assertThat(Jedi.class).containsAnnotations(Force.class, DarkSide.class);
      Parameters:
      annotations - annotations who must be attached to the class
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class doesn't contains all of these annotations.
    • hasAnnotation

      public SELF hasAnnotation(Class<? extends Annotation> annotation)
      Verifies that the actual Class has the given Annotation.

      Example:

       @Target(ElementType.TYPE)
       @Retention(RetentionPolicy.RUNTIME)
       private static @interface Force { }
       @Force
       class Jedi implements Jedi {}
       
       // this assertion succeeds:
       assertThat(Jedi.class).containsAnnotation(Force.class);
       
       // this assertion fails:
       assertThat(Jedi.class).containsAnnotation(DarkSide.class);
      Parameters:
      annotation - annotations who must be attached to the class
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class doesn't contains all of these annotations.
    • hasFields

      @Deprecated public SELF hasFields(String... fields)
      Deprecated.
    • hasPublicFields

      public SELF hasPublicFields(String... fields)
      Verifies that the actual Class has the given accessible public fields (as in Class.getFields()).

      Example:

       class MyClass {
           public String fieldOne;
           protected String fieldTwo;
           String fieldThree;
           private String fieldFour;
       }
       
       // this assertion succeeds:
       assertThat(MyClass.class).hasPublicFields("fieldOne");
       
       // these assertions fail:
       assertThat(MyClass.class).hasPublicFields("fieldTwo");
       assertThat(MyClass.class).hasPublicFields("fieldThree");
       assertThat(MyClass.class).hasPublicFields("fieldFour");
       assertThat(MyClass.class).hasPublicFields("unknownField");

      The assertion succeeds if no given fields are passed and the actual Class has no accessible public fields.

      Parameters:
      fields - the fields who must be in the class.
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class doesn't contain all of the fields.
      See Also:
    • hasOnlyPublicFields

      public SELF hasOnlyPublicFields(String... fields)
      Verifies that the actual Class only has the given accessible public fields (as in Class.getFields()) and nothing more in any order.

      Example:

       class MyClass {
           public String fieldOne;
           public String fieldTwo;
           private String fieldThree;
       }
      
       // these assertions succeed:
       assertThat(MyClass.class).hasOnlyPublicFields("fieldOne", "fieldTwo");
       assertThat(MyClass.class).hasOnlyPublicFields("fieldTwo", "fieldOne");
      
       // this assertion fails:
       assertThat(MyClass.class).hasOnlyPublicFields("fieldOne");

      The assertion succeeds if no given fields are passed and the actual Class has no accessible public fields.

      Parameters:
      fields - all the fields that are expected to be in the class.
      Throws:
      AssertionError - if actual is null.
      AssertionError - if fields are not all the actual Class's accessible public fields.
      Since:
      2.7.0 / 3.7.0
      See Also:
    • hasDeclaredFields

      public SELF hasDeclaredFields(String... fields)
      Verifies that the actual Class has the given declared fields (as in Class.getDeclaredFields()).

      Example:

       class MyClass {
           public String fieldOne;
           private String fieldTwo;
       }
       
       // this assertion succeeds:
       assertThat(MyClass.class).hasDeclaredFields("fieldOne", "fieldTwo");
       
       // this assertion fails:
       assertThat(MyClass.class).hasDeclaredFields("fieldThree");

      The assertion succeeds if no given fields are passed and the actual Class has no declared fields.

      Parameters:
      fields - the fields who must be declared in the class.
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class doesn't contains all of the field.
      See Also:
    • hasOnlyDeclaredFields

      public SELF hasOnlyDeclaredFields(String... fields)
      Verifies that the actual Class only has the given declared fields and nothing more in any order (as in Class.getDeclaredFields()).

      Example:

       class MyClass {
           public String fieldOne;
           public String fieldTwo;
           private String fieldThree;
           private String fieldFour;
       }
      
       // this assertion succeeds:
       assertThat(MyClass.class).hasOnlyDeclaredFields("fieldOne", "fieldTwo", "fieldThree", "fieldFour");
      
       // this assertion fails:
       assertThat(MyClass.class).hasOnlyDeclaredFields("fieldOne", "fieldThree");

      The assertion succeeds if no given fields are passed and the actual Class has no declared fields.

      Parameters:
      fields - all the fields that are expected to be in the class.
      Throws:
      AssertionError - if actual is null.
      AssertionError - if fields are not all the declared fields of the actual Class.
      Since:
      2.7.0 / 3.7.0
      See Also:
    • hasMethods

      public SELF hasMethods(String... methodNames)
      Verifies that the actual Class has the given methods (including inherited) whatever their visibility are.

      Example:

       class MySuperClass {
           public void superMethod() {}
           private void privateSuperMethod() {}
       }
      
       class MyClass extends MySuperClass {
           public void methodOne() {}
           private void methodTwo() {}
       }
      
       // this assertion succeeds:
       assertThat(MyClass.class).hasMethods("methodOne", "methodTwo", "superMethod", "privateSuperMethod");
      
       // this assertion fails:
       assertThat(MyClass.class).hasMethods("methodThree");
      Parameters:
      methodNames - the method names which must be in the class.
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class doesn't contains all of the method names.
      Since:
      2.7.0 / 3.7.0
    • hasDeclaredMethods

      public SELF hasDeclaredMethods(String... methodNames)
      Verifies that the actual Class has the given declared methods.

      Example:

       class MySuperClass {
           public void superMethod() {}
       }
      
       class MyClass extends MySuperClass {
           public void methodOne() {}
           private void methodTwo() {}
       }
      
       // This assertion succeeds:
       assertThat(MyClass.class).hasDeclaredMethods("methodOne", "methodTwo");
      
       // these assertions fail:
       assertThat(MyClass.class).hasDeclaredMethods("superMethod");
       assertThat(MyClass.class).hasDeclaredMethods("methodThree");

      The assertion succeeds if no given methods are passed and the actual Class has no declared methods.

      Parameters:
      methodNames - the method names which must be declared in the class.
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class doesn't contains all of the given methods.
      Since:
      2.7.0 / 3.7.0
    • hasPublicMethods

      public SELF hasPublicMethods(String... methodNames)
      Verifies that the actual Class has the given public methods.

      Example:

       class MyClass {
           public void methodOne() {}
           public void methodTwo() {}
           protected void methodThree() {}
       }
      
       // these assertions succeed:
       assertThat(MyClass.class).hasPublicMethods("methodOne");
       assertThat(MyClass.class).hasPublicMethods("methodOne", "methodTwo");
      
       // these assertions fail:
       assertThat(MyClass.class).hasPublicMethods("methodOne", "methodThree");
       assertThat(MyClass.class).hasPublicMethods("methodThree");
      Parameters:
      methodNames - the public method names which must be in the class.
      Throws:
      AssertionError - if actual is null.
      AssertionError - if the actual Class doesn't contains all of the given public methods.
      Since:
      2.7.0 / 3.7.0