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

Interface MembersShould<CONJUNCTION extends MembersShouldConjunction<?>>

All Known Subinterfaces:
CodeUnitsShould<CONJUNCTION>, FieldsShould<CONJUNCTION>, MethodsShould<CONJUNCTION>
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.
      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.
      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.
      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.
      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.
      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.
      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.
      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.
      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;
 }
      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