Package org.assertj.core.api

Class AbstractClassAssert<SELF extends AbstractClassAssert<SELF>>

    • Constructor Detail

      • AbstractClassAssert

        protected AbstractClassAssert​(java.lang.Class<?> actual,
                              java.lang.Class<?> selfType)

    • Method Detail

      • isAssignableFrom

        public SELF isAssignableFrom​(java.lang.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 assertions object
        Throws:
        java.lang.AssertionError - if the actual Class is null.
        java.lang.IllegalArgumentException - if no others classes have been specified.
        java.lang.AssertionError - if the actual Class is not assignable from all of the others classes.
        See Also:
        Class.isAssignableFrom(Class)

      • isAssignableTo

        public SELF isAssignableTo​(java.lang.Class<?> other)
        Verifies that the Class under test is assignable to the given Class.

        Example: 

         class Jedi {}
 class HumanJedi extends Jedi {}

 // this assertion succeeds:
 assertThat(HumanJedi.class).isAssignableTo(Jedi.class);

 // this assertion fails
 assertThat(Jedi.class).isAssignableTo(HumanJedi.class);
        Parameters:
        other - Class who can be assignable to.
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if the actual Class is null.
        java.lang.IllegalArgumentException - if other is null.
        java.lang.AssertionError - if the actual Class is not assignable to the others class.
        Since:
        3.24.0
        See Also:
        Class.isAssignableFrom(Class)

      • assertIsAssignableTo

        private void assertIsAssignableTo​(java.lang.Class<?> other)

      • 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();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is not an interface.

      • assertIsNotInterface

        private void assertIsNotInterface()

      • 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();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is not an interface.

      • assertIsInterface

        private void assertIsInterface()

      • isAbstract

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

        Example: 

         public abstract class MyClass { }

 // this assertion succeeds:
 assertThat(MyClass.class).isAbstract();

 // this assertion fails:
 assertThat(String.class).isAbstract();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is not abstract.
        Since:
        3.12.0

      • assertIsAbstract

        private void assertIsAbstract()

      • 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();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is not an annotation.

      • assertIsAnnotation

        private void assertIsAnnotation()

      • 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();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is an annotation.

      • assertIsNotAnnotation

        private void assertIsNotAnnotation()

      • isRecord

        public SELF isRecord()
        Verifies that the actual Class is a record.

        Example: 

         public record Jedi(String name) {}

 // this assertion succeeds:
 assertThat(Jedi.class).isRecord();

 // this assertion fails:
 assertThat(String.class).isRecord();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is not a record.
        Since:
        3.25.0

      • assertIsRecord

        private void assertIsRecord()

      • isNotRecord

        public SELF isNotRecord()
        Verifies that the actual Class is not a record.

        Example: 

         public record Jedi(String name) {}

 // this assertion succeeds:
 assertThat(String.class).isNotRecord();

 // this assertion fails:
 assertThat(Jedi.class).isNotRecord();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is a record.
        Since:
        3.25.0

      • assertIsNotRecord

        private void assertIsNotRecord()

      • isRecord

        private static boolean isRecord​(java.lang.Class<?> actual)

      • hasRecordComponents

        public SELF hasRecordComponents​(java.lang.String first,
                                java.lang.String... rest)
        Verifies that the actual Class has the given record components

        Example: 

         public class NotARecord {}

 public record MyRecord(String componentOne, String componentTwo) {}

 // these assertions succeed:
 assertThat(MyRecord.class).hasRecordComponents("componentOne");
 assertThat(MyRecord.class).hasRecordComponents("componentOne", "componentTwo");

 // these assertions fail:
 assertThat(NotARecord.class).hasRecordComponents("componentOne");
 assertThat(MyRecord.class).hasRecordComponents("componentOne", "unknownComponent");
        Parameters:
        first - the first record component name which must be in this class
        rest - the remaining record component names which must be in this class
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is not a record.
        java.lang.AssertionError - if the actual Class doesn't contain all the record component names.
        Since:
        3.25.0

      • assertHasRecordComponents

        private void assertHasRecordComponents​(java.lang.String first,
                                       java.lang.String[] rest)

      • getRecordComponentNames

        private static java.util.Set<java.lang.String> getRecordComponentNames​(java.lang.Class<?> actual)

      • 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();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is not final.

      • assertIsFinal

        private void assertIsFinal()

      • 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();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is final.

      • assertIsNotFinal

        private void assertIsNotFinal()

      • 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();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is not public.
        Since:
        2.7.0 / 3.7.0

      • assertIsPublic

        private void assertIsPublic()

      • 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();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is not protected.
        Since:
        2.7.0 / 3.7.0

      • assertIsProtected

        private void assertIsProtected()

      • isPackagePrivate

        public SELF isPackagePrivate()
        Verifies that the actual Class is package-private (i.e., has no explicit access level modifier).

        Example: 

         class MyClass { }

 // this assertion succeeds:
 assertThat(MyClass.class).isPackagePrivate();

 // these assertions fail:
 assertThat(String.class).isPackagePrivate();
 assertThat(Math.class).isPackagePrivate();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is not package-private.
        Since:
        3.15.0

      • assertIsPackagePrivate

        private void assertIsPackagePrivate()

      • isPrivate

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

        Example: 

         class EnclosingClass {
   private static class PrivateClass { }
 }

 // these assertions succeed:
 assertThat(PrivateClass.class).isPrivate();
 assertThat(Class.forName(EnclosingClass.class.getName() + "$PrivateClass")).isPrivate();

 // This assertion fails:
 assertThat(String.class).isPrivate();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is not private.
        Since:
        3.26.0

      • assertIsPrivate

        private void assertIsPrivate()

      • isStatic

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

        Example: 

         class OuterClass {
    static class StaticNestedClass { }
 }
 // this assertion succeeds:
 assertThat(OuterClass.StaticNestedClass.class).isStatic();

 // these assertions fail:
 assertThat(Object.class).isStatic();
 assertThat(Throwable.class).isStatic();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is not static.
        Since:
        3.23.0

      • assertIsStatic

        private void assertIsStatic()

      • isNotStatic

        public SELF isNotStatic()
        Verifies that the actual Class is not static (does not have static modifier).

        Example: 

         // these assertions succeed:
 assertThat(Object.class).isNotStatic();
 assertThat(Throwable.class).isNotStatic();

 class OuterClass {
    static class StaticNestedClass { }
 }
 // this assertion fails:
 assertThat(OuterClass.StaticNestedClass.class).isNotStatic();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is static.
        Since:
        3.23.0

      • assertIsNotStatic

        private void assertIsNotStatic()

      • hasAnnotations

        @SafeVarargs
public final SELF hasAnnotations​(java.lang.Class<? extends java.lang.annotation.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
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class doesn't contains all of these annotations.

      • hasAnnotationsForProxy

        protected SELF hasAnnotationsForProxy​(java.lang.Class<? extends java.lang.annotation.Annotation>[] annotations)

      • hasAnnotation

        public SELF hasAnnotation​(java.lang.Class<? extends java.lang.annotation.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
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class doesn't contains all of these annotations.

      • hasSuperclass

        public SELF hasSuperclass​(java.lang.Class<?> superclass)
        Verifies that the actual Class has the given class as direct superclass (as in Class.getSuperclass()).

        The expected superclass should always be not null. To verify the absence of the superclass, use hasNoSuperclass().

        Example: 

         // this assertion succeeds:
 assertThat(Integer.class).hasSuperclass(Number.class);

 // this assertion succeeds as superclass for array classes is Object:
 assertThat(Integer[].class).hasSuperclass(Object.class);

 // this assertion fails:
 assertThat(String.class).hasSuperclass(Number.class);

 // this assertion fails as only direct superclass matches:
 assertThat(String.class).hasSuperclass(Object.class);

 // this assertion fails as interfaces are not superclasses:
 assertThat(String.class).hasSuperclass(Comparable.class);
        Parameters:
        superclass - the class which must be the direct superclass of actual.
        Returns:
        this assertions object
        Throws:
        java.lang.NullPointerException - if superclass is null.
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class doesn't have the given class as direct superclass.
        Since:
        3.15.0
        See Also:
        hasNoSuperclass()

      • assertHasSuperclass

        private void assertHasSuperclass​(java.lang.Class<?> superclass)

      • hasNoSuperclass

        public SELF hasNoSuperclass()
        Verifies that the actual Class has no superclass (as in Class.getSuperclass(), when null is returned).

        Example: 

         // this assertion succeeds as Object has no superclass:
 assertThat(Object.class).hasNoSuperclass();

 // this assertion succeeds as interfaces have no superclass:
 assertThat(Cloneable.class).hasNoSuperclass();

 // this assertion succeeds as primitive types have no superclass:
 assertThat(Integer.TYPE).hasNoSuperclass();

 // this assertion succeeds as void type has no superclass:
 assertThat(Void.TYPE).hasNoSuperclass();

 // this assertion fails as Integer has Number as superclass:
 assertThat(Integer.class).hasNoSuperclass();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class has a superclass.
        Since:
        3.15.0
        See Also:
        hasSuperclass(Class)

      • assertHasNoSuperclass

        private void assertHasNoSuperclass()

      • hasFields

        @Deprecated
public SELF hasFields​(java.lang.String... fields)
        Deprecated.
        use hasPublicFields(String...) instead.
        Parameters:
        fields - the fields who must be in the class.
        Returns:
        this assertions object

      • hasPublicFields

        public SELF hasPublicFields​(java.lang.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.
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class doesn't contain all of the fields.
        See Also:
        Class.getField(String)

      • hasOnlyPublicFields

        public SELF hasOnlyPublicFields​(java.lang.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.
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if fields are not all the actual Class's accessible public fields.
        Since:
        2.7.0 / 3.7.0
        See Also:
        Class.getField(String)

      • hasDeclaredFields

        public SELF hasDeclaredFields​(java.lang.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.
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class doesn't contains all of the field.
        See Also:
        Class.getDeclaredField(String)

      • hasOnlyDeclaredFields

        public SELF hasOnlyDeclaredFields​(java.lang.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.
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if fields are not all the declared fields of the actual Class.
        Since:
        2.7.0 / 3.7.0
        See Also:
        Class.getField(String)

      • hasMethods

        public SELF hasMethods​(java.lang.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.
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class doesn't contains all of the method names.
        Since:
        2.7.0 / 3.7.0

      • hasDeclaredMethods

        public SELF hasDeclaredMethods​(java.lang.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.
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class doesn't contains all of the given methods.
        Since:
        2.7.0 / 3.7.0

      • hasPublicMethods

        public SELF hasPublicMethods​(java.lang.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.
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class doesn't contains all of the given public methods.
        Since:
        2.7.0 / 3.7.0

      • hasPackage

        public SELF hasPackage​(java.lang.String expected)
        Verifies that the actual Class has the given package name (as in Class.getPackage()).

        The expected package name should always be not null. To verify the absence of the package, use hasNoPackage().

        Example: 

         package one.two;

 class MyClass {}

 // this assertions succeeds:
 assertThat(MyClass.class).hasPackage("one.two");

 // these assertions fail:
 assertThat(MyClass.class).hasPackage("one");
 assertThat(MyClass.class).hasPackage("");
 assertThat(MyClass.class).hasPackage("java.lang");
        Parameters:
        expected - the package name the class should have
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class does not have the given package.
        Since:
        3.18.0

      • assertHasPackage

        private void assertHasPackage​(java.lang.String packageName)

      • hasPackage

        public SELF hasPackage​(java.lang.Package expected)
        Verifies that the actual Class has the given package (as in Class.getPackage()).

        The expected package should always be not null. To verify the absence of the package, use hasNoPackage().

        Example: 

         package one.two;

 class MyClass {}

 // these assertions succeed:
 assertThat(MyClass.class).hasPackage(Package.getPackage("one.two"));
 assertThat(MyClass.class).hasPackage(MyClass.class.getPackage());

 // these assertions fail:
 assertThat(MyClass.class).hasPackage(Package.getPackage("one"));
 assertThat(MyClass.class).hasPackage(Package.getPackage(""));
 assertThat(MyClass.class).hasPackage(Object.class.getPackage());
        Parameters:
        expected - the package the class should have
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class does not have the given package.
        Since:
        3.18.0
        See Also:
        hasPackage(String), hasNoPackage()

      • assertHasPackage

        private void assertHasPackage​(java.lang.Package expected)

      • hasNoPackage

        public SELF hasNoPackage()
        Verifies that the actual Class has no package (as in Class.getPackage(), when null is returned).

        Example: 

         // this assertion succeeds as arrays have no package:
 assertThat(int[].class).hasNoPackage();

 // this assertion succeeds as primitive types have no package:
 assertThat(Integer.TYPE).hasNoPackage();

 // this assertion succeeds as void type has no package:
 assertThat(Void.TYPE).hasNoPackage();

 // this assertion fails as Object has java.lang as package:
 assertThat(Object.class).hasNoPackage();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class has a package.
        Since:
        3.25.0
        See Also:
        hasPackage(Package), hasPackage(String)

      • assertHasNoPackage

        private void assertHasNoPackage()

      • isSealed

        public SELF isSealed()
        Verifies that the actual Class is sealed.

        Example: 

         sealed class SealedClass permits NonSealedClass {}

 non-sealed class NonSealedClass extends SealedClass {}

 // this assertion succeeds:
 assertThat(SealedClass.class).isSealed();

 // this assertion fails:
 assertThat(NonSealedClass.class).isSealed();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is not sealed.
        Since:
        3.25.0

      • assertIsSealed

        private void assertIsSealed()

      • isNotSealed

        public SELF isNotSealed()
        Verifies that the actual Class is not sealed.

        Example: 

         sealed class SealedClass permits NonSealedClass {}

 non-sealed class NonSealedClass extends SealedClass {}

 // this assertion succeeds:
 assertThat(NonSealedClass.class).isNotSealed();

 // this assertion fails:
 assertThat(SealedClass.class).isNotSealed();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is sealed.
        Since:
        3.25.0

      • assertIsNotSealed

        private void assertIsNotSealed()

      • isSealed

        private static boolean isSealed​(java.lang.Class<?> actual)

      • hasPermittedSubclasses

        public SELF hasPermittedSubclasses​(java.lang.Class<?>... permittedSubclasses)
        Verifies that the actual Class permitted subclasses contains the given classes.

        Example: 

         sealed class SealedClass permits NonSealedClass, FinalClass {}
 non-sealed class NonSealedClass extends SealedClass {}
 final class FinalClass extends SealedClass {}

 // these assertions succeed:
 assertThat(SealedClass.class).hasPermittedSubclasses(NonSealedClass.class)
                              .hasPermittedSubclasses(FinalClass.class)
                              .hasPermittedSubclasses(NonSealedClass.class, FinalClass.class)
                              .hasPermittedSubclasses();

 // these assertions fail:
 assertThat(SealedClass.class).hasPermittedSubclasses(String.class);
 assertThat(SealedClass.class).hasPermittedSubclasses(FinalClass.class, String.class);
        Parameters:
        permittedSubclasses - classes that must be permitted subclasses of the given class
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class does not have all of given permitted subclasses

      • assertHasPermittedSubclasses

        private void assertHasPermittedSubclasses​(java.lang.Class<?>[] expectedPermittedSubclasses)

      • getPermittedSubclasses

        private static java.lang.Class<?>[] getPermittedSubclasses​(java.lang.Class<?> actual)

      • isPrimitive

        public SELF isPrimitive()
        Verifies that the actual Class is a primitive type.

        Example: 

         // these assertions succeed:
 assertThat(byte.class).isPrimitive();
 assertThat(short.class).isPrimitive();
 assertThat(int.class).isPrimitive();
 assertThat(long.class).isPrimitive();
 assertThat(float.class).isPrimitive();
 assertThat(double.class).isPrimitive();
 assertThat(boolean.class).isPrimitive();
 assertThat(char.class).isPrimitive();

 // this assertion fails as Object is not a primitive type:
 assertThat(Object.class).isPrimitive();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is not a primitive type.
        See Also:
        Class.isPrimitive()

      • isNotPrimitive

        public SELF isNotPrimitive()
        Verifies that the actual Class is not a primitive type.

        Example: 

         // this assertion succeeds as Object is not a primitive type:
 assertThat(Object.class).isNotPrimitive();

 // these assertions fail:
 assertThat(byte.class).isNotPrimitive();
 assertThat(short.class).isNotPrimitive();
 assertThat(int.class).isNotPrimitive();
 assertThat(long.class).isNotPrimitive();
 assertThat(float.class).isNotPrimitive();
 assertThat(double.class).isNotPrimitive();
 assertThat(boolean.class).isNotPrimitive();
 assertThat(char.class).isNotPrimitive();
        Returns:
        this assertions object
        Throws:
        java.lang.AssertionError - if actual is null.
        java.lang.AssertionError - if the actual Class is a primitive type.
        See Also:
        Class.isPrimitive()