org.mockito.verification.VerificationMode#com.tngtech.java.junit.dataprovider.UseDataProvider源码实例Demo

@Test
@UseDataProvider("resideOutsideOfPackages_rules")
public void resideOutsideOfPackages(ArchRule rule, String... packageIdentifiers) {
    checkTestStillValid(packageIdentifiers,
            ImmutableSet.of(ArchRule.class, ArchConfiguration.class),
            ImmutableSet.<Class<?>>of(GivenObjects.class));

    EvaluationResult result = rule.evaluate(importClasses(
            ArchRule.class, ArchCondition.class, ArchConfiguration.class, GivenObjects.class));

    assertThat(singleLineFailureReportOf(result))
            .contains(String.format("classes should reside outside of packages ['%s']",
                    Joiner.on("', '").join(packageIdentifiers)))
            .containsPattern(doesntResideOutsideOfPackagesPatternFor(ArchRule.class, packageIdentifiers))
            .containsPattern(doesntResideOutsideOfPackagesPatternFor(ArchCondition.class, packageIdentifiers))
            .doesNotContain(String.format("%s", GivenObjects.class.getSimpleName()));
}
 

@Test
@UseDataProvider("callConstructorWhere_rules")
public void callConstructorWhere(ArchRule rule) {
    EvaluationResult result = rule.evaluate(importClasses(
            ClassWithConstructor.class, ClassCallingConstructor.class, ClassCallingWrongConstructor.class));

    assertThat(singleLineFailureReportOf(result))
            .contains(String.format("classes should call constructor where target is %s",
                    ClassWithConstructor.class.getSimpleName()))
            .containsPattern(callConstructorRegex(
                    ClassCallingWrongConstructor.class,
                    ClassCallingConstructor.class, int.class, Date.class))
            .doesNotMatch(callConstructorRegex(
                    ClassCallingConstructor.class,
                    ClassWithConstructor.class, String.class));
}
 

@Test
@UseDataProvider("ANDed_conditions")
public void andShould_ANDs_conditions(ArchRule rule) {
    EvaluationResult result = rule
            .evaluate(importClasses(RightOne.class, RightTwo.class, Wrong.class));

    FailureReport report = result.getFailureReport();
    assertThat(report.toString())
            .contains(String.format(
                    "classes should have fully qualified name '%s' and should have fully qualified name '%s'",
                    RightOne.class.getName(), RightTwo.class.getName()));
    assertThat(report.getDetails()).containsOnly(
            doesntHaveFqnMessage(RightTwo.class, RightOne.class),
            doesntHaveFqnMessage(RightOne.class, RightTwo.class),
            doesntHaveFqnMessage(Wrong.class, RightOne.class),
            doesntHaveFqnMessage(Wrong.class, RightTwo.class));
}
 

@Test
@UseDataProvider("onlyCallConstructorsThat_rules")
public void onlyCallConstructorsThat(ArchRule rule) {
    EvaluationResult result = rule.evaluate(importClasses(
            ClassWithConstructor.class, ClassCallingConstructor.class, ClassCallingWrongConstructor.class));

    assertThat(singleLineFailureReportOf(result))
            .contains(String.format("classes should only call constructors that are declared in %s",
                    ClassWithConstructor.class.getName()))
            .containsPattern(callConstructorRegex(
                    ClassCallingWrongConstructor.class,
                    ClassCallingConstructor.class, int.class, Date.class))
            .doesNotMatch(accessesFieldRegex(
                    ClassAccessingWrongFieldMethodAndConstructor.class, "sets",
                    ClassAccessingFieldMethodAndConstructor.class, "wrongField"))
            .doesNotMatch(callConstructorRegex(
                    ClassCallingConstructor.class,
                    ClassWithConstructor.class, String.class));
}
 

@Test
@UseDataProvider("theClass_should_haveSimpleNameContaining_rules")
public void theClass_should_haveSimpleNameContaining(ArchRule satisfiedRule, ArchRule unsatisfiedRule) {
    String simpleName = SomeClass.class.getSimpleName();
    String infix = simpleName.substring(1, simpleName.length() - 1);
    assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class)
            .haveSuccessfulRuleText("the class %s should have simple name containing '%s'",
                    SomeClass.class.getName(), infix)
            .haveFailingRuleText("the class %s should have simple name not containing '%s'",
                    SomeClass.class.getName(), infix)
            .containFailureDetail(String.format("simple name of %s contains '%s' in %s",
                    quote(SomeClass.class.getName()),
                    quote(infix),
                    locationPattern(SomeClass.class)))
            .doNotContainFailureDetail(quote(Object.class.getName()));
}
 

@Test
@UseDataProvider("theClass_should_haveOnlyFinalFields_rules")
public void theClass_should_haveOnlyFinalFields(ArchRule satisfiedRule, ArchRule unsatisfiedRule) {
    assertThatRules(satisfiedRule, unsatisfiedRule, ClassWithFinalFields.class, ClassWithNonFinalFields.class)
            .haveSuccessfulRuleText("the class %s should have only final fields",
                    ClassWithFinalFields.class.getName())
            .haveFailingRuleText("the class %s should have only final fields",
                    ClassWithNonFinalFields.class.getName())
            .containFailureDetail(String.format("Field <%s.integerField> is not final in %s",
                    quote(ClassWithNonFinalFields.class.getName()),
                    locationPattern(GivenClassShouldTest.class)))
            .containFailureDetail(String.format("Field <%s.stringField> is not final in %s",
                    quote(ClassWithNonFinalFields.class.getName()),
                    locationPattern(GivenClassShouldTest.class)))
            .doNotContainFailureDetail(quote(ClassWithFinalFields.class.getName()));
}
 

@Test
@UseDataProvider("theClass_should_haveNameMatching_rules")
public void theClass_should_haveNameMatching(ArchRule satisfiedRule, ArchRule unsatisfiedRule) {
    String regex = containsPartOfRegex(SomeClass.class.getSimpleName());

    assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class)
            .haveSuccessfulRuleText("the class %s should have name matching '%s'",
                    SomeClass.class.getName(), regex)
            .haveFailingRuleText("the class %s should have name not matching '%s'",
                    SomeClass.class.getName(), regex)
            .containFailureDetail(String.format("Class <%s> matches '%s' in %s",
                    quote(SomeClass.class.getName()),
                    quote(regex),
                    locationPattern(SomeClass.class)))
            .doNotContainFailureDetail(quote(regex));
}
 

@Test
@UseDataProvider("theClass_should_haveSimpleNameStartingWith_rules")
public void theClass_should_haveSimpleNameStartingWith(ArchRule satisfiedRule, ArchRule unsatisfiedRule) {
    String simpleName = SomeClass.class.getSimpleName();
    String prefix = simpleName.substring(0, simpleName.length() - 1);
    assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class)
            .haveSuccessfulRuleText("the class %s should have simple name starting with '%s'",
                    SomeClass.class.getName(), prefix)
            .haveFailingRuleText("the class %s should have simple name not starting with '%s'",
                    SomeClass.class.getName(), prefix)
            .containFailureDetail(String.format("simple name of %s starts with '%s' in %s",
                    quote(SomeClass.class.getName()),
                    quote(prefix),
                    locationPattern(SomeClass.class)))
            .doNotContainFailureDetail(quote(Object.class.getName()));
}
 

@Test
@UseDataProvider("theClass_should_resideInAnyPackage_rules")
public void theClass_should_resideInAnyPackage(ArchRule satisfiedRule, ArchRule unsatisfiedRule) {
    String firstPackage = SomeClass.class.getPackage().getName();
    String secondPackage = Object.class.getPackage().getName();
    String[] packageIdentifiers = {firstPackage, secondPackage};

    assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class)
            .haveSuccessfulRuleText("the class %s should reside in any package ['%s']",
                    SomeClass.class.getName(),
                    Joiner.on("', '").join(packageIdentifiers))
            .haveFailingRuleText("the class %s should reside outside of packages ['%s']",
                    SomeClass.class.getName(),
                    Joiner.on("', '").join(packageIdentifiers))
            .containFailureDetail(String.format("Class <%s> does not reside outside of packages \\['%s'\\] in %s",
                    quote(SomeClass.class.getName()),
                    quote(Joiner.on("', '").join(packageIdentifiers)),
                    locationPattern(SomeClass.class)))
            .doNotContainFailureDetail(quote(Object.class.getName()));
}
 

@Test
@UseDataProvider("no_classes_should_that_rule_starts")
public void resideInAnyPackage(ClassesThat<ClassesShouldConjunction> noClassesShouldThatRuleStart) {
    Set<JavaClass> classes = filterClassesAppearingInFailureReport(
            noClassesShouldThatRuleStart.resideInAnyPackage("..tngtech..", "java.lang.reflect"))
            .on(ClassAccessingPublicClass.class, ClassAccessingString.class, ClassAccessingConstructor.class);

    assertThatClasses(classes).matchInAnyOrder(ClassAccessingPublicClass.class, ClassAccessingConstructor.class);
}
 

@Test
@UseDataProvider("classes_should_only_that_rule_starts")
public void only_haveNameNotMatching(ClassesThat<ClassesShouldConjunction> classesShouldOnlyThatRuleStart) {
    Set<JavaClass> classes = filterClassesAppearingInFailureReport(
            classesShouldOnlyThatRuleStart.haveNameNotMatching(".*\\.List"))
            .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class);

    assertThat(getOnlyElement(classes)).matches(ClassAccessingList.class);
}
 

@Test
@UseDataProvider("no_classes_should_that_rule_starts")
public void areNotAssignableTo_type(ClassesThat<ClassesShouldConjunction> noClassesShouldThatRuleStart) {
    Set<JavaClass> classes = filterClassesAppearingInFailureReport(
            noClassesShouldThatRuleStart.areNotAssignableTo(Collection.class))
            .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class);

    assertThatClasses(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class);
}
 

@Test
@UseDataProvider("restricted_property_rule_ends")
public void property_predicates(ArchRule ruleStart, Collection<String> expectedMembers) {
    EvaluationResult result = ruleStart.evaluate(importClasses(ClassWithVariousMembers.class));

    Set<String> actualMethods = parseMembers(ClassWithVariousMembers.class, result.getFailureReport().getDetails());
    assertThat(actualMethods).containsOnlyElementsOf(expectedMembers);
}
 

@Test
@UseDataProvider("test_classes_without_any_imported_classes")
public void when_there_are_only_nonexisting_sources_nothing_is_imported(TestAnalysisRequest analysisRequest) {
    JavaClasses classes = cache.getClassesToAnalyzeFor(TestClass.class, analysisRequest);

    assertThat(classes).isEmpty();

    verify(cacheClassFileImporter).importClasses(any(ImportOptions.class), locationCaptor.capture());
    assertThat(locationCaptor.getValue()).isEmpty();
}
 

@Test
@UseDataProvider("classes_should_only_predicate_rule_starts")
public void shouldThatOnly_predicate(ArchRule rule) {
    Set<JavaClass> classes = filterClassesAppearingInFailureReport(rule)
            .on(ClassAccessingList.class, ClassAccessingString.class,
                    ClassAccessingCollection.class, ClassAccessingIterable.class);

    assertThatClasses(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingString.class);
}
 

@Test
@UseDataProvider("file_locations_pointing_to_jar")
public void JAR_protocol_is_added_to_file_urls_that_point_to_JARs(Location location) throws MalformedURLException {
    assertThat(location.uri.toString()).startsWith("jar:");
    assertThat(location.uri.toString()).endsWith("!/");
    assertThat(location.uri.toURI().toURL().getProtocol()).isEqualTo("jar");
}
 

@Test
@UseDataProvider("theClass_should_getField_rules")
public void theClass_should_getField(ArchRule satisfiedRule, ArchRule unsatisfiedRule) {
    assertThatRules(satisfiedRule, unsatisfiedRule, ClassWithField.class, ClassAccessingWrongField.class, ClassAccessingField.class)
            .haveSuccessfulRuleText("the class %s should get field %s.%s",
                    ClassAccessingField.class.getName(), ClassWithField.class.getSimpleName(), "field")
            .haveFailingRuleText("the class %s should get field %s.%s",
                    ClassAccessingWrongField.class.getName(), ClassWithField.class.getSimpleName(), "field")
            .containFailureDetail(accessesFieldRegex(
                    ClassAccessingWrongField.class, "gets",
                    ClassAccessingWrongField.class, "classAccessingField"))
            .doNotContainFailureDetail(quote(ClassAccessingField.class.getName()) + ANY_NUMBER_OF_NON_NEWLINE_CHARS_REGEX + "get");
}
 

@Test
@UseDataProvider("no_classes_should_that_rule_starts")
public void areNotAnnotatedWith_type(ClassesThat<ClassesShouldConjunction> noClassesShouldThatRuleStart) {
    Set<JavaClass> classes = filterClassesAppearingInFailureReport(
            noClassesShouldThatRuleStart.areNotAnnotatedWith(SomeAnnotation.class))
            .on(ClassAccessingAnnotatedClass.class, ClassAccessingSimpleClass.class);

    assertThat(getOnlyElement(classes)).matches(ClassAccessingSimpleClass.class);
}
 

@Test
@UseDataProvider("no_classes_should_that_rule_starts")
public void haveNameMatching(ClassesThat<ClassesShouldConjunction> noClassesShouldThatRuleStart) {
    Set<JavaClass> classes = filterClassesAppearingInFailureReport(
            noClassesShouldThatRuleStart.haveNameMatching(".*\\.List"))
            .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class);

    assertThat(getOnlyElement(classes)).matches(ClassAccessingList.class);
}
 

@Test
@UseDataProvider("haveNameContaining_rules")
public void haveNameContaining(ArchRule rule, String infix, String violatingMember) {
    EvaluationResult result = rule.evaluate(importClasses(SimpleFieldAndMethod.class));

    assertThat(singleLineFailureReportOf(result))
            .containsPattern(String.format(".*%s.* name does not contain '%s' in %s",
                    quote(violatingMember),
                    quote(infix),
                    locationPattern(SimpleFieldAndMethod.class)));
}
 

@Test
@UseDataProvider("no_classes_should_that_rule_starts")
public void doNotImplement_type(ClassesThat<ClassesShouldConjunction> noClassesShouldThatRuleStart) {
    Set<JavaClass> classes = filterClassesAppearingInFailureReport(
            noClassesShouldThatRuleStart.doNotImplement(Collection.class))
            .on(ClassAccessingArrayList.class, ClassAccessingList.class, ClassAccessingIterable.class);

    assertThatClasses(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingIterable.class);
}
 

@Test
@UseDataProvider("no_classes_should_that_rule_starts")
public void areLocalClasses_predicate(ClassesThat<ClassesShouldConjunction> noClassesShouldThatRuleStart) {
    Set<JavaClass> classes = filterClassesAppearingInFailureReport(
            noClassesShouldThatRuleStart.areLocalClasses())
            .on(ClassAccessingLocalClass.class, ClassAccessingTopLevelClass.class);

    assertThatClasses(classes).matchInAnyOrder(ClassAccessingLocalClass.class);
}
 

@Test
@UseDataProvider("classes_should_only_that_rule_starts")
public void only_implement_type(ClassesThat<ClassesShouldConjunction> classesShouldOnlyThatRuleStart) {
    Set<JavaClass> classes = filterClassesAppearingInFailureReport(
            classesShouldOnlyThatRuleStart.implement(Collection.class))
            .on(ClassAccessingArrayList.class, ClassAccessingList.class, ClassAccessingIterable.class);

    assertThatClasses(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingIterable.class);
}
 

@Test
@UseDataProvider("no_classes_should_that_rule_starts")
public void areNotLocalClasses_predicate(ClassesThat<ClassesShouldConjunction> noClassesShouldThatRuleStart) {
    Set<JavaClass> classes = filterClassesAppearingInFailureReport(
            noClassesShouldThatRuleStart.areNotLocalClasses())
            .on(ClassAccessingLocalClass.class, ClassAccessingTopLevelClass.class);

    assertThatClasses(classes).matchInAnyOrder(ClassAccessingTopLevelClass.class);
}
 

@Test
@UseDataProvider("no_classes_should_that_rule_starts")
public void areAssignableFrom_type(ClassesThat<ClassesShouldConjunction> noClassesShouldThatRuleStart) {
    Set<JavaClass> classes = filterClassesAppearingInFailureReport(
            noClassesShouldThatRuleStart.areAssignableFrom(Collection.class))
            .on(ClassAccessingList.class, ClassAccessingString.class,
                    ClassAccessingCollection.class, ClassAccessingIterable.class);

    assertThatClasses(classes).matchInAnyOrder(ClassAccessingCollection.class, ClassAccessingIterable.class);
}
 

@Test
@UseDataProvider("theClass_should_accessField_rules")
public void theClass_should_accessField(ArchRule satisfiedRule, ArchRule unsatisfiedRule) {
    assertThatRules(satisfiedRule, unsatisfiedRule, ClassWithField.class, ClassAccessingWrongField.class, ClassAccessingField.class)
            .haveSuccessfulRuleText("the class %s should access field %s.%s",
                    ClassAccessingField.class.getName(), ClassWithField.class.getSimpleName(), "field")
            .haveFailingRuleText("the class %s should access field %s.%s",
                    ClassAccessingWrongField.class.getName(), ClassWithField.class.getSimpleName(), "field")
            .containFailureDetail(accessesFieldRegex(
                    ClassAccessingWrongField.class, "gets",
                    ClassAccessingWrongField.class, "classAccessingField"))
            .doNotContainFailureDetail(quote(ClassAccessingField.class.getName()) + ANY_NUMBER_OF_NON_NEWLINE_CHARS_REGEX + "accesses");
}
 

@Test
@UseDataProvider("no_classes_should_that_rule_starts")
public void areNotAssignableFrom_type(ClassesThat<ClassesShouldConjunction> noClassesShouldThatRuleStart) {
    Set<JavaClass> classes = filterClassesAppearingInFailureReport(
            noClassesShouldThatRuleStart.areNotAssignableFrom(Collection.class))
            .on(ClassAccessingList.class, ClassAccessingString.class,
                    ClassAccessingCollection.class, ClassAccessingIterable.class);

    assertThatClasses(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingString.class);
}
 

@Test
@UseDataProvider("restricted_parameter_types_rules")
public void parameter_types_predicates(ArchRule rule, Collection<String> expectedMembers) {
    EvaluationResult result = rule.evaluate(importClasses(ClassWithVariousMembers.class));

    Set<String> actualMembers = parseMembers(ClassWithVariousMembers.class, result.getFailureReport().getDetails());
    assertThat(actualMembers).containsOnlyElementsOf(expectedMembers);
}
 

@Test
@UseDataProvider("no_classes_should_that_rule_starts")
public void haveSimpleNameNotEndingWith(ClassesThat<ClassesShouldConjunction> noClassesShouldThatRuleStart) {
    Set<JavaClass> classes = filterClassesAppearingInFailureReport(
            noClassesShouldThatRuleStart.haveSimpleNameNotEndingWith("ist"))
            .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class);

    assertThatClasses(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class);
}
 

@Test
@UseDataProvider("restricted_property_rule_starts")
public void property_predicates(DescribedRuleStart ruleStart, Collection<String> expectedMembers) {
    EvaluationResult result = ruleStart.should(everythingViolationPrintMemberName())
            .evaluate(importClasses(ClassWithVariousMembers.class));

    assertThat(result.getFailureReport().getDetails()).containsOnlyElementsOf(expectedMembers);
}