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

Interface ClassesShould

  • public interface ClassesShould

    • Method Detail

      • haveFullyQualifiedName

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction haveFullyQualifiedName​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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

      • 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

      • 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

      • beAnnotatedWith

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAnnotatedWith​(java.lang.Class<? extends java.lang.annotation.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​(java.lang.Class<? extends java.lang.annotation.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​(java.lang.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​(java.lang.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

      • 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.
        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​(java.lang.Class<? extends java.lang.annotation.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.
        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​(java.lang.Class<? extends java.lang.annotation.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.
        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​(java.lang.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.
        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​(java.lang.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.
        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.
        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.
        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​(java.lang.Class<?> type)
        Asserts that classes implement a certain interface.
        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

      • notImplement

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction notImplement​(java.lang.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

      • implement

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction implement​(java.lang.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.
        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

      • notImplement

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction notImplement​(java.lang.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

      • beAssignableTo

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAssignableTo​(java.lang.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).apply(importedStringClass); // --> returns true
   assignableTo(String.class).apply(importedStringClass); // --> returns true
   assignableTo(List.class).apply(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

      • notBeAssignableTo

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeAssignableTo​(java.lang.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

      • beAssignableTo

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAssignableTo​(java.lang.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

      • notBeAssignableTo

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeAssignableTo​(java.lang.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

      • beAssignableFrom

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAssignableFrom​(java.lang.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).apply(importedArrayListClass); // --> returns true
   assignableFrom(ArrayList.class).apply(importedListClass); // --> returns true
   assignableFrom(ArrayList.class).apply(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

      • notBeAssignableFrom

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeAssignableFrom​(java.lang.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

      • beAssignableFrom

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction beAssignableFrom​(java.lang.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

      • notBeAssignableFrom

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction notBeAssignableFrom​(java.lang.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

      • accessField

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction accessField​(java.lang.Class<?> owner,
                                     java.lang.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​(java.lang.String ownerName,
                                     java.lang.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.
        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

      • getField

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction getField​(java.lang.Class<?> owner,
                                  java.lang.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​(java.lang.String ownerName,
                                  java.lang.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

      • setField

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction setField​(java.lang.Class<?> owner,
                                  java.lang.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​(java.lang.String ownerName,
                                  java.lang.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

      • callMethod

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction callMethod​(java.lang.Class<?> owner,
                                    java.lang.String methodName,
                                    java.lang.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​(java.lang.String ownerName,
                                    java.lang.String methodName,
                                    java.lang.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.
        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

      • callConstructor

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction callConstructor​(java.lang.Class<?> owner,
                                         java.lang.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​(java.lang.String ownerName,
                                         java.lang.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

      • 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.
        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

      • 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.
        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

      • 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

      • 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

      • be

        @PublicAPI(usage=ACCESS)
ClassesShouldConjunction be​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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<java.lang.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