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
Class
es.-
Field Summary
FieldsFields inherited from class org.assertj.core.api.AbstractAssert
actual, conditions, info, myself, objects
-
Constructor Summary
Constructors -
Method Summary
Modifier and TypeMethodDescriptionhasAnnotation
(Class<? extends Annotation> annotation) Verifies that the actualClass
has the givenAnnotation
.hasAnnotations
(Class<? extends Annotation>... annotations) Verifies that the actualClass
has the givenAnnotation
s.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.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.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.Verifies that the actualClass
is an annotation.isAssignableFrom
(Class<?>... others) Verifies that the actualClass
is assignable from othersClass
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 protected (hasprotected
modifier).isPublic()
Verifies that the actualClass
is public (haspublic
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
-
Field Details
-
classes
Classes classes
-
-
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 assertion 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:
-
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();
- 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();
- Throws:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
is not an interface.
-
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();
- 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();
- 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();
- 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();
- 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();
- 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();
- Throws:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
is not protected.- Since:
- 2.7.0 / 3.7.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- Throws:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
doesn't contains all of these annotations.
-
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- Throws:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
doesn't contains all of these annotations.
-
hasFields
Deprecated.usehasPublicFields(String...)
instead. -
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.- 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.- 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.- 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.- 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.- 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.- 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.- Throws:
AssertionError
- ifactual
isnull
.AssertionError
- if the actualClass
doesn't contains all of the given public methods.- Since:
- 2.7.0 / 3.7.0
-
hasPublicFields(String...)
instead.