Package org.assertj.core.api

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 Summary

Fields

Modifier and Type	Field	Description
(package private) Classes	classes

Fields inherited from class org.assertj.core.api.AbstractAssert

actual, conditions, info, myself, objects

Constructor Summary

Constructors

Constructor	Description
AbstractClassAssert(Class<?> actual, Class<?> selfType)

Method Summary

Modifier and Type	Method	Description
SELF	hasAnnotation(Class<? extends Annotation> annotation)	Verifies that the actual Class has the given Annotation.
SELF	hasAnnotations(Class<? extends Annotation>... annotations)	Verifies that the actual Class has the given Annotations.
SELF	hasDeclaredFields(String... fields)	Verifies that the actual Class has the given declared fields (as in Class.getDeclaredFields()).
SELF	hasDeclaredMethods(String... methodNames)	Verifies that the actual Class has the given declared methods.
SELF	hasFields(String... fields)	Deprecated. use hasPublicFields(String...) instead.
SELF	hasMethods(String... methodNames)	Verifies that the actual Class has the given methods (including inherited) whatever their visibility are.
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()).
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.
SELF	hasPublicFields(String... fields)	Verifies that the actual Class has the given accessible public fields (as in Class.getFields()).
SELF	hasPublicMethods(String... methodNames)	Verifies that the actual Class has the given public methods.
SELF	isAnnotation()	Verifies that the actual Class is an annotation.
SELF	isAssignableFrom(Class<?>... others)	Verifies that the actual Class is assignable from others Class
SELF	isFinal()	Verifies that the actual Class is final (has final modifier).
SELF	isInterface()	Verifies that the actual Class is an interface.
SELF	isNotAnnotation()	Verifies that the actual Class is not an annotation.
SELF	isNotFinal()	Verifies that the actual Class is not final (does not have final modifier).
SELF	isNotInterface()	Verifies that the actual Class is not an interface.
SELF	isProtected()	Verifies that the actual Class is protected (has protected modifier).
SELF	isPublic()	Verifies that the actual Class is public (has public modifier).

Methods inherited from class org.assertj.core.api.AbstractAssert

as, as, asList, asString, describedAs, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasToString, inBinary, inHexadecimal, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, overridingErrorMessage, satisfies, setCustomRepresentation, throwAssertionError, usingComparator, usingDefaultComparator, withFailMessage, withRepresentation, withThreadDumpOnError

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Field Details

classes

Classes classes

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:

• Class.isAssignableFrom(Class)

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.

use hasPublicFields(String...) instead.

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:

• Class.getField(String)

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:

• Class.getField(String)

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:

• Class.getDeclaredField(String)

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:

• Class.getField(String)

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