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

Interface MembersShould<CONJUNCTION extends MembersShouldConjunction<?>>

All Known Subinterfaces:
CodeUnitsShould<CONJUNCTION>, FieldsShould<CONJUNCTION>, MethodsShould<CONJUNCTION>
@PublicAPI(usage=ACCESS) public interface MembersShould<CONJUNCTION extends MembersShouldConjunction<?>>

  • Method Details

    • haveName

      @PublicAPI(usage=ACCESS) CONJUNCTION haveName(String name)
      Asserts that members have a certain name (i.e. field name, method name or JavaConstructor.CONSTRUCTOR_NAME).
      Parameters:
      name - The member name
      Returns:
      A syntax element that can either be used as working rule, or to continue specifying a more complex rule

    • notHaveName

      @PublicAPI(usage=ACCESS) CONJUNCTION notHaveName(String name)
      Asserts that members do not have a certain name (i.e. field name, method name or JavaConstructor.CONSTRUCTOR_NAME).
      Parameters:
      name - The member name
      Returns:
      A syntax element that can either be used as working rule, or to continue specifying a more complex rule

    • haveNameMatching

      @PublicAPI(usage=ACCESS) CONJUNCTION haveNameMatching(String regex)
      Asserts that members have a name (i.e. field name, method name or JavaConstructor.CONSTRUCTOR_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) CONJUNCTION haveNameNotMatching(String regex)
      Asserts that members have a name (i.e. field name, method name or JavaConstructor.CONSTRUCTOR_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

    • haveFullName

      @PublicAPI(usage=ACCESS) CONJUNCTION haveFullName(String fullName)
      Asserts that members have a certain full name (compare JavaField.getFullName() and JavaCodeUnit.getFullName()).
      Parameters:
      fullName - The member's full name
      Returns:
      A syntax element that can either be used as working rule, or to continue specifying a more complex rule

    • notHaveFullName

      @PublicAPI(usage=ACCESS) CONJUNCTION notHaveFullName(String fullName)
      Asserts that members do not have a certain full name (compare JavaField.getFullName() and JavaCodeUnit.getFullName()).
      Parameters:
      fullName - The member's full name
      Returns:
      A syntax element that can either be used as working rule, or to continue specifying a more complex rule

    • haveFullNameMatching

      @PublicAPI(usage=ACCESS) CONJUNCTION haveFullNameMatching(String regex)
      Asserts that members have a full name matching a given regular expression (compare JavaField.getFullName() and JavaCodeUnit.getFullName()).
      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

    • haveFullNameNotMatching

      @PublicAPI(usage=ACCESS) CONJUNCTION haveFullNameNotMatching(String regex)
      Asserts that members have a full name not matching a given regular expression (compare JavaField.getFullName() and JavaCodeUnit.getFullName()).
      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

    • haveNameStartingWith

      @PublicAPI(usage=ACCESS) CONJUNCTION haveNameStartingWith(String prefix)
      Asserts that members have a name starting with the specified prefix.
      Parameters:
      prefix - A prefix the member name should start with
      Returns:
      A syntax element that can either be used as working rule, or to continue specifying a more complex rule

    • haveNameNotStartingWith

      @PublicAPI(usage=ACCESS) CONJUNCTION haveNameNotStartingWith(String prefix)
      Asserts that members have a name not starting with the specified prefix.
      Parameters:
      prefix - A prefix the member 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

    • haveNameContaining

      @PublicAPI(usage=ACCESS) CONJUNCTION haveNameContaining(String infix)
      Asserts that members have a name containing the specified infix.
      Parameters:
      infix - An infix the member name should contain
      Returns:
      A syntax element that can either be used as working rule, or to continue specifying a more complex rule

    • haveNameNotContaining

      @PublicAPI(usage=ACCESS) CONJUNCTION haveNameNotContaining(String infix)
      Asserts that members have a name not containing the specified infix.
      Parameters:
      infix - An infix the member name should not contain
      Returns:
      A syntax element that can either be used as working rule, or to continue specifying a more complex rule

    • haveNameEndingWith

      @PublicAPI(usage=ACCESS) CONJUNCTION haveNameEndingWith(String suffix)
      Asserts that members have a name ending with the specified suffix.
      Parameters:
      suffix - A suffix the member name should end with
      Returns:
      A syntax element that can either be used as working rule, or to continue specifying a more complex rule

    • haveNameNotEndingWith

      @PublicAPI(usage=ACCESS) CONJUNCTION haveNameNotEndingWith(String suffix)
      Asserts that members have a name not ending with the specified suffix.
      Parameters:
      suffix - A suffix the member 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

    • bePublic

      @PublicAPI(usage=ACCESS) CONJUNCTION bePublic()
      Asserts that members 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) CONJUNCTION notBePublic()
      Asserts that members 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) CONJUNCTION beProtected()
      Asserts that members 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) CONJUNCTION notBeProtected()
      Asserts that members 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) CONJUNCTION bePackagePrivate()
      Asserts that members 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) CONJUNCTION notBePackagePrivate()
      Asserts that members 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) CONJUNCTION bePrivate()
      Asserts that members 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) CONJUNCTION notBePrivate()
      Asserts that members are non-private.
      Returns:
      A syntax element that can either be used as working rule, or to continue specifying a more complex rule

    • haveModifier

      @PublicAPI(usage=ACCESS) CONJUNCTION haveModifier(JavaModifier modifier)
      Asserts that members 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) CONJUNCTION notHaveModifier(JavaModifier modifier)
      Asserts that members 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) CONJUNCTION beAnnotatedWith(Class<? extends Annotation> annotationType)
      Asserts that members 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) CONJUNCTION notBeAnnotatedWith(Class<? extends Annotation> annotationType)
      Asserts that members 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) CONJUNCTION beAnnotatedWith(String annotationTypeName)
      Asserts that members 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) CONJUNCTION notBeAnnotatedWith(String annotationTypeName)
      Asserts that members 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) CONJUNCTION beAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)
      Asserts that members are 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

    • notBeAnnotatedWith

      @PublicAPI(usage=ACCESS) CONJUNCTION notBeAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)
      Asserts that members are not 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

    • beMetaAnnotatedWith

      @PublicAPI(usage=ACCESS) CONJUNCTION beMetaAnnotatedWith(Class<? extends Annotation> annotationType)
      Asserts that members 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 members 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) CONJUNCTION notBeMetaAnnotatedWith(Class<? extends Annotation> annotationType)
      Asserts that members 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 members 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) CONJUNCTION beMetaAnnotatedWith(String annotationTypeName)
      Asserts that members 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 members 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) CONJUNCTION notBeMetaAnnotatedWith(String annotationTypeName)
      Asserts that members 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 members 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) CONJUNCTION beMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)
      Asserts that members are meta-annotated with an annotation matching the supplied predicate. A meta-annotation is an annotation that is declared on another annotation.

      The assertion is also successful if members 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) CONJUNCTION notBeMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)
      Asserts that members are not meta-annotated with an annotation matching the supplied predicate. A meta-annotation is an annotation that is declared on another annotation.

      The assertion also fails if members 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

    • beDeclaredIn

      @PublicAPI(usage=ACCESS) CONJUNCTION beDeclaredIn(Class<?> javaClass)
      Asserts that members are declared within the supplied class.

      E.g. 
      
 members().should().beDeclaredIn(Example.class)
      would be violated by someField in 
      
 class AnyOther {
     Object someField;
 }
      Parameters:
      javaClass - A class that members should be declared in
      Returns:
      A syntax element that can either be used as working rule, or to continue specifying a more complex rule

    • notBeDeclaredIn

      @PublicAPI(usage=ACCESS) CONJUNCTION notBeDeclaredIn(Class<?> javaClass)
      Asserts that members are not declared within the supplied class.

      E.g. 
      
 members().should().notBeDeclaredIn(Example.class)
      would be violated by someField in 
      
 class Example {
     Object someField;
 }
      Parameters:
      javaClass - A class that members should not be declared in
      Returns:
      A syntax element that can either be used as working rule, or to continue specifying a more complex rule

    • beDeclaredIn

      @PublicAPI(usage=ACCESS) CONJUNCTION beDeclaredIn(String className)
      Asserts that members are declared within a class of the supplied class name.

      E.g. 
      
 members().should().beDeclaredIn(Example.class.getName())
      would be violated by someField in 
      
 class AnyOther {
     Object someField;
 }
      Parameters:
      className - Fully qualified name of a class that members should be declared in
      Returns:
      A syntax element that can either be used as working rule, or to continue specifying a more complex rule

    • notBeDeclaredIn

      @PublicAPI(usage=ACCESS) CONJUNCTION notBeDeclaredIn(String className)
      Asserts that members are not declared within a class of the supplied class name.

      E.g. 
      
 members().should().notBeDeclaredIn(Example.class.getName())
      would be violated by someField in 
      
 class Example {
     Object someField;
 }
      Parameters:
      className - Fully qualified name of a class that members must not be declared in to match
      Returns:
      A syntax element that can either be used as working rule, or to continue specifying a more complex rule

    • beDeclaredInClassesThat

      @PublicAPI(usage=ACCESS) CONJUNCTION beDeclaredInClassesThat(DescribedPredicate<? super JavaClass> predicate)
      Asserts that members are declared within a class matching the supplied predicate.

      E.g. 
      
 members().should().beDeclaredInClassesThat(areSubtypeOf(Example.class))
      would be violated by someField in 
      
 class AnyOther {
     Object someField;
 }
      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 which matches classes where members have to be declared in
      Returns:
      A syntax element that can either be used as working rule, or to continue specifying a more complex rule

    • beDeclaredInClassesThat

      @PublicAPI(usage=ACCESS) ClassesThat<CONJUNCTION> beDeclaredInClassesThat()
      Allows to assert that members are declared within a certain class.

      E.g. 
      
 members().should().beDeclaredInClassesThat().areAssignableTo(Example.class)
      would be violated by someField in 
      
 class AnyOther {
     Object someField;
 }
      Returns:
      A syntax element that allows restricting where members are declared in

    • containNumberOfElements

      @PublicAPI(usage=ACCESS) CONJUNCTION containNumberOfElements(DescribedPredicate<? super Integer> predicate)
      Asserts that the number of members 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