Class AbstractClassAssert<SELF extends 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
Class
es.- Author:
- William Delanoue, Mikhail Mazursky
-
Field Summary
Fields inherited from class org.assertj.core.api.AbstractAssert
actual, info, myself, objects, throwUnsupportedExceptionOnEquals
-
Constructor Summary
-
Method Summary
Modifier and TypeMethodDescriptionhasAnnotation
(Class<? extends Annotation> annotation) Verifies that the actualClass
has the givenAnnotation
.final SELF
hasAnnotations
(Class<? extends Annotation>... annotations) Verifies that the actualClass
has the givenAnnotation
s.protected SELF
hasAnnotationsForProxy
(Class<? extends Annotation>[] annotations) hasDeclaredFields
(String... fields) Verifies that the actualClass
has the given declared fields (as inClass.getDeclaredFields()
).hasDeclaredMethods
(String... methodNames) Verifies that the actualClass
has the given declared methods.Deprecated.hasMethods
(String... methodNames) Verifies that the actualClass
has the given methods (including inherited) whatever their visibility are.Verifies that the actualClass
has no superclass (as inClass.getSuperclass()
, whennull
is returned).hasOnlyDeclaredFields
(String... fields) Verifies that the actualClass
only has the given declaredfields
and nothing more in any order (as inClass.getDeclaredFields()
).hasOnlyPublicFields
(String... fields) Verifies that the actualClass
only has the given accessible public fields (as inClass.getFields()
) and nothing more in any order.hasPackage
(Package aPackage) Verifies that the actualClass
has the given package (as inClass.getPackage()
).hasPackage
(String packageName) Verifies that the actualClass
has the given package name (as inClass.getPackage()
).hasPublicFields
(String... fields) Verifies that the actualClass
has the given accessible public fields (as inClass.getFields()
).hasPublicMethods
(String... methodNames) Verifies that the actualClass
has the given public methods.hasSuperclass
(Class<?> superclass) Verifies that the actualClass
has the given class as direct superclass (as inClass.getSuperclass()
).Verifies that the actualClass
is abstract (hasabstract
modifier).Verifies that the actualClass
is an annotation.isAssignableFrom
(Class<?>... others) Verifies that the actualClass
is assignable from othersClass
isAssignableTo
(Class<?> other) Verifies that theClass
under test is assignable to the givenClass
.isFinal()
Verifies that the actualClass
is final (hasfinal
modifier).Verifies that the actualClass
is an interface.Verifies that the actualClass
is not an annotation.Verifies that the actualClass
is not final (does not havefinal
modifier).Verifies that the actualClass
is not an interface.Verifies that the actualClass
is not static (does not havestatic
modifier).Verifies that the actualClass
is package-private (has no modifier).Verifies that the actualClass
is protected (hasprotected
modifier).isPublic()
Verifies that the actualClass
is public (haspublic
modifier).isStatic()
Verifies that the actualClass
is static (hasstatic
modifier).Methods inherited from class org.assertj.core.api.AbstractAssert
areEqual, asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, doesNotHaveSameHashCodeAs, doesNotHaveToString, equals, extracting, extracting, failure, failureWithActualExpected, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, inBinary, inHexadecimal, is, isElementOfCustomAssert, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, overridingErrorMessage, satisfies, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOfForProxy, satisfiesForProxy, setCustomRepresentation, setDescriptionConsumer, setPrintAssertionsDescription, throwAssertionError, usingComparator, usingComparator, usingDefaultComparator, usingRecursiveAssertion, usingRecursiveAssertion, usingRecursiveComparison, usingRecursiveComparison, withFailMessage, withFailMessage, withRepresentation, withThreadDumpOnError
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
Methods inherited from interface org.assertj.core.api.Descriptable
as, as, as, describedAs
-
Constructor Details
-
AbstractClassAssert
-
-
Method Details
-
isAssignableFrom
Verifies that the actualClass
is assignable from othersClass
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:
AssertionError
- if the actualClass
isnull
.IllegalArgumentException
- if noothers
classes have been specified.AssertionError
- if the actualClass
is not assignable from all of theothers
classes.- See Also:
-
isAssignableTo
Verifies that theClass
under test is assignable to the givenClass
.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:
AssertionError
- if the actualClass
isnull
.IllegalArgumentException
- ifother
is null.AssertionError
- if the actualClass
is not assignable to theothers
class.- Since:
- 3.24.0
- See Also:
-
isNotInterface
Verifies that the actualClass
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
is not an interface.
-
isInterface
Verifies that the actualClass
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
is not an interface.
-
isAbstract
Verifies that the actualClass
is abstract (hasabstract
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
is not abstract.- Since:
- 3.12.0
-
isAnnotation
Verifies that the actualClass
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
is not an annotation.
-
isNotAnnotation
Verifies that the actualClass
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
is an annotation.
-
isFinal
Verifies that the actualClass
is final (hasfinal
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
is not final.
-
isNotFinal
Verifies that the actualClass
is not final (does not havefinal
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
is final.
-
isPublic
Verifies that the actualClass
is public (haspublic
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
is not public.- Since:
- 2.7.0 / 3.7.0
-
isProtected
Verifies that the actualClass
is protected (hasprotected
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
is not protected.- Since:
- 2.7.0 / 3.7.0
-
isPackagePrivate
Verifies that the actualClass
is package-private (has no 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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
is not package-private.- Since:
- 3.15.0
-
isStatic
Verifies that the actualClass
is static (hasstatic
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
is not static.- Since:
- 3.23.0
-
isNotStatic
Verifies that the actualClass
is not static (does not havestatic
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
is static.- Since:
- 3.23.0
-
hasAnnotations
Verifies that the actualClass
has the givenAnnotation
s.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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
doesn't contains all of these annotations.
-
hasAnnotationsForProxy
-
hasAnnotation
Verifies that the actualClass
has the givenAnnotation
.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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
doesn't contains all of these annotations.
-
hasSuperclass
Verifies that the actualClass
has the given class as direct superclass (as inClass.getSuperclass()
).The
superclass
should always be notnull
, usehasNoSuperclass()
to verify the absence of the superclass.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:
NullPointerException
- ifsuperclass
isnull
.AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
doesn't have the given class as direct superclass.- Since:
- 3.15.0
- See Also:
-
hasNoSuperclass
Verifies that the actualClass
has no superclass (as inClass.getSuperclass()
, whennull
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
has a superclass.- Since:
- 3.15.0
- See Also:
-
hasFields
Deprecated.usehasPublicFields(String...)
instead.- Parameters:
fields
- the fields who must be in the class.- Returns:
this
assertions object
-
hasPublicFields
Verifies that the actualClass
has the given accessible public fields (as inClass.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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
doesn't contain all of the fields.- See Also:
-
hasOnlyPublicFields
Verifies that the actualClass
only has the given accessible public fields (as inClass.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:
AssertionError
- ifactual
isnull
.AssertionError
- if fields are not all the actualClass
's accessible public fields.- Since:
- 2.7.0 / 3.7.0
- See Also:
-
hasDeclaredFields
Verifies that the actualClass
has the given declared fields (as inClass.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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
doesn't contains all of the field.- See Also:
-
hasOnlyDeclaredFields
Verifies that the actualClass
only has the given declaredfields
and nothing more in any order (as inClass.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:
AssertionError
- ifactual
isnull
.AssertionError
- if fields are not all the declared fields of the actualClass
.- Since:
- 2.7.0 / 3.7.0
- See Also:
-
hasMethods
Verifies that the actualClass
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
doesn't contains all of the method names.- Since:
- 2.7.0 / 3.7.0
-
hasDeclaredMethods
Verifies that the actualClass
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
doesn't contains all of the given methods.- Since:
- 2.7.0 / 3.7.0
-
hasPublicMethods
Verifies that the actualClass
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:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
doesn't contains all of the given public methods.- Since:
- 2.7.0 / 3.7.0
-
hasPackage
Verifies that the actualClass
has the given package name (as inClass.getPackage()
).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:
packageName
- the package name the class should have- Returns:
this
assertions object- Throws:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
does not have the given package.- Since:
- 3.18.0
-
hasPackage
Verifies that the actualClass
has the given package (as inClass.getPackage()
).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:
aPackage
- the package the class should have- Returns:
this
assertions object- Throws:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
does not have the given package.- Since:
- 3.18.0
-
hasPublicFields(String...)
instead.