public abstract Class AbstractClassAssert<SELF extends AbstractClassAssert<SELF>>

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:Class<? extends Annotation>

annotations who must be attached to the class

Returns:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class doesn't contains all of these 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:Class<? extends Annotation>[]

annotations who must be attached to the class

Returns:SELF

this assertions object

Annotations

@SafeVarargs

Exceptions

AssertionError:

• if actual is null.
• if the actual Class doesn't contains all of these annotations.

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:String[]

the fields who must be declared in the class.

Returns:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class doesn't contains all of the field.

See Also

Class#getDeclaredField(String)

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:String[]

the method names which must be declared in the class.

Returns:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class doesn't contains all of the given methods.

Since

2.7.0 / 3.7.0

Parameters

fields:String[]

the fields who must be in the class.

Returns:SELF

this assertions object

Annotations

@Deprecated

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:String[]

the method names which must be in the class.

Returns:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class doesn't contains all of the method names.

Since

2.7.0 / 3.7.0

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class has a package.

Since

3.25.0

See Also

hasPackage(Package), hasPackage(String)

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class has a superclass.

Since

3.15.0

See Also

hasSuperclass(Class)

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:String[]

all the fields that are expected to be in the class.

Returns:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if fields are not all the declared fields of the actual Class.

Since

2.7.0 / 3.7.0

See Also

Class#getField(String)

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:String[]

all the fields that are expected to be in the class.

Returns:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if fields are not all the actual Class's accessible public fields.

Since

2.7.0 / 3.7.0

See Also

Class#getField(String)

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:String

the package name the class should have

Returns:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class does not have the given package.

Since

3.18.0

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:Package

the package the class should have

Returns:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class does not have the given package.

Since

3.18.0

See Also

hasPackage(String), hasNoPackage()

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:Class<?>[]

classes that must be permitted subclasses of the given class

Returns:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class does not have all of given permitted subclasses

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:String[]

the fields who must be in the class.

Returns:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class doesn't contain all of the fields.

See Also

Class#getField(String)

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:String[]

the public method names which must be in the class.

Returns:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class doesn't contains all of the given public methods.

Since

2.7.0 / 3.7.0

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:String

the first record component name which must be in this class

rest:String[]

the remaining record component names which must be in this class

Returns:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is not a record.
• if the actual Class doesn't contain all the record component names.

Since

3.25.0

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:Class<?>

the class which must be the direct superclass of actual.

Returns:SELF

this assertions object

Exceptions

NullPointerException:

if superclass is null.

AssertionError:

• if actual is null.
• if the actual Class doesn't have the given class as direct superclass.

Since

3.15.0

See Also

hasNoSuperclass()

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is not abstract.

Since

3.12.0

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is not an annotation.

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<?>[]

Class who can be assignable from.

Returns:SELF

this assertions object

Exceptions

AssertionError:

• if the actual Class is null.
• if the actual Class is not assignable from all of the others classes.

IllegalArgumentException:

if no others classes have been specified.

See Also

Class#isAssignableFrom(Class)

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<?>

Class who can be assignable to.

Returns:SELF

this assertions object

Exceptions

AssertionError:

• if the actual Class is null.
• if the actual Class is not assignable to the others class.

IllegalArgumentException:

if other is null.

Since

3.24.0

See Also

Class#isAssignableFrom(Class)

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is not final.

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is not an interface.

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is an annotation.

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is final.

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is not an interface.

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is a primitive type.

See Also

Class#isPrimitive()

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is a record.

Since

3.25.0

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is sealed.

Since

3.25.0

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is static.

Since

3.23.0

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is not package-private.

Since

3.15.0

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is not a primitive type.

See Also

Class#isPrimitive()

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is not private.

Since

3.26.0

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is not protected.

Since

2.7.0 / 3.7.0

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is not public.

Since

2.7.0 / 3.7.0

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is not a record.

Since

3.25.0

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is not sealed.

Since

3.25.0

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:SELF

this assertions object

Exceptions

AssertionError:

• if actual is null.
• if the actual Class is not static.

Since

3.23.0