Package com.tngtech.archunit.lang.syntax.elements

Interface ClassesShould

@PublicAPI(usage=ACCESS)
public interface ClassesShould

Method Summary

Modifier and Type	Method	Description
ClassesThat<ClassesShouldConjunction>	accessClassesThat()	Asserts that all classes selected by this rule access certain classes (compare onlyAccessClassesThat()). NOTE: This usually makes more sense the negated way, e.g.
ClassesShouldConjunction	accessClassesThat(DescribedPredicate<? super JavaClass> predicate)	Asserts that all classes selected by this rule access certain classes (compare onlyAccessClassesThat(DescribedPredicate). NOTE: This usually makes more sense the negated way, e.g.
ClassesShouldConjunction	accessField(Class<?> owner, String fieldName)	Matches against all accesses (setting or getting) of a specific field.
ClassesShouldConjunction	accessField(String ownerName, String fieldName)	Matches against all accesses (setting or getting) of a specific field.
ClassesShouldConjunction	accessFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate)	Matches against accessing fields, where origin (a method or constructor) and target (a field) can be freely restricted by the supplied predicate.
ClassesShouldConjunction	accessTargetWhere(DescribedPredicate<? super JavaAccess<?>> predicate)	Matches against access of arbitrary targets (compare AccessTarget) where origin (a method or constructor) and target (a field, method or constructor) can be freely restricted by the supplied predicate.
ClassesShouldConjunction	be(Class<?> clazz)	Asserts that the rule matches exactly the given class.
ClassesShouldConjunction	be(String className)	Asserts that the rule matches exactly the class with the given fully qualified class name.
ClassesShouldConjunction	beAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)	Asserts that classes are annotated with a certain annotation, where matching annotations are determined by the supplied predicate.
ClassesShouldConjunction	beAnnotatedWith(Class<? extends Annotation> annotationType)	Asserts that classes are annotated with a certain type of annotation.
ClassesShouldConjunction	beAnnotatedWith(String annotationTypeName)	Asserts that classes are annotated with a certain type of annotation.
ClassesShouldConjunction	beAnonymousClasses()
ClassesShouldConjunction	beAssignableFrom(DescribedPredicate<? super JavaClass> predicate)	Asserts that classes are assignable from a certain type matching the given predicate.
ClassesShouldConjunction	beAssignableFrom(Class<?> type)	Asserts that classes are assignable from a certain type (compare Class.isAssignableFrom(Class) to terminology).
ClassesShouldConjunction	beAssignableFrom(String typeName)	Asserts that classes are assignable from a certain type with the given type name.
ClassesShouldConjunction	beAssignableTo(DescribedPredicate<? super JavaClass> predicate)	Asserts that classes are assignable to a certain type matching the given predicate.
ClassesShouldConjunction	beAssignableTo(Class<?> type)	Asserts that classes are assignable to a certain type (compare Class.isAssignableFrom(Class) to terminology).
ClassesShouldConjunction	beAssignableTo(String typeName)	Asserts that classes are assignable to a certain type with the given type name.
ClassesShouldConjunction	beEnums()	Asserts that classes are enums.
ClassesShouldConjunction	beInnerClasses()
ClassesShouldConjunction	beInterfaces()	Asserts that classes are interfaces.
ClassesShouldConjunction	beLocalClasses()
ClassesShouldConjunction	beMemberClasses()
ClassesShouldConjunction	beMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)	Asserts that classes are meta-annotated with a certain annotation, where matching meta-annotations are determined by the supplied predicate.
ClassesShouldConjunction	beMetaAnnotatedWith(Class<? extends Annotation> annotationType)	Asserts that classes are meta-annotated with a certain type of annotation.
ClassesShouldConjunction	beMetaAnnotatedWith(String annotationTypeName)	Asserts that classes are meta-annotated with a certain type of annotation.
ClassesShouldConjunction	beNestedClasses()
ClassesShouldConjunction	bePackagePrivate()	Asserts that classes are package private.
ClassesShouldConjunction	bePrivate()	Asserts that classes are private.
ClassesShouldConjunction	beProtected()	Asserts that classes are protected.
ClassesShouldConjunction	bePublic()	Asserts that classes are public.
ClassesShouldConjunction	beRecords()	Asserts that classes are records.
ClassesShouldConjunction	beTopLevelClasses()
ClassesShouldConjunction	callCodeUnitWhere(DescribedPredicate<? super JavaCall<?>> predicate)	Matches against code unit calls (compare JavaCodeUnit) where origin (a code unit) and target (a code unit) can be freely restricted by the supplied predicate.
ClassesShouldConjunction	callConstructor(Class<?> owner, Class<?>... parameterTypes)	Matches against a constructor call to a specific constructor (e.g.
ClassesShouldConjunction	callConstructor(String ownerName, String... parameterTypeNames)	Matches against constructor call to a specific constructor (e.g.
ClassesShouldConjunction	callConstructorWhere(DescribedPredicate<? super JavaConstructorCall> predicate)	Matches against constructor calls where origin (a method or constructor) and target (a constructor) can be freely restricted by the supplied predicate.
ClassesShouldConjunction	callMethod(Class<?> owner, String methodName, Class<?>... parameterTypes)	Matches against a method call to a specific method (e.g.
ClassesShouldConjunction	callMethod(String ownerName, String methodName, String... parameterTypeNames)	Matches against method call to a specific method (e.g.
ClassesShouldConjunction	callMethodWhere(DescribedPredicate<? super JavaMethodCall> predicate)	Matches against method calls where origin (a method or constructor) and target (a method) can be freely restricted by the supplied predicate.
ClassesShouldConjunction	containNumberOfElements(DescribedPredicate<? super Integer> predicate)	Asserts that the number of classes checked by this rule conforms to the supplied predicate.
ClassesThat<ClassesShouldConjunction>	dependOnClassesThat()	Asserts that all classes selected by this rule depend on certain classes. NOTE: This usually makes more sense the negated way, e.g.
ClassesShouldConjunction	dependOnClassesThat(DescribedPredicate<? super JavaClass> predicate)	Asserts that all classes selected by this rule depend on certain classes. NOTE: This usually makes more sense the negated way, e.g.
ClassesShouldConjunction	getField(Class<?> owner, String fieldName)	Matches against getting of a specific field (e.g.
ClassesShouldConjunction	getField(String ownerName, String fieldName)	Matches against getting a specific field (e.g.
ClassesShouldConjunction	getFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate)	Matches against getting of fields, where origin (a method or constructor) and target (a field) can be freely restricted by the supplied predicate.
ClassesShouldConjunction	haveFullyQualifiedName(String name)	Asserts that classes have a certain fully qualified class name.
ClassesShouldConjunction	haveModifier(JavaModifier modifier)	Asserts that classes have a certain JavaModifier (e.g.
ClassesShouldConjunction	haveNameMatching(String regex)	Asserts that classes have a fully qualified class name matching a given regular expression.
ClassesShouldConjunction	haveNameNotMatching(String regex)	Asserts that classes have a fully qualified class name not matching a given regular expression.
ClassesShouldConjunction	haveOnlyFinalFields()	Asserts that classes have only final fields.
ClassesShouldConjunction	haveOnlyPrivateConstructors()	Asserts that classes have only private constructors.
ClassesShouldConjunction	haveSimpleName(String name)	Asserts that classes have a certain simple class name.
ClassesShouldConjunction	haveSimpleNameContaining(String infix)	Asserts that classes' simple class names contain the specified infix.
ClassesShouldConjunction	haveSimpleNameEndingWith(String suffix)	Asserts that classes' simple class names end with a given suffix.
ClassesShouldConjunction	haveSimpleNameNotContaining(String infix)	Asserts that classes' simple class names do not contain the specified infix.
ClassesShouldConjunction	haveSimpleNameNotEndingWith(String suffix)	Asserts that classes' simple class names do not end with a given suffix.
ClassesShouldConjunction	haveSimpleNameNotStartingWith(String prefix)	Asserts that classes' simple class names do not start with a given prefix.
ClassesShouldConjunction	haveSimpleNameStartingWith(String prefix)	Asserts that classes' simple class names start with a given prefix.
ClassesShouldConjunction	implement(DescribedPredicate<? super JavaClass> predicate)	Asserts that classes implement a certain interface matching the given predicate.
ClassesShouldConjunction	implement(Class<?> type)	Asserts that classes implement a certain interface.
ClassesShouldConjunction	implement(String typeName)	Asserts that classes implement a certain interface with the given type name.
ClassesShouldConjunction	notBe(Class<?> clazz)	Asserts that the rule does not match the given class.
ClassesShouldConjunction	notBe(String className)	Asserts that the rule does not match the class with the given fully qualified class name.
ClassesShouldConjunction	notBeAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)	Asserts that classes are not annotated with a certain annotation, where matching annotations are determined by the supplied predicate.
ClassesShouldConjunction	notBeAnnotatedWith(Class<? extends Annotation> annotationType)	Asserts that classes are not annotated with a certain type of annotation.
ClassesShouldConjunction	notBeAnnotatedWith(String annotationTypeName)	Asserts that classes are not annotated with a certain type of annotation.
ClassesShouldConjunction	notBeAnonymousClasses()
ClassesShouldConjunction	notBeAssignableFrom(DescribedPredicate<? super JavaClass> predicate)	Asserts that classes are not assignable from a certain type matching the given predicate.
ClassesShouldConjunction	notBeAssignableFrom(Class<?> type)	Asserts that classes are not assignable from a certain type.
ClassesShouldConjunction	notBeAssignableFrom(String typeName)	Asserts that classes are not assignable from a certain type with the given type name.
ClassesShouldConjunction	notBeAssignableTo(DescribedPredicate<? super JavaClass> predicate)	Asserts that classes are not assignable to a certain type matching the given predicate.
ClassesShouldConjunction	notBeAssignableTo(Class<?> type)	Asserts that classes are not assignable to a certain type.
ClassesShouldConjunction	notBeAssignableTo(String typeName)	Asserts that classes are not assignable to a certain type with the given type name.
ClassesShouldConjunction	notBeEnums()	Asserts that classes are not enums.
ClassesShouldConjunction	notBeInnerClasses()
ClassesShouldConjunction	notBeInterfaces()	Asserts that classes are not interfaces.
ClassesShouldConjunction	notBeLocalClasses()
ClassesShouldConjunction	notBeMemberClasses()
ClassesShouldConjunction	notBeMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)	Asserts that classes are not meta-annotated with a certain annotation, where matching meta-annotations are determined by the supplied predicate.
ClassesShouldConjunction	notBeMetaAnnotatedWith(Class<? extends Annotation> annotationType)	Asserts that classes are not meta-annotated with a certain type of annotation.
ClassesShouldConjunction	notBeMetaAnnotatedWith(String annotationTypeName)	Asserts that classes are not meta-annotated with a certain type of annotation.
ClassesShouldConjunction	notBeNestedClasses()
ClassesShouldConjunction	notBePackagePrivate()	Asserts that classes are non-package private.
ClassesShouldConjunction	notBePrivate()	Asserts that classes are non-private.
ClassesShouldConjunction	notBeProtected()	Asserts that classes are non-protected.
ClassesShouldConjunction	notBePublic()	Asserts that classes are non-public.
ClassesShouldConjunction	notBeRecords()	Asserts that classes are not records.
ClassesShouldConjunction	notBeTopLevelClasses()
ClassesShouldConjunction	notHaveFullyQualifiedName(String name)	Asserts that classes do not have a certain fully qualified class name.
ClassesShouldConjunction	notHaveModifier(JavaModifier modifier)	Asserts that classes do not have a certain JavaModifier (e.g.
ClassesShouldConjunction	notHaveSimpleName(String name)	Asserts that classes do not have a certain simple class name.
ClassesShouldConjunction	notImplement(DescribedPredicate<? super JavaClass> predicate)	Asserts that classes do not implement a certain interface matching the given predicate.
ClassesShouldConjunction	notImplement(Class<?> type)	Asserts that classes do not implement a certain interface.
ClassesShouldConjunction	notImplement(String typeName)	Asserts that classes do not implement a certain interface with the given type name.
ClassesThat<ClassesShouldConjunction>	onlyAccessClassesThat()	Asserts that all classes selected by this rule ONLY access certain classes (compare accessClassesThat()). E.g.
ClassesShouldConjunction	onlyAccessClassesThat(DescribedPredicate<? super JavaClass> predicate)	Asserts that all classes selected by this rule ONLY access certain classes (compare accessClassesThat(DescribedPredicate)). E.g.
ClassesShouldConjunction	onlyAccessFieldsThat(DescribedPredicate<? super JavaField> predicate)	Matches all field accesses against the supplied predicate.
ClassesShouldConjunction	onlyAccessMembersThat(DescribedPredicate<? super JavaMember> predicate)	Matches all members calls against the supplied predicate.
OnlyBeAccessedSpecification<ClassesShouldConjunction>	onlyBeAccessed()	Asserts that only certain classes access the classes selected by this rule. E.g.
ClassesShouldConjunction	onlyCallCodeUnitsThat(DescribedPredicate<? super JavaCodeUnit> predicate)	Matches all code unit calls against the supplied predicate.
ClassesShouldConjunction	onlyCallConstructorsThat(DescribedPredicate<? super JavaConstructor> predicate)	Matches all constructor calls against the supplied predicate.
ClassesShouldConjunction	onlyCallMethodsThat(DescribedPredicate<? super JavaMethod> predicate)	Matches all method calls against the supplied predicate.
ClassesThat<ClassesShouldConjunction>	onlyDependOnClassesThat()	Asserts that all classes selected by this rule ONLY depend on certain classes (compare dependOnClassesThat()). E.g.
ClassesShouldConjunction	onlyDependOnClassesThat(DescribedPredicate<? super JavaClass> predicate)	Asserts that all classes selected by this rule ONLY depend on certain classes (compare dependOnClassesThat(DescribedPredicate)). E.g.
ClassesThat<ClassesShouldConjunction>	onlyHaveDependentClassesThat()	Asserts that only certain classes depend on the classes selected by this rule. E.g.
ClassesShouldConjunction	onlyHaveDependentClassesThat(DescribedPredicate<? super JavaClass> predicate)	Asserts that only certain classes depend on the classes selected by this rule. E.g.
ClassesShouldConjunction	resideInAnyPackage(String... packageIdentifiers)	Asserts that classes reside in a package matching any of the supplied package identifiers.
ClassesShouldConjunction	resideInAPackage(String packageIdentifier)	Asserts that classes reside in a package matching the supplied package identifier.
ClassesShouldConjunction	resideOutsideOfPackage(String packageIdentifier)	Asserts that classes do not reside in a package matching the supplied package identifier.
ClassesShouldConjunction	resideOutsideOfPackages(String... packageIdentifiers)	Asserts that classes do not reside in a package matching any of the supplied package identifiers.
ClassesShouldConjunction	setField(Class<?> owner, String fieldName)	Matches against setting a specific field (e.g.
ClassesShouldConjunction	setField(String ownerName, String fieldName)	Matches against setting a specific field (e.g.
ClassesShouldConjunction	setFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate)	Matches against setting of fields, where origin (a method or constructor) and target (a field) can be freely restricted by the supplied predicate.
ClassesThat<ClassesShouldConjunction>	transitivelyDependOnClassesThat()	Asserts that all classes selected by this rule transitively depend on any matching classes. It focuses on detecting all direct dependencies of the selected classes that are themselves matched or have any transitive dependencies on matched classes.
ClassesShouldConjunction	transitivelyDependOnClassesThat(DescribedPredicate<? super JavaClass> predicate)	Asserts that all classes selected by this rule transitively depend on any matching classes. It focuses on detecting all direct dependencies of the selected classes that are themselves matched or have any transitive dependencies on matched classes.

Method Details

haveFullyQualifiedName

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction haveFullyQualifiedName(String name)

Asserts that classes have a certain fully qualified class name.

Parameters:

name - The fully qualified class name

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notHaveFullyQualifiedName

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notHaveFullyQualifiedName(String name)

Asserts that classes do not have a certain fully qualified class name.

Parameters:

name - The fully qualified class name

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

haveSimpleName

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction haveSimpleName(String name)

Asserts that classes have a certain simple class name.

Parameters:

name - The simple class name

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notHaveSimpleName

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notHaveSimpleName(String name)

Asserts that classes do not have a certain simple class name.

Parameters:

name - The simple class name

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

haveSimpleNameStartingWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction haveSimpleNameStartingWith(String prefix)

Asserts that classes' simple class names start with a given prefix.

Parameters:

prefix - A prefix the simple class name should start with

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

haveSimpleNameNotStartingWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction haveSimpleNameNotStartingWith(String prefix)

Asserts that classes' simple class names do not start with a given prefix.

Parameters:

prefix - A prefix the simple class name should not start with

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

haveSimpleNameContaining

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction haveSimpleNameContaining(String infix)

Asserts that classes' simple class names contain the specified infix.

Parameters:

infix - An infix the simple class name should contain

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

haveSimpleNameNotContaining

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction haveSimpleNameNotContaining(String infix)

Asserts that classes' simple class names do not contain the specified infix.

Parameters:

infix - An infix the simple class name should not contain

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

haveSimpleNameEndingWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction haveSimpleNameEndingWith(String suffix)

Asserts that classes' simple class names end with a given suffix.

Parameters:

suffix - A suffix the simple class name should end with

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

haveSimpleNameNotEndingWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction haveSimpleNameNotEndingWith(String suffix)

Asserts that classes' simple class names do not end with a given suffix.

Parameters:

suffix - A suffix the simple class name should not end with

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

haveNameMatching

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction haveNameMatching(String regex)

Asserts that classes have a fully qualified class name matching a given regular expression.

Parameters:

regex - A regular expression

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

haveNameNotMatching

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction haveNameNotMatching(String regex)

Asserts that classes have a fully qualified class name not matching a given regular expression.

Parameters:

regex - A regular expression

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

resideInAPackage

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction resideInAPackage(String packageIdentifier)

Asserts that classes reside in a package matching the supplied package identifier.

Parameters:

packageIdentifier - A string identifying packages, for details see PackageMatcher

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

resideInAnyPackage

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction resideInAnyPackage(String... packageIdentifiers)

Asserts that classes reside in a package matching any of the supplied package identifiers.

Parameters:

packageIdentifiers - Strings identifying packages, for details see PackageMatcher

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

resideOutsideOfPackage

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction resideOutsideOfPackage(String packageIdentifier)

Asserts that classes do not reside in a package matching the supplied package identifier.

Parameters:

packageIdentifier - A string identifying packages, for details see PackageMatcher

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

resideOutsideOfPackages

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction resideOutsideOfPackages(String... packageIdentifiers)

Asserts that classes do not reside in a package matching any of the supplied package identifiers.

Parameters:

packageIdentifiers - Strings identifying packages, for details see PackageMatcher

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

bePublic

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction bePublic()

Asserts that classes are public.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notBePublic

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBePublic()

Asserts that classes are non-public.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

beProtected

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beProtected()

Asserts that classes are protected.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notBeProtected

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeProtected()

Asserts that classes are non-protected.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

bePackagePrivate

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction bePackagePrivate()

Asserts that classes are package private.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notBePackagePrivate

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBePackagePrivate()

Asserts that classes are non-package private.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

bePrivate

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction bePrivate()

Asserts that classes are private.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notBePrivate

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBePrivate()

Asserts that classes are non-private.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

haveOnlyFinalFields

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction haveOnlyFinalFields()

Asserts that classes have only final fields.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

haveOnlyPrivateConstructors

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction haveOnlyPrivateConstructors()

Asserts that classes have only private constructors.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

haveModifier

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction haveModifier(JavaModifier modifier)

Asserts that classes have a certain JavaModifier (e.g. JavaModifier.ABSTRACT).

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notHaveModifier

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notHaveModifier(JavaModifier modifier)

Asserts that classes do not have a certain JavaModifier (e.g. JavaModifier.ABSTRACT).

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

beAnnotatedWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAnnotatedWith(Class<? extends Annotation> annotationType)

Asserts that classes are annotated with a certain type of annotation.

Parameters:

annotationType - Specific type of Annotation

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notBeAnnotatedWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeAnnotatedWith(Class<? extends Annotation> annotationType)

Asserts that classes are not annotated with a certain type of annotation.

Parameters:

annotationType - Specific type of Annotation

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

beAnnotatedWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAnnotatedWith(String annotationTypeName)

Asserts that classes are annotated with a certain type of annotation.

Parameters:

annotationTypeName - Fully qualified class name of a specific type of Annotation

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notBeAnnotatedWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeAnnotatedWith(String annotationTypeName)

Asserts that classes are not annotated with a certain type of annotation.

Parameters:

annotationTypeName - Fully qualified class name of a specific type of Annotation

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

beAnnotatedWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)

Asserts that classes are annotated with a certain annotation, where matching annotations are determined by the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaAnnotation can be found within one of the respective ancestors like HasType.Predicates.

Parameters:

predicate - A predicate defining matching JavaAnnotations

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notBeAnnotatedWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)

Asserts that classes are not annotated with a certain annotation, where matching annotations are determined by the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaAnnotation can be found within one of the respective ancestors like HasType.Predicates.

Parameters:

predicate - A predicate defining matching JavaAnnotations

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

beMetaAnnotatedWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beMetaAnnotatedWith(Class<? extends Annotation> annotationType)

Asserts that classes are meta-annotated with a certain type of annotation. A meta-annotation is an annotation that is declared on another annotation.

The assertion is also successful if classes are directly annotated with the supplied annotation type.

Parameters:

annotationType - Specific type of Annotation

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notBeMetaAnnotatedWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeMetaAnnotatedWith(Class<? extends Annotation> annotationType)

Asserts that classes are not meta-annotated with a certain type of annotation. A meta-annotation is an annotation that is declared on another annotation.

The assertion also fails if classes are directly annotated with the supplied annotation type.

Parameters:

annotationType - Specific type of Annotation

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

beMetaAnnotatedWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beMetaAnnotatedWith(String annotationTypeName)

Asserts that classes are meta-annotated with a certain type of annotation. A meta-annotation is an annotation that is declared on another annotation.

The assertion is also successful if classes are directly annotated with the supplied annotation type.

Parameters:

annotationTypeName - Fully qualified class name of a specific type of Annotation

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notBeMetaAnnotatedWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeMetaAnnotatedWith(String annotationTypeName)

Asserts that classes are not meta-annotated with a certain type of annotation. A meta-annotation is an annotation that is declared on another annotation.

The assertion also fails if classes are directly annotated with the supplied annotation type.

Parameters:

annotationTypeName - Fully qualified class name of a specific type of Annotation

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

beMetaAnnotatedWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)

Asserts that classes are meta-annotated with a certain annotation, where matching meta-annotations are determined by the supplied predicate. A meta-annotation is an annotation that is declared on another annotation.

The assertion is also successful if classes are directly annotated with an annotation matching the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaAnnotation can be found within one of the respective ancestors like HasType.Predicates.

Parameters:

predicate - A predicate defining matching JavaAnnotations

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notBeMetaAnnotatedWith

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)

Asserts that classes are not meta-annotated with a certain annotation, where matching meta-annotations are determined by the supplied predicate. A meta-annotation is an annotation that is declared on another annotation.

The assertion also fails if classes are directly annotated with an annotation matching the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaAnnotation can be found within one of the respective ancestors like HasType.Predicates.

Parameters:

predicate - A predicate defining matching JavaAnnotations

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

implement

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction implement(Class<?> type)

Asserts that classes implement a certain interface. Note that this only matches non-interface classes that implement the supplied interface type (compare JavaClass.Predicates.implement(Class). For general assignability see beAssignableTo(Class)

Parameters:

type - An interface imported classes should implement

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.implement(Class)

notImplement

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notImplement(Class<?> type)

Asserts that classes do not implement a certain interface. This is the negation of implement(Class).

Parameters:

type - An interface imported classes should NOT implement

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.notImplement(Class)

implement

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction implement(String typeName)

Asserts that classes implement a certain interface with the given type name. This is equivalent to implement(Class), but does not depend on having a certain type on the classpath. Note that this only matches non-interface classes that implement the supplied interface typeName (compare JavaClass.Predicates.implement(Class). For general assignability see beAssignableTo(String)

Parameters:

typeName - Name of an interface imported classes should implement

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.implement(String)

notImplement

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notImplement(String typeName)

Asserts that classes do not implement a certain interface with the given type name. This is equivalent to notImplement(Class), but does not depend on having a certain type on the classpath.

Parameters:

typeName - Name of an interface imported classes should NOT implement

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.notImplement(String)

implement

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction implement(DescribedPredicate<? super JavaClass> predicate)

Asserts that classes implement a certain interface matching the given predicate. For example, a call with HasName.Predicates.name(String) would be equivalent to implement(String), but the approach is a lot more generic. Note that this only matches non-interface classes that implement an interface matching the predicate (compare JavaClass.Predicates.implement(Class). For general assignability see beAssignableTo(DescribedPredicate)

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - A predicate identifying an interface imported classes should implement

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.implement(DescribedPredicate)

notImplement

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notImplement(DescribedPredicate<? super JavaClass> predicate)

Asserts that classes do not implement a certain interface matching the given predicate. This is the negation of implement(DescribedPredicate).

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - A predicate identifying an interface imported classes should NOT implement

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.notImplement(DescribedPredicate)

beAssignableTo

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAssignableTo(Class<?> type)

Asserts that classes are assignable to a certain type (compare Class.isAssignableFrom(Class) to terminology). A simple example for this predicate would be

   assignableTo(Object.class).test(importedStringClass); // --> returns true
   assignableTo(String.class).test(importedStringClass); // --> returns true
   assignableTo(List.class).test(importedStringClass); // --> returns false
 

Parameters:

type - An upper type bound to match imported classes against (imported subtypes will match)

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.beAssignableTo(Class)

notBeAssignableTo

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeAssignableTo(Class<?> type)

Asserts that classes are not assignable to a certain type. This is the negation of beAssignableTo(Class).

Parameters:

type - An upper type bound imported classes should NOT have

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.notBeAssignableTo(Class)

beAssignableTo

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAssignableTo(String typeName)

Asserts that classes are assignable to a certain type with the given type name. This is equivalent to beAssignableTo(Class), but does not depend on having a certain type on the classpath.

Parameters:

typeName - Name of an upper type bound to match imported classes against (imported subtypes will match)

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.beAssignableTo(String)

notBeAssignableTo

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeAssignableTo(String typeName)

Asserts that classes are not assignable to a certain type with the given type name. This is equivalent to notBeAssignableTo(Class), but does not depend on having a certain type on the classpath.

Parameters:

typeName - Name of an upper type bound imported classes should NOT have

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.notBeAssignableTo(String)

beAssignableTo

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAssignableTo(DescribedPredicate<? super JavaClass> predicate)

Asserts that classes are assignable to a certain type matching the given predicate. For example, a call with HasName.Predicates.name(String) would be equivalent to beAssignableTo(String), but the approach is a lot more generic.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - A predicate identifying an upper type bound to match imported classes against (imported subtypes will match)

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.beAssignableTo(DescribedPredicate)

notBeAssignableTo

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeAssignableTo(DescribedPredicate<? super JavaClass> predicate)

Asserts that classes are not assignable to a certain type matching the given predicate. This is the negation of beAssignableTo(DescribedPredicate).

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - A predicate identifying an upper type bound imported classes should NOT have

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.notBeAssignableTo(DescribedPredicate)

beAssignableFrom

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAssignableFrom(Class<?> type)

Asserts that classes are assignable from a certain type (compare Class.isAssignableFrom(Class) to terminology). This is roughly equivalent to the use of reflection:

   someClass.class.isAssignableFrom(type);
 

A simple example for this predicate would be

   assignableFrom(ArrayList.class).test(importedArrayListClass); // --> returns true
   assignableFrom(ArrayList.class).test(importedListClass); // --> returns true
   assignableFrom(ArrayList.class).test(importedStringClass); // --> returns false
 

Parameters:

type - A lower type bound to match imported classes against (imported supertypes will match)

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.beAssignableFrom(Class)

notBeAssignableFrom

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeAssignableFrom(Class<?> type)

Asserts that classes are not assignable from a certain type. This is the negation of beAssignableFrom(Class).

Parameters:

type - A lower type bound imported classes should NOT have

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.notBeAssignableFrom(Class)

beAssignableFrom

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAssignableFrom(String typeName)

Asserts that classes are assignable from a certain type with the given type name. This is equivalent to beAssignableFrom(Class), but does not depend on having a certain type on the classpath.

Parameters:

typeName - Name of a lower type bound to match imported classes against (imported supertypes will match)

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.beAssignableFrom(String)

notBeAssignableFrom

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeAssignableFrom(String typeName)

Asserts that classes are not assignable from a certain type with the given type name. This is equivalent to notBeAssignableFrom(Class), but does not depend on having a certain type on the classpath.

Parameters:

typeName - Name of a lower type bound imported classes should NOT have

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.notBeAssignableFrom(String)

beAssignableFrom

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAssignableFrom(DescribedPredicate<? super JavaClass> predicate)

Asserts that classes are assignable from a certain type matching the given predicate. For example, a call with HasName.Predicates.name(String) would be equivalent to beAssignableFrom(String), but the approach is a lot more generic.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - A predicate identifying a lower type bound to match imported classes against (imported supertypes will match)

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.beAssignableFrom(DescribedPredicate)

notBeAssignableFrom

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeAssignableFrom(DescribedPredicate<? super JavaClass> predicate)

Asserts that classes are not assignable from a certain type matching the given predicate. This is the negation of beAssignableFrom(DescribedPredicate).

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - A predicate identifying a lower type bound imported classes should NOT have

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• ArchConditions.notBeAssignableFrom(DescribedPredicate)

accessField

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction accessField(Class<?> owner,
 String fieldName)

Matches against all accesses (setting or getting) of a specific field.

Parameters:

owner - The class declaring the field

fieldName - The name of the field to match

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

accessField

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction accessField(String ownerName,
 String fieldName)

Matches against all accesses (setting or getting) of a specific field.

Parameters:

ownerName - The fully qualified class name of the class declaring the field

fieldName - The name of the field to match

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

accessFieldWhere

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction accessFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate)

Matches against accessing fields, where origin (a method or constructor) and target (a field) can be freely restricted by the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaFieldAccess can be found within JavaFieldAccess.Predicates or one of the respective ancestors like JavaAccess.Predicates.

Parameters:

predicate - Determines which JavaFieldAccesses match the rule

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

onlyAccessFieldsThat

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction onlyAccessFieldsThat(DescribedPredicate<? super JavaField> predicate)

Matches all field accesses against the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaField can be found within JavaMember.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - Determines which JavaFields match the rule

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

getField

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction getField(Class<?> owner,
 String fieldName)

Matches against getting of a specific field (e.g. return someClass.someField;).

Parameters:

owner - The class declaring the field

fieldName - The name of the field to match

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

getField

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction getField(String ownerName,
 String fieldName)

Matches against getting a specific field (e.g. return someClass.someField;).

Parameters:

ownerName - The fully qualified class name of the class declaring the field

fieldName - The name of the field to match

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

getFieldWhere

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction getFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate)

Matches against getting of fields, where origin (a method or constructor) and target (a field) can be freely restricted by the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaFieldAccess can be found within JavaFieldAccess.Predicates or one of the respective ancestors like JavaAccess.Predicates.

Parameters:

predicate - Determines which JavaFieldAccesses match the rule

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

setField

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction setField(Class<?> owner,
 String fieldName)

Matches against setting a specific field (e.g. someClass.someField = newValue;).

Parameters:

owner - The class declaring the field

fieldName - The name of the field to match

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

setField

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction setField(String ownerName,
 String fieldName)

Matches against setting a specific field (e.g. someClass.someField = newValue;).

Parameters:

ownerName - The fully qualified class name of the class declaring the field

fieldName - The name of the field to match

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

setFieldWhere

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction setFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate)

Matches against setting of fields, where origin (a method or constructor) and target (a field) can be freely restricted by the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaFieldAccess can be found within JavaFieldAccess.Predicates or one of the respective ancestors like JavaAccess.Predicates.

Parameters:

predicate - Determines which JavaFieldAccesses match the rule

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

callMethod

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction callMethod(Class<?> owner,
 String methodName,
 Class<?>... parameterTypes)

Matches against a method call to a specific method (e.g. someClass.call();).

Parameters:

owner - Class declaring the method

methodName - The method name to match against

parameterTypes - The parameter types of the respective method

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

callMethod

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction callMethod(String ownerName,
 String methodName,
 String... parameterTypeNames)

Matches against method call to a specific method (e.g. someClass.call();).

Parameters:

ownerName - The fully qualified class name declaring the method

methodName - The method name to match against

parameterTypeNames - The fully qualified parameter type names

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

callMethodWhere

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction callMethodWhere(DescribedPredicate<? super JavaMethodCall> predicate)

Matches against method calls where origin (a method or constructor) and target (a method) can be freely restricted by the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaMethodCall can be found within JavaCall.Predicates or one of the respective ancestors like JavaAccess.Predicates.

Parameters:

predicate - Determines which JavaMethodCalls match the rule

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

onlyCallMethodsThat

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction onlyCallMethodsThat(DescribedPredicate<? super JavaMethod> predicate)

Matches all method calls against the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaMethod can be found within JavaCodeUnit.Predicates or one of the respective ancestors like JavaMember.Predicates.

Parameters:

predicate - Determines which JavaMethods match the rule

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

callConstructor

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction callConstructor(Class<?> owner,
 Class<?>... parameterTypes)

Matches against a constructor call to a specific constructor (e.g. new SomeClass();).

Parameters:

owner - Class declaring the constructor

parameterTypes - The parameter types of the respective constructor

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

callConstructor

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction callConstructor(String ownerName,
 String... parameterTypeNames)

Matches against constructor call to a specific constructor (e.g. new SomeClass();).

Parameters:

ownerName - The fully qualified class name declaring the constructor

parameterTypeNames - The fully qualified parameter type names

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

callConstructorWhere

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction callConstructorWhere(DescribedPredicate<? super JavaConstructorCall> predicate)

Matches against constructor calls where origin (a method or constructor) and target (a constructor) can be freely restricted by the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaConstructorCall can be found within JavaCall.Predicates or one of the respective ancestors like JavaAccess.Predicates.

Parameters:

predicate - Determines which JavaConstructorCalls match the rule

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

onlyCallConstructorsThat

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction onlyCallConstructorsThat(DescribedPredicate<? super JavaConstructor> predicate)

Matches all constructor calls against the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaConstructor can be found within JavaCodeUnit.Predicates or one of the respective ancestors like JavaMember.Predicates.

Parameters:

predicate - Determines which JavaConstructors match the rule

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

accessTargetWhere

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction accessTargetWhere(DescribedPredicate<? super JavaAccess<?>> predicate)

Matches against access of arbitrary targets (compare AccessTarget) where origin (a method or constructor) and target (a field, method or constructor) can be freely restricted by the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaAccess can be found within JavaAccess.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - Determines which JavaAccesses match the rule

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

onlyAccessMembersThat

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction onlyAccessMembersThat(DescribedPredicate<? super JavaMember> predicate)

Matches all members calls against the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaMember can be found within JavaMember.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - Determines which JavaMembers match the rule

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

callCodeUnitWhere

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction callCodeUnitWhere(DescribedPredicate<? super JavaCall<?>> predicate)

Matches against code unit calls (compare JavaCodeUnit) where origin (a code unit) and target (a code unit) can be freely restricted by the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaCall can be found within JavaCall.Predicates or one of the respective ancestors like JavaAccess.Predicates.

Parameters:

predicate - Determines which JavaCalls match the rule

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

onlyCallCodeUnitsThat

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction onlyCallCodeUnitsThat(DescribedPredicate<? super JavaCodeUnit> predicate)

Matches all code unit calls against the supplied predicate.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaCodeUnit can be found within JavaCodeUnit.Predicates or one of the respective ancestors like JavaMember.Predicates.

Parameters:

predicate - Determines which JavaCodeUnits match the rule

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

accessClassesThat

@PublicAPI(usage=ACCESS)
ClassesThat<ClassesShouldConjunction> accessClassesThat()

Asserts that all classes selected by this rule access certain classes (compare onlyAccessClassesThat()).
NOTE: This usually makes more sense the negated way, e.g.

 noClasses().should().accessClassesThat().haveFullyQualifiedName(String)
 

NOTE: 'access' refers only to violations by real accesses, i.e. accessing a field, and calling a method. Compare with dependOnClassesThat() that catches a wider variety of violations.

Returns:

A syntax element that allows choosing which classes should be accessed

accessClassesThat

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction accessClassesThat(DescribedPredicate<? super JavaClass> predicate)

Asserts that all classes selected by this rule access certain classes (compare onlyAccessClassesThat(DescribedPredicate).
NOTE: This usually makes more sense the negated way, e.g.

 noClasses().should().accessClassesThat(myPredicate)
 

NOTE: 'access' refers only to violations by real accesses, i.e. accessing a field, and calling a method. Compare with dependOnClassesThat(DescribedPredicate) that catches a wider variety of violations.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - Determines which JavaClasses match the access target

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

onlyAccessClassesThat

@PublicAPI(usage=ACCESS)
ClassesThat<ClassesShouldConjunction> onlyAccessClassesThat()

Asserts that all classes selected by this rule ONLY access certain classes (compare accessClassesThat()).
E.g.

 classes().should().onlyAccessClassesThat().haveFullyQualifiedName(String)
 

NOTE: 'access' refers only to violations by real accesses, i.e. accessing a field, and calling a method. Compare with onlyDependOnClassesThat()) that catches a wider variety of violations.

Returns:

A syntax element that allows choosing which classes should only be accessed

onlyAccessClassesThat

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction onlyAccessClassesThat(DescribedPredicate<? super JavaClass> predicate)

Asserts that all classes selected by this rule ONLY access certain classes (compare accessClassesThat(DescribedPredicate)).
E.g.

 classes().should().onlyAccessClassesThat(myPredicate)
 

NOTE: 'access' refers only to violations by real accesses, i.e. accessing a field, and calling a method. Compare with onlyDependOnClassesThat(DescribedPredicate) that catches a wider variety of violations.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - Determines which JavaClasses match the access target

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

dependOnClassesThat

@PublicAPI(usage=ACCESS)
ClassesThat<ClassesShouldConjunction> dependOnClassesThat()

Asserts that all classes selected by this rule depend on certain classes.
NOTE: This usually makes more sense the negated way, e.g.

 noClasses().should().dependOnClassesThat().haveFullyQualifiedName(String)
 

NOTE: 'dependOn' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc... Compare with accessClassesThat() that catches violations only by real accesses.

Returns:

A syntax element that allows choosing to which classes a dependency should exist

dependOnClassesThat

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction dependOnClassesThat(DescribedPredicate<? super JavaClass> predicate)

Asserts that all classes selected by this rule depend on certain classes.
NOTE: This usually makes more sense the negated way, e.g.

 noClasses().should().dependOnClassesThat(myPredicate)
 

NOTE: 'dependOn' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc... Compare with accessClassesThat(DescribedPredicate) that catches violations only by real accesses.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - Determines which JavaClasses match the dependency target

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

onlyDependOnClassesThat

@PublicAPI(usage=ACCESS)
ClassesThat<ClassesShouldConjunction> onlyDependOnClassesThat()

Asserts that all classes selected by this rule ONLY depend on certain classes (compare dependOnClassesThat()).
E.g.

 classes().should().onlyDependOnClassesThat().haveFullyQualifiedName(String)
 

NOTE: 'dependOn' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc... Compare with onlyAccessClassesThat() that catches violations only by real accesses.

Returns:

A syntax element that allows choosing to which classes a dependency should only exist

onlyDependOnClassesThat

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction onlyDependOnClassesThat(DescribedPredicate<? super JavaClass> predicate)

Asserts that all classes selected by this rule ONLY depend on certain classes (compare dependOnClassesThat(DescribedPredicate)).
E.g.

 classes().should().onlyDependOnClassesThat(myPredicate)
 

NOTE: 'dependOn' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc... Compare with onlyAccessClassesThat(DescribedPredicate) that catches violations only by real accesses.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - Determines which JavaClasses match the dependency target

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

transitivelyDependOnClassesThat

@PublicAPI(usage=ACCESS)
ClassesThat<ClassesShouldConjunction> transitivelyDependOnClassesThat()

Asserts that all classes selected by this rule transitively depend on any matching classes.
It focuses on detecting all direct dependencies of the selected classes that are themselves matched or have any transitive dependencies on matched classes. Thus, it doesn't discover all possible dependency paths but stops at the first match to be fast and resource-friendly.
NOTE: This usually makes more sense the negated way, e.g.

 noClasses().should().transitivelyDependOnClassesThat().haveFullyQualifiedName(String)
 

NOTE: 'dependOn' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc...

Returns:

A syntax element that allows choosing to which classes a transitive dependency should exist

transitivelyDependOnClassesThat

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction transitivelyDependOnClassesThat(DescribedPredicate<? super JavaClass> predicate)

Asserts that all classes selected by this rule transitively depend on any matching classes.
It focuses on detecting all direct dependencies of the selected classes that are themselves matched or have any transitive dependencies on matched classes. Thus, it doesn't discover all possible dependency paths but stops at the first match to be fast and resource-friendly.
NOTE: This usually makes more sense the negated way, e.g.

 noClasses().should().transitivelyDependOnClassesThat(myPredicate)
 

NOTE: 'dependOn' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc...

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - Determines which JavaClasses match the dependency target

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

onlyBeAccessed

@PublicAPI(usage=ACCESS)
OnlyBeAccessedSpecification<ClassesShouldConjunction> onlyBeAccessed()

Asserts that only certain classes access the classes selected by this rule.

E.g.

 onlyBeAccessed().byAnyPackage(String...)
 

NOTE: 'access' refers only to violations by real accesses, i.e. accessing a field, and calling a method. Compare with onlyHaveDependentClassesThat() that catches a wider variety of violations.

Returns:

A syntax element that allows restricting how classes should be accessed

onlyHaveDependentClassesThat

@PublicAPI(usage=ACCESS)
ClassesThat<ClassesShouldConjunction> onlyHaveDependentClassesThat()

Asserts that only certain classes depend on the classes selected by this rule.

E.g.

 classes().should().onlyHaveDependentClassesThat().haveFullyQualifiedName(String)
 

NOTE: 'depends' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc... Compare with onlyBeAccessed() that catches violations only by real accesses.

Returns:

A syntax element that allows choosing from which classes a dependency to these classes may exist

onlyHaveDependentClassesThat

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction onlyHaveDependentClassesThat(DescribedPredicate<? super JavaClass> predicate)

Asserts that only certain classes depend on the classes selected by this rule.

E.g.

 classes().should().onlyHaveDependentClassesThat(myPredicate)
 

NOTE: 'depends' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc... Compare with onlyBeAccessed().byClassesThat(DescribedPredicate) that catches violations only by real accesses.

Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.

Parameters:

predicate - Determines which JavaClasses match the dependency origin

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

beInterfaces

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beInterfaces()

Asserts that classes are interfaces.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notBeInterfaces

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeInterfaces()

Asserts that classes are not interfaces.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

beEnums

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beEnums()

Asserts that classes are enums.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notBeEnums

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeEnums()

Asserts that classes are not enums.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

beRecords

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beRecords()

Asserts that classes are records.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• JavaClass.isRecord()

notBeRecords

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeRecords()

Asserts that classes are not records.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

See Also:

• JavaClass.isRecord()

beTopLevelClasses

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beTopLevelClasses()

notBeTopLevelClasses

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeTopLevelClasses()

beNestedClasses

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beNestedClasses()

notBeNestedClasses

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeNestedClasses()

beMemberClasses

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beMemberClasses()

notBeMemberClasses

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeMemberClasses()

beInnerClasses

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beInnerClasses()

notBeInnerClasses

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeInnerClasses()

beAnonymousClasses

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAnonymousClasses()

notBeAnonymousClasses

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeAnonymousClasses()

beLocalClasses

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction beLocalClasses()

notBeLocalClasses

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeLocalClasses()

be

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction be(Class<?> clazz)

Asserts that the rule matches exactly the given class.

Parameters:

clazz - the only class the should be matched

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notBe

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBe(Class<?> clazz)

Asserts that the rule does not match the given class.

Parameters:

clazz - the class that should not be matched

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

be

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction be(String className)

Asserts that the rule matches exactly the class with the given fully qualified class name.

Parameters:

className - the name of the only class that should be matched.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

notBe

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBe(String className)

Asserts that the rule does not match the class with the given fully qualified class name.

Parameters:

className - the name of the class that should not be matched.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule

containNumberOfElements

@PublicAPI(usage=ACCESS)
ClassesShouldConjunction containNumberOfElements(DescribedPredicate<? super Integer> predicate)

Asserts that the number of classes checked by this rule conforms to the supplied predicate.

Returns:

A syntax element that can either be used as working rule, or to continue specifying a more complex rule