Interface ClassesShould


public interface ClassesShould
  • Method Details

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

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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​(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
    • beAnnotatedWith

      Asserts that classes are 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
    • 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. 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​(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
      See Also:
      ArchConditions.notImplement(Class)
    • 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. 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​(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
      See Also:
      ArchConditions.notImplement(String)
    • implement

      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)
      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

      Asserts that classes do not implement a certain interface matching the given predicate. This is the negation of implement(DescribedPredicate).
      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​(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
      See Also:
      ArchConditions.beAssignableTo(Class)
    • 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
      See Also:
      ArchConditions.notBeAssignableTo(Class)
    • 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
      See Also:
      ArchConditions.beAssignableTo(String)
    • 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
      See Also:
      ArchConditions.notBeAssignableTo(String)
    • beAssignableTo

      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.
      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).
      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​(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
      See Also:
      ArchConditions.beAssignableFrom(Class)
    • 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
      See Also:
      ArchConditions.notBeAssignableFrom(Class)
    • 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
      See Also:
      ArchConditions.beAssignableFrom(String)
    • 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
      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.
      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).
      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​(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

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

      @PublicAPI(usage=ACCESS) ClassesShouldConjunction onlyAccessFieldsThat​(DescribedPredicate<? super JavaField> predicate)
      Matches all field accesses against the supplied predicate.
      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​(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
    • getFieldWhere

      Matches against getting of 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
    • 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
    • setFieldWhere

      Matches against setting of 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
    • 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

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

      @PublicAPI(usage=ACCESS) ClassesShouldConjunction onlyCallMethodsThat​(DescribedPredicate<? super JavaMethod> predicate)
      Matches all method calls against the supplied predicate.
      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​(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
    • callConstructorWhere

      Matches against constructor calls where origin (a method or constructor) and target (a constructor) can be freely restricted by the supplied predicate.
      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.
      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.
      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.
      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.
      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.
      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

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

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

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

      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.
      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 certain classes.
      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 certain classes.
      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...
      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

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

      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

      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

      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

      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

      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

      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

    • notBeTopLevelClasses

    • beNestedClasses

    • notBeNestedClasses

    • beMemberClasses

    • notBeMemberClasses

    • beInnerClasses

    • notBeInnerClasses

    • beAnonymousClasses

    • notBeAnonymousClasses

    • beLocalClasses

    • notBeLocalClasses

    • 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<? super 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