From 6c8a65aaa3428fb65ee57d96dadbb6d3214913c5 Mon Sep 17 00:00:00 2001 From: Manfred Hanke Date: Sun, 27 Apr 2025 11:42:43 +0200 Subject: [PATCH 01/11] remove unused `@RunWith(DataProviderRunner.class)` annotations and junit-dataprovider dependency Signed-off-by: Manfred Hanke --- archunit-maven-test/pom.xml.template | 1 - ...lassFileImporterCodeUnitReferencesNewerJavaVersionTest.java | 3 --- .../ClassFileImporterLambdaAccessesNewerJavaVersionTest.java | 3 --- .../archunit/core/importer/ClassFileImporterAccessesTest.java | 3 --- .../core/importer/ClassFileImporterAnnotationsTest.java | 3 --- .../core/importer/ClassFileImporterGenericFieldTypesTest.java | 3 --- .../ClassFileImporterGenericMethodReturnTypesTest.java | 3 --- .../core/importer/ClassFileImporterGenericSuperclassTest.java | 3 --- .../archunit/lang/syntax/elements/GivenClassesThatTest.java | 3 --- .../syntax/elements/GivenMembersDeclaredInClassesThatTest.java | 3 --- 10 files changed, 28 deletions(-) diff --git a/archunit-maven-test/pom.xml.template b/archunit-maven-test/pom.xml.template index 8bdf2fd067..d31e4e28b5 100644 --- a/archunit-maven-test/pom.xml.template +++ b/archunit-maven-test/pom.xml.template @@ -58,7 +58,6 @@ #{exampleLibs.jakartaAnnotations} #{exampleLibs.guice} #{libs.junit4:test} - #{libs.junitDataprovider:test} #{libs.assertj:test} #{exampleLibs.joox:test} #{additionalDependencies} diff --git a/archunit/src/jdk9test/java/com/tngtech/archunit/core/importer/ClassFileImporterCodeUnitReferencesNewerJavaVersionTest.java b/archunit/src/jdk9test/java/com/tngtech/archunit/core/importer/ClassFileImporterCodeUnitReferencesNewerJavaVersionTest.java index d1c2262787..b1f8734123 100644 --- a/archunit/src/jdk9test/java/com/tngtech/archunit/core/importer/ClassFileImporterCodeUnitReferencesNewerJavaVersionTest.java +++ b/archunit/src/jdk9test/java/com/tngtech/archunit/core/importer/ClassFileImporterCodeUnitReferencesNewerJavaVersionTest.java @@ -3,13 +3,10 @@ import java.util.function.Supplier; import com.tngtech.archunit.core.domain.JavaClasses; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; import org.junit.Test; -import org.junit.runner.RunWith; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class ClassFileImporterCodeUnitReferencesNewerJavaVersionTest { /** * A local class constructor obtains extra parameters from the outer scope that the compiler transparently adds diff --git a/archunit/src/jdk9test/java/com/tngtech/archunit/core/importer/ClassFileImporterLambdaAccessesNewerJavaVersionTest.java b/archunit/src/jdk9test/java/com/tngtech/archunit/core/importer/ClassFileImporterLambdaAccessesNewerJavaVersionTest.java index b882fce4e4..55737fe745 100644 --- a/archunit/src/jdk9test/java/com/tngtech/archunit/core/importer/ClassFileImporterLambdaAccessesNewerJavaVersionTest.java +++ b/archunit/src/jdk9test/java/com/tngtech/archunit/core/importer/ClassFileImporterLambdaAccessesNewerJavaVersionTest.java @@ -6,16 +6,13 @@ import com.tngtech.archunit.core.domain.JavaAccess; import com.tngtech.archunit.core.domain.JavaClasses; import com.tngtech.archunit.core.domain.JavaConstructorCall; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; import org.junit.Test; -import org.junit.runner.RunWith; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.core.domain.JavaConstructor.CONSTRUCTOR_NAME; import static com.tngtech.archunit.testutil.Assertions.assertThatAccess; import static java.util.stream.Collectors.toSet; -@RunWith(DataProviderRunner.class) public class ClassFileImporterLambdaAccessesNewerJavaVersionTest { /** * This is a special case: For local constructors the Java compiler actually adds a lambda calling the constructor diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAccessesTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAccessesTest.java index 15e9758e86..cc88046683 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAccessesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAccessesTest.java @@ -88,9 +88,7 @@ import com.tngtech.archunit.core.importer.testexamples.trycatch.ClassWithSimpleTryCatchBlocks; import com.tngtech.archunit.core.importer.testexamples.trycatch.ClassWithTryCatchBlockWithoutThrowables; import com.tngtech.archunit.core.importer.testexamples.trycatch.ClassWithTryWithResources; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; import org.junit.Test; -import org.junit.runner.RunWith; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.core.domain.JavaClass.Predicates.equivalentTo; @@ -124,7 +122,6 @@ import static java.util.stream.Collectors.groupingBy; import static java.util.stream.Collectors.toSet; -@RunWith(DataProviderRunner.class) public class ClassFileImporterAccessesTest { @Test diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAnnotationsTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAnnotationsTest.java index 39bbbdd9fb..8d2a358e1f 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAnnotationsTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAnnotationsTest.java @@ -31,9 +31,7 @@ import com.tngtech.archunit.core.importer.testexamples.simpleimport.AnnotationParameter; import com.tngtech.archunit.core.importer.testexamples.simpleimport.AnnotationToImport; import com.tngtech.archunit.core.importer.testexamples.simpleimport.EnumToImport; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; import org.junit.Test; -import org.junit.runner.RunWith; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.core.importer.testexamples.SomeEnum.OTHER_VALUE; @@ -48,7 +46,6 @@ import static com.tngtech.archunit.testutil.Assertions.assertThatType; import static java.util.Collections.emptySet; -@RunWith(DataProviderRunner.class) public class ClassFileImporterAnnotationsTest { @Test diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericFieldTypesTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericFieldTypesTest.java index d96f500409..444201f36c 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericFieldTypesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericFieldTypesTest.java @@ -11,9 +11,7 @@ import com.tngtech.archunit.core.domain.JavaClass; import com.tngtech.archunit.core.domain.JavaType; import com.tngtech.archunit.core.domain.JavaTypeVariable; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; import org.junit.Test; -import org.junit.runner.RunWith; import static com.tngtech.archunit.core.importer.DependencyResolutionProcessTestUtils.importClassWithOnlyGenericTypeResolution; import static com.tngtech.archunit.core.importer.DependencyResolutionProcessTestUtils.importClassesWithOnlyGenericTypeResolution; @@ -27,7 +25,6 @@ import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteTypeVariable.typeVariable; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteWildcardType.wildcardType; -@RunWith(DataProviderRunner.class) public class ClassFileImporterGenericFieldTypesTest { @Test diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericMethodReturnTypesTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericMethodReturnTypesTest.java index e74359d46b..d67bc06866 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericMethodReturnTypesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericMethodReturnTypesTest.java @@ -11,9 +11,7 @@ import com.tngtech.archunit.core.domain.JavaClass; import com.tngtech.archunit.core.domain.JavaType; import com.tngtech.archunit.core.domain.JavaTypeVariable; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; import org.junit.Test; -import org.junit.runner.RunWith; import static com.tngtech.archunit.core.importer.DependencyResolutionProcessTestUtils.importClassWithOnlyGenericTypeResolution; import static com.tngtech.archunit.core.importer.DependencyResolutionProcessTestUtils.importClassesWithOnlyGenericTypeResolution; @@ -27,7 +25,6 @@ import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteTypeVariable.typeVariable; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteWildcardType.wildcardType; -@RunWith(DataProviderRunner.class) public class ClassFileImporterGenericMethodReturnTypesTest { @Test diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericSuperclassTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericSuperclassTest.java index c1c3387374..66152b46f9 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericSuperclassTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericSuperclassTest.java @@ -9,9 +9,7 @@ import com.tngtech.archunit.ArchConfiguration; import com.tngtech.archunit.core.domain.JavaType; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; import org.junit.Test; -import org.junit.runner.RunWith; import static com.tngtech.archunit.core.importer.DependencyResolutionProcessTestUtils.importClassWithOnlyGenericTypeResolution; import static com.tngtech.archunit.core.importer.DependencyResolutionProcessTestUtils.importClassesWithOnlyGenericTypeResolution; @@ -25,7 +23,6 @@ import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteTypeVariable.typeVariable; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteWildcardType.wildcardType; -@RunWith(DataProviderRunner.class) public class ClassFileImporterGenericSuperclassTest { @Test diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassesThatTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassesThatTest.java index 15b3f48ff8..ae0b71f759 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassesThatTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassesThatTest.java @@ -27,10 +27,8 @@ import com.tngtech.archunit.lang.ArchCondition; import com.tngtech.archunit.lang.ConditionEvents; import com.tngtech.archunit.testutil.ArchConfigurationRule; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; import org.junit.Rule; import org.junit.Test; -import org.junit.runner.RunWith; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.base.DescribedPredicate.equalTo; @@ -51,7 +49,6 @@ import static com.tngtech.archunit.testutil.Assertions.assertThatTypes; import static java.util.regex.Pattern.quote; -@RunWith(DataProviderRunner.class) public class GivenClassesThatTest { @Rule diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMembersDeclaredInClassesThatTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMembersDeclaredInClassesThatTest.java index d75f125330..7d64fe5b6e 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMembersDeclaredInClassesThatTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMembersDeclaredInClassesThatTest.java @@ -24,10 +24,8 @@ import com.tngtech.archunit.core.domain.properties.HasType; import com.tngtech.archunit.lang.syntax.elements.GivenClassesThatTest.Evaluator; import com.tngtech.archunit.testutil.ArchConfigurationRule; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; import org.junit.Rule; import org.junit.Test; -import org.junit.runner.RunWith; import static com.tngtech.archunit.base.DescribedPredicate.equalTo; import static com.tngtech.archunit.core.domain.JavaClass.Predicates.simpleName; @@ -46,7 +44,6 @@ import static com.tngtech.archunit.testutil.Assertions.assertThatMembers; import static java.util.regex.Pattern.quote; -@RunWith(DataProviderRunner.class) public class GivenMembersDeclaredInClassesThatTest { @Rule From ff36e9034b8bea3f6a653a05b0c93e0198111675 Mon Sep 17 00:00:00 2001 From: Manfred Hanke Date: Tue, 29 Apr 2025 09:04:49 +0200 Subject: [PATCH 02/11] migrate junit-dataprovider tests to junit-jupiter-params' @{Csv,Enum,Value}Source Note that > By default, `@CsvSource` uses a single quote (') as its quote character [...] > An empty, quoted value ('') results in an empty String [...] > whereas an entirely empty value is interpreted as a null reference. [https://junit.org/junit5/docs/current/api/org.junit.jupiter.params/org/junit/jupiter/params/provider/CsvSource.html] Signed-off-by: Manfred Hanke --- ...eImporterAccessesNewerJavaVersionTest.java | 80 +++++++--------- .../ClassFileImporterRecordsTest.java | 26 ++--- .../core/domain/JavaFieldAccessTest.java | 23 ++--- .../core/domain/PackageMatcherTest.java | 40 ++++---- ...lassFileImporterGenericInterfacesTest.java | 94 +++++++------------ .../ViolationLineMatcherFactoryTest.java | 17 ++-- 6 files changed, 106 insertions(+), 174 deletions(-) diff --git a/archunit/src/jdk16test/java/com/tngtech/archunit/core/importer/ClassFileImporterAccessesNewerJavaVersionTest.java b/archunit/src/jdk16test/java/com/tngtech/archunit/core/importer/ClassFileImporterAccessesNewerJavaVersionTest.java index d7f4c98f88..c2986bca09 100644 --- a/archunit/src/jdk16test/java/com/tngtech/archunit/core/importer/ClassFileImporterAccessesNewerJavaVersionTest.java +++ b/archunit/src/jdk16test/java/com/tngtech/archunit/core/importer/ClassFileImporterAccessesNewerJavaVersionTest.java @@ -12,57 +12,47 @@ import com.tngtech.archunit.core.importer.testexamples.methodresolution.OnlyDefinedInCommonAncestor; import com.tngtech.archunit.core.importer.testexamples.methodresolution.OnlyLeftAncestorOverridesRootMethod; import com.tngtech.archunit.core.importer.testexamples.methodresolution.OnlyRightAncestorOverridesRootMethod; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; -@RunWith(DataProviderRunner.class) public class ClassFileImporterAccessesNewerJavaVersionTest { - @DataProvider - public static Object[][] method_resolution_scenarios() { - return testForEach( - OnlyDefinedInCommonAncestor.class, - OnlyLeftAncestorOverridesRootMethod.class, - OnlyRightAncestorOverridesRootMethod.class, - LeftAncestorPrecedesRightAncestor.class, - ChildOverridesAllMethods.class, - DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.LeftLeftHasPrecedence.class, - DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.LeftRightHasPrecedenceOverRight.class, - DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.RightLeftHasPrecedenceOverRightRight.class, - DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.RightRightIsPickedIfThereIsNoAlternative.class, - DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.LeftOverriddenHasPrecedenceOverParents.class, - DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.RightOverriddenHasPrecedenceOverParents.class, - DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.LeftLeftHasPrecedenceOverOverriddenRight.class, - DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.LeftRightHasPrecedenceOverOverriddenRight.class, - DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.LeftOverriddenHasPrecedenceOverRightOverridden.class, - DeterminesMethodAnalogouslyToReflectionApi.ClassHasPrecedenceOverInterface.ParentClassHasPrecedenceOverChildInterfaces.class, - DeterminesMethodAnalogouslyToReflectionApi.ClassHasPrecedenceOverInterface.GrandParentClassHasPrecedenceOverChildInterfaces.class, - DeterminesMethodAnalogouslyToReflectionApi.InterfaceOnParentHasPrecedenceOverInterfaceOnChild.LeftLeftOnGrandparentHasPrecedenceOverAllOthers.class, - DeterminesMethodAnalogouslyToReflectionApi.InterfaceOnParentHasPrecedenceOverInterfaceOnChild.LeftRightOnGrandparentHasPrecedenceOverLeftOnParent.class, - DeterminesMethodAnalogouslyToReflectionApi.InterfaceOnParentHasPrecedenceOverInterfaceOnChild.RightLeftOnGrandparentHasPrecedenceOverLeftAndRightOnParent.class, - DeterminesMethodAnalogouslyToReflectionApi.InterfaceOnParentHasPrecedenceOverInterfaceOnChild.RightRightOnGrandparentHasPrecedenceOverLeftAndRightOnParent.class, - DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.RightWithMoreSpecificReturnOnParentTypeHasPrecedenceOverAllOthers.class, - DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.LeftWithMoreSpecificReturnTypeHasPrecedenceRightWithMoreSpecificReturnType.class, - DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.ParentInterfaceWithMoreSpecificReturnTypeHasPrecedenceOverAllOthers.class, - DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.InterfaceWithMoreSpecificReturnTypeHasPrecedenceOverGrandParentClass.class, - DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.ParentInterfaceOnParentClassWithMoreSpecificReturnTypeHasPrecedenceOverGrandParentClass.class, - DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.GrandParentInterfaceWithMoreSpecificReturnTypeHasPrecedenceOverAllOthers.class, - DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.GrandParentInterfaceWithMoreSpecificReturnTypeHasPrecedenceOverFirstParentInterfaceWithMoreSpecificReturnType.class, - DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.GrandParentInterfaceWithMoreSpecificReturnTypeHasPrecedenceOverAllParentInterfacesWithMoreSpecificReturnType.class, - DeterminesMethodAnalogouslyToReflectionApi.StaticMethodsInInterfacesAreIgnored.class - ); - } - - @Test - @UseDataProvider("method_resolution_scenarios") - public void resolves_method_call_targets(Class scenario) throws NoSuchMethodException { + @ParameterizedTest + @ValueSource(classes = { + OnlyDefinedInCommonAncestor.class, + OnlyLeftAncestorOverridesRootMethod.class, + OnlyRightAncestorOverridesRootMethod.class, + LeftAncestorPrecedesRightAncestor.class, + ChildOverridesAllMethods.class, + DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.LeftLeftHasPrecedence.class, + DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.LeftRightHasPrecedenceOverRight.class, + DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.RightLeftHasPrecedenceOverRightRight.class, + DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.RightRightIsPickedIfThereIsNoAlternative.class, + DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.LeftOverriddenHasPrecedenceOverParents.class, + DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.RightOverriddenHasPrecedenceOverParents.class, + DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.LeftLeftHasPrecedenceOverOverriddenRight.class, + DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.LeftRightHasPrecedenceOverOverriddenRight.class, + DeterminesMethodAnalogouslyToReflectionApi.EquivalentMethodsAreChosenDepthFirst.LeftOverriddenHasPrecedenceOverRightOverridden.class, + DeterminesMethodAnalogouslyToReflectionApi.ClassHasPrecedenceOverInterface.ParentClassHasPrecedenceOverChildInterfaces.class, + DeterminesMethodAnalogouslyToReflectionApi.ClassHasPrecedenceOverInterface.GrandParentClassHasPrecedenceOverChildInterfaces.class, + DeterminesMethodAnalogouslyToReflectionApi.InterfaceOnParentHasPrecedenceOverInterfaceOnChild.LeftLeftOnGrandparentHasPrecedenceOverAllOthers.class, + DeterminesMethodAnalogouslyToReflectionApi.InterfaceOnParentHasPrecedenceOverInterfaceOnChild.LeftRightOnGrandparentHasPrecedenceOverLeftOnParent.class, + DeterminesMethodAnalogouslyToReflectionApi.InterfaceOnParentHasPrecedenceOverInterfaceOnChild.RightLeftOnGrandparentHasPrecedenceOverLeftAndRightOnParent.class, + DeterminesMethodAnalogouslyToReflectionApi.InterfaceOnParentHasPrecedenceOverInterfaceOnChild.RightRightOnGrandparentHasPrecedenceOverLeftAndRightOnParent.class, + DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.RightWithMoreSpecificReturnOnParentTypeHasPrecedenceOverAllOthers.class, + DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.LeftWithMoreSpecificReturnTypeHasPrecedenceRightWithMoreSpecificReturnType.class, + DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.ParentInterfaceWithMoreSpecificReturnTypeHasPrecedenceOverAllOthers.class, + DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.InterfaceWithMoreSpecificReturnTypeHasPrecedenceOverGrandParentClass.class, + DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.ParentInterfaceOnParentClassWithMoreSpecificReturnTypeHasPrecedenceOverGrandParentClass.class, + DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.GrandParentInterfaceWithMoreSpecificReturnTypeHasPrecedenceOverAllOthers.class, + DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.GrandParentInterfaceWithMoreSpecificReturnTypeHasPrecedenceOverFirstParentInterfaceWithMoreSpecificReturnType.class, + DeterminesMethodAnalogouslyToReflectionApi.MoreSpecificReturnTypeHasPrecedence.GrandParentInterfaceWithMoreSpecificReturnTypeHasPrecedenceOverAllParentInterfacesWithMoreSpecificReturnType.class, + DeterminesMethodAnalogouslyToReflectionApi.StaticMethodsInInterfacesAreIgnored.class + }) + void resolves_method_call_targets(Class scenario) throws NoSuchMethodException { JavaMethod origin = new ClassFileImporter().importPackagesOf(scenario).get(scenario).getMethod("scenario"); MethodCallTarget target = getOnlyElement(origin.getMethodCallsFromSelf()).getTarget(); diff --git a/archunit/src/jdk16test/java/com/tngtech/archunit/core/importer/ClassFileImporterRecordsTest.java b/archunit/src/jdk16test/java/com/tngtech/archunit/core/importer/ClassFileImporterRecordsTest.java index 9d181fe94b..2ca2bca1e4 100644 --- a/archunit/src/jdk16test/java/com/tngtech/archunit/core/importer/ClassFileImporterRecordsTest.java +++ b/archunit/src/jdk16test/java/com/tngtech/archunit/core/importer/ClassFileImporterRecordsTest.java @@ -4,29 +4,21 @@ import com.tngtech.archunit.core.domain.JavaConstructor; import com.tngtech.archunit.core.domain.JavaField; import com.tngtech.archunit.core.domain.JavaMethod; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; -@RunWith(DataProviderRunner.class) public class ClassFileImporterRecordsTest { - @DataProvider - public static Object[][] imports_record() { - record SimpleRecord(String component1, int component2) { - } - record EmptyRecord() { - } - return testForEach(SimpleRecord.class, EmptyRecord.class); + record SimpleRecord(String component1, int component2) { + } + record EmptyRecord() { } - @Test - @UseDataProvider - public void imports_record(Class recordToImport) { + @ParameterizedTest + @ValueSource(classes = {SimpleRecord.class, EmptyRecord.class}) + void imports_record(Class recordToImport) { JavaClass javaClass = new ClassFileImporter().importClasses(recordToImport, Record.class).get(recordToImport); assertThat(javaClass) diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaFieldAccessTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaFieldAccessTest.java index 0df19a838d..2c70fc5295 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaFieldAccessTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaFieldAccessTest.java @@ -6,25 +6,19 @@ import com.tngtech.archunit.core.domain.AccessTarget.FieldAccessTarget; import com.tngtech.archunit.core.domain.JavaFieldAccess.AccessType; import com.tngtech.archunit.core.importer.JavaFieldAccessTestBuilder; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.base.DescribedPredicate.alwaysTrue; import static com.tngtech.archunit.core.domain.JavaFieldAccess.AccessType.GET; -import static com.tngtech.archunit.core.domain.JavaFieldAccess.AccessType.SET; import static com.tngtech.archunit.core.domain.JavaFieldAccess.Predicates.accessType; import static com.tngtech.archunit.core.domain.JavaFieldAccess.Predicates.target; import static com.tngtech.archunit.core.domain.TestUtils.importClassWithContext; import static com.tngtech.archunit.core.domain.TestUtils.targetFrom; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; -@RunWith(DataProviderRunner.class) public class JavaFieldAccessTest { @Test public void equals_of_JavaAccess_should_be_identity_equals() throws Exception { @@ -52,14 +46,9 @@ public void fieldAccess_should_have_same_name_as_target() throws Exception { assertThat(access.getName()).isEqualTo(access.getTarget().getName()); } - @DataProvider - public static Object[][] accessTypes() { - return $$($(GET), $(SET)); - } - - @Test - @UseDataProvider("accessTypes") - public void predicate_access_type(AccessType accessType) { + @ParameterizedTest + @EnumSource(AccessType.class) + void predicate_access_type(AccessType accessType) { assertThat(accessType(accessType)) .accepts(stringFieldAccess(accessType)) .rejects(stringFieldAccess(not(accessType))) diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/PackageMatcherTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/PackageMatcherTest.java index 3cb2ee7de6..1e1178d178 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/PackageMatcherTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/PackageMatcherTest.java @@ -3,22 +3,19 @@ import java.util.Optional; import com.tngtech.archunit.core.domain.PackageMatcher.Result; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; import static com.tngtech.archunit.core.domain.PackageMatcher.TO_GROUPS; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; import static org.assertj.core.api.Assertions.assertThatThrownBy; -@RunWith(DataProviderRunner.class) public class PackageMatcherTest { - @Test - @DataProvider(value = { + @ParameterizedTest + @CsvSource(delimiter = ',', ignoreLeadingAndTrailingWhitespace = true, value = { "some.arbitrary.pkg , some.arbitrary.pkg , true", "some.arbitrary.pkg , some.thing.different , false", "some..pkg , some.arbitrary.pkg , true", @@ -60,8 +57,8 @@ public void match(String matcher, String target, boolean matches) { .isEqualTo(matches); } - @Test - @DataProvider(value = { + @ParameterizedTest + @CsvSource(delimiter = ',', ignoreLeadingAndTrailingWhitespace = true, nullValues = "null", value = { "some.(*).pkg , some.arbitrary.pkg , arbitrary", "some.arb(*)ry.pkg , some.arbitrary.pkg , itra", "some.arb(*)ry.pkg , some.arbit.rary.pkg , null", @@ -139,19 +136,14 @@ public void should_reject_toplevel_alternations() { .hasMessage("Package Identifier only supports '|' inside of '[]' or '()'"); } - @DataProvider - public static Object[][] data_reject_nesting_of_groups() { - return testForEach( - "some.(pkg.(other).pkg)..", - "some.(pkg.[a|b].pkg)..", - "some.[inside.(pkg).it|other.(pkg).it].pkg", - "some.[inside.[a|b].it|other].pkg" - ); - } - - @Test - @UseDataProvider - public void test_reject_nesting_of_groups(String packageIdentifier) { + @ParameterizedTest + @ValueSource(strings = { + "some.(pkg.(other).pkg)..", + "some.(pkg.[a|b].pkg)..", + "some.[inside.(pkg).it|other.(pkg).it].pkg", + "some.[inside.[a|b].it|other].pkg" + }) + void reject_nesting_of_groups(String packageIdentifier) { assertThatThrownBy(() -> PackageMatcher.of(packageIdentifier)) .isInstanceOf(IllegalArgumentException.class) .hasMessage("Package Identifier does not support nesting '()' or '[]' within other '()' or '[]'"); diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericInterfacesTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericInterfacesTest.java index 38efa3b1ec..330b180dbd 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericInterfacesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericInterfacesTest.java @@ -13,11 +13,9 @@ import com.tngtech.archunit.core.domain.JavaType; import com.tngtech.archunit.core.importer.ClassFileImporterGenericInterfacesTest.Outer.SomeNestedInterface; import com.tngtech.archunit.core.importer.ClassFileImporterGenericInterfacesTest.Outer.SomeNestedInterface.SomeDeeplyNestedInterface; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.core.importer.DependencyResolutionProcessTestUtils.importClassWithOnlyGenericTypeResolution; @@ -32,9 +30,7 @@ import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteParameterizedType.parameterizedType; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteTypeVariable.typeVariable; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteWildcardType.wildcardType; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; -@RunWith(DataProviderRunner.class) public class ClassFileImporterGenericInterfacesTest { @Test @@ -394,17 +390,12 @@ interface InterfaceChild testInput) { + @ParameterizedTest + @ValueSource(classes = { + Data_of_imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_self_referencing_type_definitions.ClassChild.class, + Data_of_imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_self_referencing_type_definitions.InterfaceChild.class + }) + void imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_self_referencing_type_definitions(Class testInput) { JavaType genericInterface = getOnlyElement(importClassWithOnlyGenericTypeResolution(testInput).getInterfaces()); // @formatter:off @@ -456,17 +447,12 @@ interface InterfaceChild extends InterfaceWithThreeTypeParameters< } } - @DataProvider - public static Object[][] data_imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_concrete_array_bounds() { - return testForEach( - Data_of_imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_concrete_array_bounds.ClassChild.class, - Data_of_imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_concrete_array_bounds.InterfaceChild.class - ); - } - - @Test - @UseDataProvider - public void test_imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_concrete_array_bounds(Class testInput) { + @ParameterizedTest + @ValueSource(classes = { + Data_of_imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_concrete_array_bounds.ClassChild.class, + Data_of_imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_concrete_array_bounds.InterfaceChild.class + }) + void imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_concrete_array_bounds(Class testInput) { JavaType genericInterface = getOnlyElement(importClassWithOnlyGenericTypeResolution(testInput).getInterfaces()); assertThatType(genericInterface).hasActualTypeArguments( @@ -489,17 +475,12 @@ interface InterfaceChild extends InterfaceWithThreeTypeParameters[] } } - @DataProvider - public static Object[][] data_imports_type_of_generic_interface_with_parameterized_array_bounds() { - return testForEach( - Data_of_imports_type_of_generic_interface_with_parameterized_array_bounds.ClassChild.class, - Data_of_imports_type_of_generic_interface_with_parameterized_array_bounds.InterfaceChild.class - ); - } - - @Test - @UseDataProvider - public void test_imports_type_of_generic_interface_with_parameterized_array_bounds(Class testInput) { + @ParameterizedTest + @ValueSource(classes = { + Data_of_imports_type_of_generic_interface_with_parameterized_array_bounds.ClassChild.class, + Data_of_imports_type_of_generic_interface_with_parameterized_array_bounds.InterfaceChild.class + }) + void imports_type_of_generic_interface_with_parameterized_array_bounds(Class testInput) { JavaType genericInterface = getOnlyElement(importClassWithOnlyGenericTypeResolution(testInput).getInterfaces()); assertThatType(genericInterface).hasActualTypeArguments( @@ -528,17 +509,12 @@ interface InterfaceChild extends Inter } } - @DataProvider - public static Object[][] data_imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_generic_array_bounds() { - return testForEach( - Data_of_imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_generic_array_bounds.ClassChild.class, - Data_of_imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_generic_array_bounds.InterfaceChild.class - ); - } - - @Test - @UseDataProvider - public void test_imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_generic_array_bounds(Class testInput) { + @ParameterizedTest + @ValueSource(classes = { + Data_of_imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_generic_array_bounds.ClassChild.class, + Data_of_imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_generic_array_bounds.InterfaceChild.class + }) + void imports_complex_type_with_multiple_nested_actual_type_arguments_of_generic_interface_with_generic_array_bounds(Class testInput) { JavaType genericInterface = getOnlyElement(importClassWithOnlyGenericTypeResolution(testInput).getInterfaces()); assertThatType(genericInterface).hasActualTypeArguments( @@ -582,16 +558,12 @@ interface InterfaceChild extends } } - @DataProvider - public static Object[][] data_imports_multiple_generic_interfaces() { - return testForEach( - Data_of_imports_multiple_generic_interfaces.ClassChild.class, - Data_of_imports_multiple_generic_interfaces.InterfaceChild.class); - } - - @Test - @UseDataProvider - public void test_imports_multiple_generic_interfaces(Class testInput) { + @ParameterizedTest + @ValueSource(classes = { + Data_of_imports_multiple_generic_interfaces.ClassChild.class, + Data_of_imports_multiple_generic_interfaces.InterfaceChild.class + }) + void imports_multiple_generic_interfaces(Class testInput) { JavaClass child = importClassWithOnlyGenericTypeResolution(testInput); assertThatType(getGenericInterface(child, InterfaceWithOneTypeParameter.class)).as("generic interface") diff --git a/archunit/src/test/java/com/tngtech/archunit/library/freeze/ViolationLineMatcherFactoryTest.java b/archunit/src/test/java/com/tngtech/archunit/library/freeze/ViolationLineMatcherFactoryTest.java index 6f42db0565..126a7d45da 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/freeze/ViolationLineMatcherFactoryTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/freeze/ViolationLineMatcherFactoryTest.java @@ -1,19 +1,16 @@ package com.tngtech.archunit.library.freeze; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class ViolationLineMatcherFactoryTest { - @Test - @DataProvider(splitBy = "\\|", value = { + @ParameterizedTest + @CsvSource(delimiter = '|', value = { "" + - "|" + - "|" + true, + "''|" + + "''|" + true, "" + "abc|" + "abc|" + true, @@ -48,7 +45,7 @@ public class ViolationLineMatcherFactoryTest { "A:1) B$2 C|" + // limitation of the current implementation: "A: B$ C|" + true, // false positive }) - public void default_matcher(String str1, String str2, boolean expected) { + void default_matcher(String str1, String str2, boolean expected) { ViolationLineMatcher defaultMatcher = ViolationLineMatcherFactory.create(); assertThat(defaultMatcher.matches(str1, str2)) .as(String.format("'%s' matches '%s'", str1, str2)) From 289088d792f48a0ca66fd63d0f00574c132ffe29 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stefan=20Gr=C3=A4ber?= Date: Fri, 10 Jul 2026 14:08:26 +0200 Subject: [PATCH 03/11] migrate ViolationLineMatcherFactoryTest to MethodSource MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Stefan Gräber Co-authored-by: Manfred Hanke Signed-off-by: Manfred Hanke --- .../ViolationLineMatcherFactoryTest.java | 107 +++++++++++------- 1 file changed, 68 insertions(+), 39 deletions(-) diff --git a/archunit/src/test/java/com/tngtech/archunit/library/freeze/ViolationLineMatcherFactoryTest.java b/archunit/src/test/java/com/tngtech/archunit/library/freeze/ViolationLineMatcherFactoryTest.java index 126a7d45da..6993d6f391 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/freeze/ViolationLineMatcherFactoryTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/freeze/ViolationLineMatcherFactoryTest.java @@ -1,50 +1,79 @@ package com.tngtech.archunit.library.freeze; +import java.util.stream.Stream; + import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class ViolationLineMatcherFactoryTest { + + private static Stream default_matcher() { + return Stream.of( + expectMatch( + "", + "" + ), + expectMatch( + "abc", + "abc" + ), + expectNoMatch( + "abc", + "abcd" + ), + expectMatch( + "(A.java:1)", + "(A.java:2)" + ), + expectNoMatch( + "A.java:1", + "A.java:2" + ), + expectNoMatch( + "(A.java:1)", + "(A.java:2" + ), + expectMatch( + "A$1 B$2 C$4 (X.java:111)", + "A$2 B$3 C$5 (X.java:222)" + ), + expectNoMatch( + "A$a", + "A$b" + ), + expectNoMatch( + "A:1", + "A$2" + ), + expectMatch( + "Method has a violation in (MyClass.java:123)", + "Method has a violation in (MyClass.java:0)" + ), + expectNoMatch( + "Method is bad in (C.java:123)", + "Method is bad in (C.java:123), too" + ), + expectMatch( // limitation of the current implementation, false positive + "A:1) B$2 C", + "A: B$ C" + ) + ); + } + + private static Arguments expectMatch(String str1, String str2) { + return arguments(str1, str2, true); + } + + private static Arguments expectNoMatch(String str1, String str2) { + return arguments(str1, str2, false); + } + @ParameterizedTest - @CsvSource(delimiter = '|', value = { - "" + - "''|" + - "''|" + true, - "" + - "abc|" + - "abc|" + true, - "" + - "abc|" + - "abcd|" + false, - "" + - "(A.java:1)|" + - "(A.java:2)|" + true, - "" + - "A.java:1|" + - "A.java:2|" + false, - "" + - "(A.java:1)|" + - "(A.java:2|" + false, - "" + - "A$1 B$2 C$4 (X.java:111)|" + - "A$2 B$3 C$5 (X.java:222)|" + true, - "" + - "A$a|" + - "A$b|" + false, - "" + - "A:1|" + - "A$2|" + false, - "" + - "Method has a violation in (MyClass.java:123)|" + - "Method has a violation in (MyClass.java:0)|" + true, - "" + - "Method is bad in (C.java:123)|" + - "Method is bad in (C.java:123), too|" + false, - "" + - "A:1) B$2 C|" + // limitation of the current implementation: - "A: B$ C|" + true, // false positive - }) + @MethodSource void default_matcher(String str1, String str2, boolean expected) { ViolationLineMatcher defaultMatcher = ViolationLineMatcherFactory.create(); assertThat(defaultMatcher.matches(str1, str2)) From c3d3253606dda09dc2545c48dd62726aaba02f52 Mon Sep 17 00:00:00 2001 From: Manfred Hanke Date: Sat, 26 Apr 2025 20:31:29 +0200 Subject: [PATCH 04/11] migrate some junit-dataprovider tests to junit-jupiter-params' @MethodSource For convenience (and to keep the diff smaller) `com.tngtech.archunit.testutil.DataProviders.$` provides the same API for `junit-jupiter-params` as `com.tngtech.java.junit.dataprovider.DataProviders.$` did for `junit-dataprovider`. Signed-off-by: Manfred Hanke --- archunit/build.gradle | 1 + .../ClassesShouldNewerJavaVersionTest.java | 36 +- .../ShouldClassesThatRecordsTest.java | 19 +- .../ShouldOnlyByClassesThatRecordsTest.java | 19 +- .../archunit/base/DescribedPredicateTest.java | 39 +- .../archunit/core/domain/DependencyTest.java | 104 +-- .../archunit/core/domain/FormattersTest.java | 97 +- .../core/domain/JavaClassDescriptorTest.java | 57 +- .../archunit/core/domain/JavaClassTest.java | 85 +- .../JavaClassTransitiveDependenciesTest.java | 24 +- .../core/domain/JavaCodeUnitTest.java | 50 +- .../domain/JavaParameterizedTypeTest.java | 24 +- .../archunit/core/domain/SourceTest.java | 96 +- .../properties/HasThrowsClauseTest.java | 22 +- .../core/domain/properties/HasTypeTest.java | 23 +- ...ssFileImporterAutomaticResolutionTest.java | 74 +- ...assFileImporterCodeUnitReferencesTest.java | 47 +- .../ClassFileImporterGenericClassesTest.java | 36 +- ...rterGenericCodeUnitParameterTypesTest.java | 304 +++---- ...leImporterGenericMethodSignaturesTest.java | 297 +++--- ...assFileImporterLambdaDependenciesTest.java | 25 +- .../archunit/core/importer/LocationTest.java | 63 +- .../importer/NormalizedResourceNameTest.java | 47 +- .../ClassResolverFromClassPathTest.java | 41 +- .../archunit/lang/ArchConditionTest.java | 43 +- .../lang/conditions/NeverConditionTest.java | 22 +- .../lang/syntax/TransformersTest.java | 25 +- .../ClassesShouldConjunctionTest.java | 87 +- .../elements/ClassesThatTestsExistTest.java | 5 +- .../syntax/elements/CodeUnitsShouldTest.java | 179 ++-- .../syntax/elements/FieldsShouldTest.java | 37 +- .../syntax/elements/GivenClassShouldTest.java | 514 +++++------ .../lang/syntax/elements/GivenFieldsTest.java | 25 +- .../syntax/elements/GivenMethodsTest.java | 32 +- .../MembersShouldConjunctionTest.java | 49 +- .../syntax/elements/MethodsShouldTest.java | 30 +- .../elements/ShouldClassesThatTest.java | 860 +++++++++--------- .../elements/ShouldOnlyByClassesThatTest.java | 507 +++++------ .../library/LayeredArchitectureTest.java | 67 +- .../library/OnionArchitectureTest.java | 51 +- .../archunit/library/ProxyRulesTest.java | 31 +- .../dependencies/SlicesShouldTest.java | 42 +- .../library/metrics/LakosMetricsTest.java | 25 +- .../library/modules/ArchModuleTest.java | 28 +- .../modules/syntax/ModuleRuleTest.java | 22 +- .../modules/syntax/ModulesShouldTest.java | 41 +- .../archunit/testutil/DataProviders.java | 9 + .../testutil/syntax/MethodCallChainTest.java | 22 +- 48 files changed, 2022 insertions(+), 2361 deletions(-) create mode 100644 archunit/src/test/java/com/tngtech/archunit/testutil/DataProviders.java diff --git a/archunit/build.gradle b/archunit/build.gradle index 52f3452832..d57cea608a 100644 --- a/archunit/build.gradle +++ b/archunit/build.gradle @@ -15,6 +15,7 @@ dependencies { testImplementation libs.junit4 testImplementation libs.junitDataprovider testImplementation libs.mockito + testImplementation libs.mockito.junit5 testImplementation libs.assertj testImplementation(libs.assertj.guava) { exclude module: 'assertj-core' diff --git a/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldNewerJavaVersionTest.java b/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldNewerJavaVersionTest.java index 3d28fe6b89..03058e27c2 100644 --- a/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldNewerJavaVersionTest.java +++ b/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldNewerJavaVersionTest.java @@ -1,37 +1,34 @@ package com.tngtech.archunit.lang.syntax.elements; +import java.util.stream.Stream; + import com.tngtech.archunit.lang.ArchRule; import com.tngtech.archunit.lang.EvaluationResult; import com.tngtech.archunit.lang.conditions.ArchConditions; import com.tngtech.archunit.lang.syntax.elements.testobjects.SomeRecord; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.core.domain.TestUtils.importClasses; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes; import static com.tngtech.archunit.lang.syntax.elements.ClassesShouldTest.locationPattern; import static com.tngtech.archunit.lang.syntax.elements.ClassesShouldTest.singleLineFailureReportOf; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.regex.Pattern.quote; -@RunWith(DataProviderRunner.class) public class ClassesShouldNewerJavaVersionTest { - @DataProvider - public static Object[][] data_beRecords() { - return $$( + static Stream be_records() { + return Stream.of( $(classes().should().beRecords(), SomeRecord.class, String.class), $(classes().should(ArchConditions.beRecords()), SomeRecord.class, String.class)); } - @Test - @UseDataProvider - public void test_beRecords(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource + void be_records(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -42,16 +39,15 @@ public void test_beRecords(ArchRule rule, Class satisfied, Class violated) .doesNotMatch(String.format(".*%s.* record.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] data_notBeRecords() { - return $$( + static Stream not_be_records() { + return Stream.of( $(classes().should().notBeRecords(), String.class, SomeRecord.class), $(classes().should(ArchConditions.notBeRecords()), String.class, SomeRecord.class)); } - @Test - @UseDataProvider - public void test_notBeRecords(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource + void not_be_records(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) diff --git a/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ShouldClassesThatRecordsTest.java b/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ShouldClassesThatRecordsTest.java index c7c208ca0b..56960b2c9e 100644 --- a/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ShouldClassesThatRecordsTest.java +++ b/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ShouldClassesThatRecordsTest.java @@ -1,20 +1,17 @@ package com.tngtech.archunit.lang.syntax.elements; import com.tngtech.archunit.core.importer.ClassFileImporter; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; import static java.util.regex.Pattern.quote; -@RunWith(DataProviderRunner.class) public class ShouldClassesThatRecordsTest { - @Test - @UseDataProvider(location = ShouldClassesThatTest.class, value = "no_classes_should_that_rule_starts") - public void areRecords_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("com.tngtech.archunit.lang.syntax.elements.ShouldClassesThatTest#no_classes_should_that_rule_starts") + void areRecords_predicate(ClassesThat noClassesShouldThatRuleStart) { record SomeRecord(String param) { } @SuppressWarnings("unused") @@ -36,9 +33,9 @@ void call() { .hasNoViolationMatching(".*" + quote(ClassNotAccessingRecord.class.getName()) + ".*" + quote(ClassAccessingRecord.class.getName()) + ".*"); } - @Test - @UseDataProvider(location = ShouldClassesThatTest.class, value = "no_classes_should_that_rule_starts") - public void areNotRecords_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("com.tngtech.archunit.lang.syntax.elements.ShouldClassesThatTest#no_classes_should_that_rule_starts") + void areNotRecords_predicate(ClassesThat noClassesShouldThatRuleStart) { record SomeRecord(String param) { } @SuppressWarnings("unused") diff --git a/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ShouldOnlyByClassesThatRecordsTest.java b/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ShouldOnlyByClassesThatRecordsTest.java index 4585bafb70..79685f6e76 100644 --- a/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ShouldOnlyByClassesThatRecordsTest.java +++ b/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ShouldOnlyByClassesThatRecordsTest.java @@ -1,20 +1,17 @@ package com.tngtech.archunit.lang.syntax.elements; import com.tngtech.archunit.core.importer.ClassFileImporter; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; import static java.util.regex.Pattern.quote; -@RunWith(DataProviderRunner.class) public class ShouldOnlyByClassesThatRecordsTest { - @Test - @UseDataProvider(location = ShouldOnlyByClassesThatTest.class, value = "should_only_be_by_rule_starts") - public void areRecords_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("com.tngtech.archunit.lang.syntax.elements.ShouldOnlyByClassesThatTest#should_only_be_by_rule_starts") + void areRecords_predicate(ClassesThat classesShouldOnlyBeBy) { record SomeRecord(String param) { } record RecordAccessingRecord(String param) { @@ -36,9 +33,9 @@ void call() { .hasNoViolationMatching(".*" + quote(RecordAccessingRecord.class.getName()) + ".*" + quote(SomeRecord.class.getName()) + ".*"); } - @Test - @UseDataProvider(location = ShouldOnlyByClassesThatTest.class, value = "should_only_be_by_rule_starts") - public void areNotRecords_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("com.tngtech.archunit.lang.syntax.elements.ShouldOnlyByClassesThatTest#should_only_be_by_rule_starts") + void areNotRecords_predicate(ClassesThat classesShouldOnlyBeBy) { record SomeRecord(String param) { } record RecordAccessingRecord(String param) { diff --git a/archunit/src/test/java/com/tngtech/archunit/base/DescribedPredicateTest.java b/archunit/src/test/java/com/tngtech/archunit/base/DescribedPredicateTest.java index 15d6236b3d..4c01b67a17 100644 --- a/archunit/src/test/java/com/tngtech/archunit/base/DescribedPredicateTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/base/DescribedPredicateTest.java @@ -3,13 +3,12 @@ import java.util.Collections; import java.util.function.Function; import java.util.function.Predicate; +import java.util.stream.Stream; import com.google.common.collect.ImmutableList; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.base.DescribedPredicate.allElements; import static com.tngtech.archunit.base.DescribedPredicate.alwaysFalse; @@ -26,12 +25,9 @@ import static com.tngtech.archunit.base.DescribedPredicate.lessThanOrEqualTo; import static com.tngtech.archunit.base.DescribedPredicate.not; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; import static java.util.Collections.emptyList; import static java.util.Collections.emptySet; -@RunWith(DataProviderRunner.class) public class DescribedPredicateTest { @Test @@ -197,39 +193,38 @@ public void describe_works() { .rejects(5); } - @DataProvider - public static Object[][] not_scenarios() { - return $$( - $(new NotScenario("not", ".negate") { + static Stream not_scenarios() { + return Stream.of( + new NotScenario("not", ".negate") { @Override DescribedPredicate apply(DescribedPredicate input) { return input.negate(); } - }), - $(new NotScenario("not", "not") { + }, + new NotScenario("not", "not") { @Override DescribedPredicate apply(DescribedPredicate input) { return not(input); } - }), - $(new NotScenario("do not", "doNot") { + }, + new NotScenario("do not", "doNot") { @Override DescribedPredicate apply(DescribedPredicate input) { return doNot(input); } - }), - $(new NotScenario("does not", "doesNot") { + }, + new NotScenario("does not", "doesNot") { @Override DescribedPredicate apply(DescribedPredicate input) { return doesNot(input); } - }) + } ); } - @Test - @UseDataProvider("not_scenarios") - public void not_works(NotScenario scenario) { + @ParameterizedTest + @MethodSource("not_scenarios") + void not_works(NotScenario scenario) { assertThat(scenario.apply(equalTo(5))) .accepts(4) .hasDescription(scenario.expectedPrefix + " equal to '5'") diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/DependencyTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/DependencyTest.java index f56e69dbd2..3181d85be2 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/DependencyTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/DependencyTest.java @@ -9,6 +9,7 @@ import java.util.Set; import java.util.function.Consumer; import java.util.function.Supplier; +import java.util.stream.Stream; import com.google.common.base.MoreObjects; import com.tngtech.archunit.base.DescribedPredicate; @@ -20,11 +21,10 @@ import com.tngtech.archunit.testutil.Assertions; import com.tngtech.archunit.testutil.assertion.DependenciesAssertion; import com.tngtech.archunit.testutil.assertion.DependencyAssertion; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.google.common.collect.MoreCollectors.onlyElement; @@ -41,29 +41,25 @@ import static com.tngtech.archunit.testutil.Assertions.assertThatConversionOf; import static com.tngtech.archunit.testutil.Assertions.assertThatDependencies; import static com.tngtech.archunit.testutil.Assertions.assertThatType; +import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.assertion.DependenciesAssertion.from; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; -@RunWith(DataProviderRunner.class) public class DependencyTest { - @DataProvider - public static Object[][] field_array_types() throws NoSuchFieldException { + static Stream field_array_types() throws NoSuchFieldException { @SuppressWarnings("unused") class ClassWithArrayDependencies { private String[] oneDimArray; private String[][] multiDimArray; } - return testForEach( + return Stream.of( ClassWithArrayDependencies.class.getDeclaredField("oneDimArray"), ClassWithArrayDependencies.class.getDeclaredField("multiDimArray")); } - @Test - @UseDataProvider("field_array_types") - public void Dependencies_from_field_with_component_type(Field reflectionArrayField) { + @ParameterizedTest + @MethodSource("field_array_types") + void dependencies_from_field_with_component_type(Field reflectionArrayField) { Class reflectionDeclaringClass = reflectionArrayField.getDeclaringClass(); JavaField field = new ClassFileImporter().importClasses(reflectionDeclaringClass).get(reflectionDeclaringClass).getField(reflectionArrayField.getName()); @@ -92,8 +88,7 @@ void callMe() { } } - @DataProvider - public static Object[][] data_dependency_from_access() { + static Stream> dependency_from_access() { @SuppressWarnings("unused") class Origin { String fieldAccess(Data_dependency_from_access.Target target) { @@ -117,7 +112,7 @@ Consumer methodReference() { } } JavaClass origin = new ClassFileImporter().importClasses(Origin.class, Data_dependency_from_access.Target.class).get(Origin.class); - return testForEach( + return Stream.of( getOnlyElement(origin.getMethod("fieldAccess", Data_dependency_from_access.Target.class).getFieldAccesses()), getOnlyElement(origin.getMethod("constructorCall").getConstructorCallsFromSelf()), getOnlyElement(origin.getMethod("methodCall", Data_dependency_from_access.Target.class).getMethodCallsFromSelf()), @@ -126,25 +121,24 @@ Consumer methodReference() { ); } - @Test - @UseDataProvider - public void test_dependency_from_access(JavaAccess access) { + @ParameterizedTest + @MethodSource + void dependency_from_access(JavaAccess access) { Dependency dependency = getOnlyElement(Dependency.tryCreateFromAccess(access)); assertThatType(dependency.getTargetClass()).as("target class").isEqualTo(access.getTargetOwner()); assertThat(dependency.getDescription()).as("description").isEqualTo(access.getDescription()); } - @DataProvider - public static Object[][] method_calls_to_array_types() { - return $$( + static Stream method_calls_to_array_types() { + return Stream.of( $(ClassWithArrayDependencies.class, "oneDimArray", String[].class, 6), $(ClassWithArrayDependencies.class, "multiDimArray", String[][].class, 10) ); } - @Test - @UseDataProvider("method_calls_to_array_types") - public void Dependency_from_access_with_component_type(Class classDependingOnArray, String nameOfMethodWithArrayMethodCall, Class arrayType, int expectedLineNumber) throws NoSuchMethodException { + @ParameterizedTest + @MethodSource("method_calls_to_array_types") + void dependency_from_access_with_component_type(Class classDependingOnArray, String nameOfMethodWithArrayMethodCall, Class arrayType, int expectedLineNumber) throws NoSuchMethodException { Method reflectionMethodWithArrayMethodCall = classDependingOnArray.getDeclaredMethod(nameOfMethodWithArrayMethodCall); Class reflectionDeclaringClass = reflectionMethodWithArrayMethodCall.getDeclaringClass(); JavaMethod method = new ClassFileImporter().importClasses(reflectionDeclaringClass) @@ -200,20 +194,19 @@ public void Dependency_from_throws_declaration() { .contains("Method <" + origin.getFullName() + "> throws type <" + IOException.class.getName() + ">"); } - @DataProvider - public static Object[][] with_instanceof_check_members() { + static Stream with_instanceof_check_members() { JavaClass javaClass = importClassesWithContext(ClassWithDependencyOnInstanceofCheck.class, InstanceOfCheckTarget.class) .get(ClassWithDependencyOnInstanceofCheck.class); - return $$( + return Stream.of( $(javaClass.getStaticInitializer().get(), 6), $(javaClass.getConstructor(Object.class), 9), $(javaClass.getMethod("method", Object.class), 13)); } - @Test - @UseDataProvider("with_instanceof_check_members") - public void Dependency_from_instanceof_check_in_code_unit(JavaCodeUnit memberWithInstanceofCheck, int expectedLineNumber) { + @ParameterizedTest + @MethodSource("with_instanceof_check_members") + void dependency_from_instanceof_check_in_code_unit(JavaCodeUnit memberWithInstanceofCheck, int expectedLineNumber) { InstanceofCheck instanceofCheck = getOnlyElement(memberWithInstanceofCheck.getInstanceofChecks()); Dependency dependency = getOnlyElement(Dependency.tryCreateFromInstanceofCheck(instanceofCheck)); @@ -224,19 +217,18 @@ public void Dependency_from_instanceof_check_in_code_unit(JavaCodeUnit memberWit .inLocation(ClassWithDependencyOnInstanceofCheck.class, expectedLineNumber); } - @DataProvider - public static Object[][] annotated_classes() { + static Stream annotated_classes() { JavaClasses classes = importClassesWithContext( ClassWithDependencyOnAnnotation.class, InterfaceWithDependencyOnAnnotation.class, SomeAnnotation.class, SomeMemberType.class); - return testForEach( + return Stream.of( classes.get(ClassWithDependencyOnAnnotation.class), classes.get(InterfaceWithDependencyOnAnnotation.class)); } - @Test - @UseDataProvider("annotated_classes") - public void Dependency_from_annotation_on_class(JavaClass annotatedClass) { + @ParameterizedTest + @MethodSource("annotated_classes") + void dependency_from_annotation_on_class(JavaClass annotatedClass) { JavaAnnotation annotation = annotatedClass.getAnnotations().iterator().next(); Class annotationClass = annotation.getRawType().reflect(); @@ -247,20 +239,19 @@ public void Dependency_from_annotation_on_class(JavaClass annotatedClass) { .contains("Class <" + annotatedClass.getName() + "> is annotated with <" + annotationClass.getName() + ">"); } - @DataProvider - public static Object[][] annotated_members() { + static Stream annotated_members() { JavaClass javaClass = importClassesWithContext(ClassWithAnnotatedMembers.class, SomeAnnotation.class, SomeMemberType.class) .get(ClassWithAnnotatedMembers.class); - return testForEach( + return Stream.of( javaClass.getField("annotatedField"), javaClass.getConstructor(Object.class), javaClass.getMethod("annotatedMethod")); } - @Test - @UseDataProvider("annotated_members") - public void Dependency_from_annotation_on_member(JavaMember annotatedMember) { + @ParameterizedTest + @MethodSource("annotated_members") + void dependency_from_annotation_on_member(JavaMember annotatedMember) { JavaAnnotation annotation = annotatedMember.getAnnotations().iterator().next(); Class annotationClass = annotation.getRawType().reflect(); @@ -292,9 +283,9 @@ void method(@SomeAnnotation(String.class) Object param) { + "is annotated with <" + SomeAnnotation.class.getName() + ">"); } - @Test - @UseDataProvider("annotated_classes") - public void Dependency_from_class_annotation_member(JavaClass annotatedClass) { + @ParameterizedTest + @MethodSource("annotated_classes") + void dependency_from_class_annotation_member(JavaClass annotatedClass) { JavaAnnotation annotation = annotatedClass.getAnnotationOfType(SomeAnnotation.class.getName()); JavaClass memberType = ((JavaClass) annotation.get("value").get()); @@ -305,9 +296,9 @@ public void Dependency_from_class_annotation_member(JavaClass annotatedClass) { .contains("Class <" + annotatedClass.getName() + "> has annotation member of type <" + memberType.getName() + ">"); } - @Test - @UseDataProvider("annotated_members") - public void Dependency_from_member_annotation_member(JavaMember annotatedMember) { + @ParameterizedTest + @MethodSource("annotated_members") + void dependency_from_member_annotation_member(JavaMember annotatedMember) { JavaAnnotation annotation = annotatedMember.getAnnotationOfType(SomeAnnotation.class.getName()); JavaClass memberType = ((JavaClass) annotation.get("value").get()); @@ -482,8 +473,7 @@ SomeGenericType method(String anyParam) { getClass().getSimpleName())); } - @DataProvider - public static Object[][] data_Dependency_from_generic_code_unit_parameter_type_arguments() { + static Stream dependency_from_generic_code_unit_parameter_type_arguments() { @SuppressWarnings("unused") class SomeGenericType { } @@ -503,14 +493,14 @@ void genericTypeOnMethod(SomeGenericType param) { JavaMethod method = importClassesWithContext(GenericTypeOnMethod.class, SomeGenericType.class, String.class) .get(GenericTypeOnMethod.class).getMethod("genericTypeOnMethod", SomeGenericType.class); String expectedGenericParameterTypeName = SomeGenericType.class.getName() + "<" + String.class.getName() + ">"; - return $$( + return Stream.of( $(constructor, expectedGenericParameterTypeName), $(method, expectedGenericParameterTypeName)); } - @Test - @UseDataProvider - public void test_Dependency_from_generic_code_unit_parameter_type_arguments(JavaCodeUnit codeUnit, String expectedGenericParameterTypeName) { + @ParameterizedTest + @MethodSource + void dependency_from_generic_code_unit_parameter_type_arguments(JavaCodeUnit codeUnit, String expectedGenericParameterTypeName) { JavaType parameterType = getOnlyElement(codeUnit.getParameterTypes()); JavaClass typeArgumentDependency = (JavaClass) ((JavaParameterizedType) parameterType).getActualTypeArguments().get(0); diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/FormattersTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/FormattersTest.java index 4eef0db7af..de3ab1a213 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/FormattersTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/FormattersTest.java @@ -5,30 +5,29 @@ import java.util.ArrayList; import java.util.List; import java.util.Set; +import java.util.stream.Stream; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Sets; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.ImmutableList.of; import static com.google.common.collect.Sets.union; import static com.google.common.primitives.Primitives.allPrimitiveTypes; import static com.tngtech.archunit.core.domain.Formatters.joinSingleQuoted; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.Arrays.stream; import static java.util.Collections.emptyList; import static java.util.Collections.singleton; import static java.util.stream.Collectors.toList; import static org.assertj.core.api.Assertions.assertThatThrownBy; -@RunWith(DataProviderRunner.class) public class FormattersTest { @Test @@ -56,71 +55,65 @@ public void ensureSimpleName_withNullString() { ).isInstanceOf(NullPointerException.class); } - @DataProvider - public static Object[][] simple_name_test_cases() { - return $$( - $("", ""), - $("Dummy", "Dummy"), - $("org.example.Dummy", "Dummy"), - $("org.example.Dummy$123", ""), - $("org.example.Dummy$NestedClass", "NestedClass"), - $("org.example.Dummy$NestedClass123", "NestedClass123"), - $("org.example.Dummy$NestedClass$123", ""), - $("org.example.Dummy$NestedClass$MoreNestedClass", "MoreNestedClass"), - $("org.example.Dummy$123LocalClass", "LocalClass"), - $("org.example.Dummy$Inner$123LocalClass", "LocalClass"), - $("org.example.Dummy$Inner$123LocalClass123", "LocalClass123"), - $("Dummy[]", "Dummy[]"), - $("org.example.Dummy[]", "Dummy[]"), - $("org.example.Dummy$Inner[][]", "Inner[][]")); - } - - @Test - @UseDataProvider("simple_name_test_cases") - public void ensureSimpleName(String input, String expected) { + @ParameterizedTest + @CsvSource(delimiter = ',', ignoreLeadingAndTrailingWhitespace = true, value = { + "'' , ''", + "Dummy , Dummy", + "org.example.Dummy , Dummy", + "org.example.Dummy$123 , ''", + "org.example.Dummy$NestedClass , NestedClass", + "org.example.Dummy$NestedClass123 , NestedClass123", + "org.example.Dummy$NestedClass$123 , ''", + "org.example.Dummy$NestedClass$MoreNestedClass , MoreNestedClass", + "org.example.Dummy$123LocalClass , LocalClass", + "org.example.Dummy$Inner$123LocalClass , LocalClass", + "org.example.Dummy$Inner$123LocalClass123 , LocalClass123", + "Dummy[] , Dummy[]", + "org.example.Dummy[] , Dummy[]", + "org.example.Dummy$Inner[][] , Inner[][]" + }) + void ensureSimpleName(String input, String expected) { assertThat(Formatters.ensureSimpleName(input)).isEqualTo(expected); } - @DataProvider - public static List> canonical_array_name_test_cases() { + static List canonical_array_name_test_cases() { class SomeClass { } - List> testCases = new ArrayList<>(); - testCases.add(ImmutableList.of("", "")); - testCases.add(ImmutableList.of(SomeClass.class.getSimpleName(), SomeClass.class.getSimpleName())); - testCases.addAll(generateCanonicalNameTestCases(union(ImmutableSet.of(String.class, SomeClass.class), allRelevantPrimitiveTypes()))); - testCases.add(ImmutableList.of("[[Lorg.example.Some$Inner;", "org.example.Some$Inner[][]")); - return testCases; + return ImmutableList.builder() + .add($("", "")) + .add($(SomeClass.class.getSimpleName(), SomeClass.class.getSimpleName())) + .addAll(generateCanonicalNameTestCases(union(ImmutableSet.of(String.class, SomeClass.class), allRelevantPrimitiveTypes()))) + .add($("[[Lorg.example.Some$Inner;", "org.example.Some$Inner[][]")) + .build(); } private static Set> allRelevantPrimitiveTypes() { return Sets.difference(allPrimitiveTypes(), singleton(void.class)); } - private static List> generateCanonicalNameTestCases(Iterable> classes) { - List> result = new ArrayList<>(); + private static List generateCanonicalNameTestCases(Iterable> classes) { + List result = new ArrayList<>(); for (Class componentType : classes) { - result.add(ImmutableList.of(componentType.getName(), componentType.getName())); + result.add($(componentType.getName(), componentType.getName())); Class oneDim = Array.newInstance(componentType, 0).getClass(); - result.add(ImmutableList.of(oneDim.getName(), componentType.getName() + "[]")); + result.add($(oneDim.getName(), componentType.getName() + "[]")); Class twoDim = Array.newInstance(oneDim, 0).getClass(); - result.add(ImmutableList.of(twoDim.getName(), componentType.getName() + "[][]")); + result.add($(twoDim.getName(), componentType.getName() + "[][]")); } return result; } - @Test - @UseDataProvider("canonical_array_name_test_cases") - public void ensureCanonicalArrayTypeName(String input, String expected) { + @ParameterizedTest + @MethodSource("canonical_array_name_test_cases") + void ensureCanonicalArrayTypeName(String input, String expected) { assertThat(Formatters.ensureCanonicalArrayTypeName(input)).as("Canonical name of '%s'", input).isEqualTo(expected); } - @DataProvider - public static Object[][] data_joinSingleQuoted() { - return $$( + static Stream test_joinSingleQuoted() { + return Stream.of( $(new String[0], ""), $(new String[]{"one"}, "'one'"), $(new String[]{"one", "two"}, "'one', 'two'"), @@ -129,9 +122,9 @@ public static Object[][] data_joinSingleQuoted() { ); } - @Test - @UseDataProvider - public void test_joinSingleQuoted(String[] input, String expectedOutput) { + @ParameterizedTest + @MethodSource + void test_joinSingleQuoted(String[] input, String expectedOutput) { assertThat(joinSingleQuoted(input)).isEqualTo(expectedOutput); assertThat(joinSingleQuoted(stream(input).collect(toList()))).isEqualTo(expectedOutput); } diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassDescriptorTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassDescriptorTest.java index 49371f713e..6caff16270 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassDescriptorTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassDescriptorTest.java @@ -5,22 +5,21 @@ import com.google.common.collect.ImmutableList; import com.tngtech.archunit.base.ArchUnitException.ReflectionException; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import org.objectweb.asm.Type; import static com.tngtech.archunit.testutil.Assertions.assertThat; +import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThatThrownBy; -@RunWith(DataProviderRunner.class) public class JavaClassDescriptorTest { - @Test - @UseDataProvider("primitives") - public void primitive_types_by_name_and_descriptor(String name, Class expected) { + @ParameterizedTest + @MethodSource("primitives") + void primitive_types_by_name_and_descriptor(String name, Class expected) { JavaClassDescriptor primitiveType = JavaClassDescriptor.From.name(name); assertThat(primitiveType.isPrimitive()).isTrue(); assertThat(primitiveType.isArray()).isFalse(); @@ -29,9 +28,9 @@ public void primitive_types_by_name_and_descriptor(String name, Class expecte assertThat(primitiveType).isEquivalentTo(expected); } - @Test - @UseDataProvider("arrays") - public void array_types_by_name_and_canonical_name(String name, Class expected) { + @ParameterizedTest + @MethodSource("arrays") + void array_types_by_name_and_canonical_name(String name, Class expected) { JavaClassDescriptor arrayType = JavaClassDescriptor.From.name(name); assertThat(arrayType.isPrimitive()).isFalse(); assertThat(arrayType.isArray()).isTrue(); @@ -50,15 +49,15 @@ public void object_name() { assertThat(objectType).isEquivalentTo(Object.class); } - @Test - @UseDataProvider(value = "primitives") - public void resolves_primitive_type_names(String name, Class expected) { + @ParameterizedTest + @MethodSource(value = "primitives") + void resolves_primitive_type_names(String name, Class expected) { assertThat(JavaClassDescriptor.From.name(name).resolveClass()).isEqualTo(expected); } - @Test - @UseDataProvider(value = "arrays") - public void resolves_arrays_type_names(String name, Class expected) { + @ParameterizedTest + @MethodSource(value = "arrays") + void resolves_arrays_type_names(String name, Class expected) { assertThat(JavaClassDescriptor.From.name(name).resolveClass()).isEqualTo(expected); } @@ -104,9 +103,8 @@ public void default_package() { assertThat(specialChars.getPackageName()).isEmpty(); } - @DataProvider - public static List> primitives() { - return ImmutableList.>builder() + static List primitives() { + return ImmutableList.builder() .addAll(namesToPrimitive(void.class)) .addAll(namesToPrimitive(boolean.class)) .addAll(namesToPrimitive(byte.class)) @@ -156,15 +154,14 @@ public void converts_descriptor_repeatedly_multi_dim_array_descriptor() { assertThat(arrayDescriptor.getPackageName()).isEqualTo(Object.class.getPackage().getName()); } - private static List> namesToPrimitive(Class primitiveType) { + private static List namesToPrimitive(Class primitiveType) { return ImmutableList.of( - ImmutableList.of(primitiveType.getName(), primitiveType), - ImmutableList.of(Type.getType(primitiveType).getDescriptor(), primitiveType)); + $(primitiveType.getName(), primitiveType), + $(Type.getType(primitiveType).getDescriptor(), primitiveType)); } - @DataProvider - public static List> arrays() { - return ImmutableList.>builder() + static List arrays() { + return ImmutableList.builder() .addAll(namesToArray(boolean[].class)) .addAll(namesToArray(byte[].class)) .addAll(namesToArray(char[].class)) @@ -186,9 +183,9 @@ public static List> arrays() { .build(); } - private static List> namesToArray(Class arrayType) { + private static List namesToArray(Class arrayType) { return ImmutableList.of( - ImmutableList.of(arrayType.getName(), arrayType), - ImmutableList.of(arrayType.getCanonicalName(), arrayType)); + $(arrayType.getName(), arrayType), + $(arrayType.getCanonicalName(), arrayType)); } } diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassTest.java index c08fc3ac32..cda8ed5fcc 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassTest.java @@ -20,6 +20,7 @@ import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Supplier; +import java.util.stream.Stream; import com.google.common.collect.ImmutableSet; import com.tngtech.archunit.base.ArchUnitException.InvalidSyntaxUsageException; @@ -41,15 +42,13 @@ import com.tngtech.archunit.core.importer.testexamples.arrays.ClassAccessingOneDimensionalArray; import com.tngtech.archunit.core.importer.testexamples.arrays.ClassAccessingTwoDimensionalArray; import com.tngtech.archunit.core.importer.testexamples.arrays.ClassUsedInArray; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; import org.assertj.core.api.AbstractBooleanAssert; import org.assertj.core.api.Condition; import org.assertj.core.api.ThrowableAssert.ThrowingCallable; -import org.junit.Assert; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.base.DescribedPredicate.describe; @@ -98,18 +97,16 @@ import static com.tngtech.archunit.testutil.Assertions.assertThatTypes; import static com.tngtech.archunit.testutil.Conditions.codeUnitWithSignature; import static com.tngtech.archunit.testutil.Conditions.containing; +import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.ReflectionTestUtils.getHierarchy; import static com.tngtech.archunit.testutil.assertion.DependenciesAssertion.from; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; import static java.lang.annotation.RetentionPolicy.RUNTIME; import static java.util.Collections.singletonList; import static java.util.regex.Pattern.quote; import static java.util.stream.Collectors.toSet; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.fail; -@RunWith(DataProviderRunner.class) @SuppressWarnings("SameParameterValue") public class JavaClassTest { @@ -164,8 +161,7 @@ public void finds_multidimensional_array_type() { assertThatType(twoDimArray.tryGetComponentType().get().tryGetComponentType().get()).isEqualTo(type); } - @DataProvider - public static Object[][] data_imported_array_types_match_Reflection_API() { + static Stream imported_array_types_match_reflection_api() { @SuppressWarnings("unused") class PublicClassArray { String[] array; @@ -196,7 +192,7 @@ class ProtectedClassArray { class InnerPackagePrivateClassArray { SomePackagePrivateClass[] array; } - return $$( + return Stream.of( $(PublicClassArray.class, String[].class), $(PublicClassMultiDimArray.class, String[][].class), $(PrimitiveClassArray.class, int[].class), @@ -207,9 +203,9 @@ class InnerPackagePrivateClassArray { ); } - @Test - @UseDataProvider - public void test_imported_array_types_match_Reflection_API(Class classWithArrayField, Class expectedReflectionType) { + @ParameterizedTest + @MethodSource + void imported_array_types_match_reflection_api(Class classWithArrayField, Class expectedReflectionType) { JavaClass classWithArray = new ClassFileImporter().importClass(classWithArrayField); JavaClass arrayClassObject = classWithArray.getField("array").getRawType(); @@ -928,8 +924,7 @@ class ClassWithTypeParameters< ); } - @DataProvider - public static Object[][] data_direct_dependencies_from_self_by_code_unit_type_parameters() { + static Stream direct_dependencies_from_self_by_code_unit_type_parameters() { @SuppressWarnings("unused") class TypeParametersOnConstructor { < @@ -954,15 +949,15 @@ class TypeParametersOnMethod { > void typeParametersOnMethod() { } } - return testForEach( + return Stream.of( importClasses(TypeParametersOnConstructor.class).get(TypeParametersOnConstructor.class), importClasses(TypeParametersOnMethod.class).get(TypeParametersOnMethod.class) ); } - @Test - @UseDataProvider - public void test_direct_dependencies_from_self_by_code_unit_type_parameters(JavaClass javaClass) { + @ParameterizedTest + @MethodSource + void direct_dependencies_from_self_by_code_unit_type_parameters(JavaClass javaClass) { assertThatDependencies(javaClass.getDirectDependenciesFromSelf()) .contain(from(javaClass) .withExpectedDescriptionTemplate("type parameter 'FIRST' depending on") @@ -1464,8 +1459,7 @@ class SecondDependingOnOtherThroughTypeParameter< ); } - @DataProvider - public static Object[][] data_direct_dependencies_to_self_by_code_unit_type_parameters() { + static Stream direct_dependencies_to_self_by_code_unit_type_parameters() { class ClassOtherConstructorTypeSignaturesDependOn { } @SuppressWarnings("unused") @@ -1508,7 +1502,7 @@ > void secondDependingOnOtherThroughMethodTypeParameter() { FirstDependingOnOtherThroughMethodTypeParameter.class, SecondDependingOnOtherThroughMethodTypeParameter.class ); - return $$( + return Stream.of( $( dependenciesThroughConstructorTypeParameters.get(FirstDependingOnOtherThroughConstructorTypeParameter.class), dependenciesThroughConstructorTypeParameters.get(SecondDependingOnOtherThroughConstructorTypeParameter.class), @@ -1522,9 +1516,9 @@ > void secondDependingOnOtherThroughMethodTypeParameter() { ); } - @Test - @UseDataProvider - public void test_direct_dependencies_to_self_by_code_unit_type_parameters(JavaClass firstOrigin, JavaClass secondOrigin, JavaClass expectedTarget) { + @ParameterizedTest + @MethodSource + void direct_dependencies_to_self_by_code_unit_type_parameters(JavaClass firstOrigin, JavaClass secondOrigin, JavaClass expectedTarget) { assertThatDependencies(expectedTarget.getDirectDependenciesToSelf()) .contain(from(firstOrigin).to(expectedTarget).inLocation(getClass(), 0) .withDescriptionContaining("type parameter 'T' depending on") @@ -1796,9 +1790,8 @@ public void predicate_assignableTo() { assertThat(assignableTo(System.class)).hasDescription("assignable to java.lang.System"); } - @DataProvider - public static Object[][] implement_match_cases() { - return testForEach( + static Stream> predicate_implement_matches() { + return Stream.of( implement(List.class), implement(Collection.class), implement(List.class.getName()), @@ -1807,9 +1800,9 @@ public static Object[][] implement_match_cases() { implement(name(Collection.class.getName()))); } - @Test - @UseDataProvider("implement_match_cases") - public void predicate_implement_matches(DescribedPredicate expectedMatch) { + @ParameterizedTest + @MethodSource + void predicate_implement_matches(DescribedPredicate expectedMatch) { assertThat(expectedMatch).accepts(classWithHierarchy(ArrayList.class)); } @@ -1827,9 +1820,8 @@ public static void expectInvalidSyntaxUsageForClassInsteadOfInterface(Class n .hasMessageContaining("interface"); } - @DataProvider - public static Object[][] implement_mismatch_cases() { - return testForEach( + static Stream> predicate_implement_mismatches() { + return Stream.of( implement(HasDescription.class), implement(Set.class), implement(HasDescription.class.getName()), @@ -1840,9 +1832,9 @@ public static Object[][] implement_mismatch_cases() { implement(name(String.class.getName()))); } - @Test - @UseDataProvider("implement_mismatch_cases") - public void predicate_implement_mismatches(DescribedPredicate expectedMismatch) { + @ParameterizedTest + @MethodSource + void predicate_implement_mismatches(DescribedPredicate expectedMismatch) { assertThat(expectedMismatch).rejects(classWithHierarchy(ArrayList.class)); } @@ -1897,9 +1889,8 @@ public void predicate_equivalentTo() { .hasDescription("equivalent to " + Parent.class.getName()); } - @DataProvider - public static Object[][] data_predicate_belong_to() { - return testForEach( + static Stream> predicate_belong_to() { + return Stream.of( belongToAnyOf(Object.class, ClassWithNamedAndAnonymousInnerClasses.class), belongTo(describe( String.format("any of [%s, %s]", Object.class.getName(), ClassWithNamedAndAnonymousInnerClasses.class.getName()), @@ -1907,9 +1898,9 @@ public static Object[][] data_predicate_belong_to() { ); } - @Test - @UseDataProvider - public void test_predicate_belong_to(DescribedPredicate belongToPredicate) { + @ParameterizedTest + @MethodSource + void predicate_belong_to(DescribedPredicate belongToPredicate) { JavaClasses classes = new ClassFileImporter().importPackagesOf(getClass()); JavaClass outerAnonymous = getOnlyClassSettingField(classes, ClassWithNamedAndAnonymousInnerClasses.name_of_fieldIndicatingOuterAnonymousInnerClass); @@ -2207,7 +2198,7 @@ public boolean matches(Dependency value) { private void assertIllegalArgumentException(String expectedMessagePart, Runnable runnable) { try { runnable.run(); - Assert.fail("Should have thrown an " + IllegalArgumentException.class.getSimpleName()); + fail("Should have thrown an " + IllegalArgumentException.class.getSimpleName()); } catch (IllegalArgumentException e) { assertThat(e.getMessage()) .as("Messagee of %s", IllegalArgumentException.class.getSimpleName()) diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassTransitiveDependenciesTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassTransitiveDependenciesTest.java index 07c75ed264..2c56860073 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassTransitiveDependenciesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassTransitiveDependenciesTest.java @@ -2,19 +2,16 @@ import java.util.Set; import java.util.function.Function; +import java.util.stream.Stream; import com.tngtech.archunit.core.importer.ClassFileImporter; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.DataProviders; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.core.domain.JavaClass.Functions.GET_TRANSITIVE_DEPENDENCIES_FROM_SELF; import static com.tngtech.archunit.testutil.Assertions.assertThatDependencies; -@RunWith(DataProviderRunner.class) public class JavaClassTransitiveDependenciesTest { @SuppressWarnings("unused") @@ -37,17 +34,16 @@ static class D { } } - @DataProvider - public static Object[][] data_finds_transitive_dependencies_in_acyclic_graph() { - return DataProviders.testForEach( - (Function>) JavaClass::getTransitiveDependenciesFromSelf, + static Stream>> finds_transitive_dependencies_in_acyclic_graph() { + return Stream.of( + JavaClass::getTransitiveDependenciesFromSelf, GET_TRANSITIVE_DEPENDENCIES_FROM_SELF ); } - @Test - @UseDataProvider - public void test_finds_transitive_dependencies_in_acyclic_graph(Function> getTransitiveDependenciesFromSelf) { + @ParameterizedTest + @MethodSource + void finds_transitive_dependencies_in_acyclic_graph(Function> getTransitiveDependenciesFromSelf) { Class a = AcyclicGraph.A.class; Class b = AcyclicGraph.B.class; Class c = AcyclicGraph.C.class; diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaCodeUnitTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaCodeUnitTest.java index 6f19b21eb1..e01f158481 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaCodeUnitTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaCodeUnitTest.java @@ -6,15 +6,14 @@ import java.util.List; import java.util.Map; import java.util.Set; +import java.util.stream.Stream; import com.google.common.collect.ImmutableList; import com.tngtech.archunit.base.DescribedPredicate; import com.tngtech.archunit.core.importer.ClassFileImporter; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.Lists.newArrayList; import static com.google.common.collect.Sets.union; @@ -29,10 +28,8 @@ import static com.tngtech.archunit.testutil.Assertions.assertThat; import static com.tngtech.archunit.testutil.Assertions.assertThatAnnotation; import static com.tngtech.archunit.testutil.Assertions.assertThatTypes; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; import static org.assertj.core.api.Assertions.assertThatThrownBy; -@RunWith(DataProviderRunner.class) public class JavaCodeUnitTest { @Test @@ -85,10 +82,9 @@ public void offers_all_accesses_from_Self() { .build()); } - @DataProvider - public static Object[][] code_units_with_parameters() { + static Stream code_units_with_parameters() { JavaClass javaClass = new ClassFileImporter().importClass(ClassWithVariousCodeUnitParameters.class); - return testForEach( + return Stream.of( javaClass.getConstructor(Object.class, String.class), javaClass.getConstructor(List.class, Map.class), javaClass.getMethod("method", Object.class, String.class), @@ -96,9 +92,9 @@ public static Object[][] code_units_with_parameters() { ); } - @Test - @UseDataProvider("code_units_with_parameters") - public void creates_parameters(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource("code_units_with_parameters") + void creates_parameters(JavaCodeUnit codeUnit) { for (int i = 0; i < codeUnit.getParameters().size(); i++) { assertThat(codeUnit.getParameters().get(i).getRawType()).isEqualTo(codeUnit.getRawParameterTypes().get(i)); assertThat(codeUnit.getParameters().get(i).getType()).isEqualTo(codeUnit.getParameterTypes().get(i)); @@ -174,8 +170,7 @@ class LocalClassReferencingNonConstantFromOuterScope { } } - @DataProvider - public static Object[][] code_units_with_four_different_parameters() { + static Stream code_units_with_four_different_parameters() { @SuppressWarnings("unused") class SomeClass { SomeClass(List first, T second, String third, int fourth) { @@ -185,15 +180,15 @@ void method(List first, T second, String third, int fourth) { } } JavaClass javaClass = new ClassFileImporter().importClass(SomeClass.class); - return testForEach( + return Stream.of( javaClass.getConstructor(List.class, Object.class, String.class, int.class), javaClass.getMethod("method", List.class, Object.class, String.class, int.class) ); } - @Test - @UseDataProvider("code_units_with_four_different_parameters") - public void adds_description_to_parameters_of_code_unit(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource("code_units_with_four_different_parameters") + void adds_description_to_parameters_of_code_unit(JavaCodeUnit codeUnit) { List parameters = codeUnit.getParameters(); assertThat(parameters.get(0).getDescription()).isEqualTo("Parameter <" + List.class.getName() + "<" + String.class.getName() + ">> of " + startWithLowercase(codeUnit.getDescription())); @@ -202,9 +197,9 @@ public void adds_description_to_parameters_of_code_unit(JavaCodeUnit codeUnit) { assertThat(parameters.get(3).getDescription()).isEqualTo("Parameter <" + int.class.getName() + "> of " + startWithLowercase(codeUnit.getDescription())); } - @Test - @UseDataProvider("code_units_with_four_different_parameters") - public void adds_index_to_parameters_of_code_unit(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource("code_units_with_four_different_parameters") + void adds_index_to_parameters_of_code_unit(JavaCodeUnit codeUnit) { List parameters = codeUnit.getParameters(); assertThat(parameters.get(0).getIndex()).isEqualTo(0); @@ -213,8 +208,7 @@ public void adds_index_to_parameters_of_code_unit(JavaCodeUnit codeUnit) { assertThat(parameters.get(3).getIndex()).isEqualTo(3); } - @DataProvider - public static Object[][] data_adds_owner_to_parameters_of_code_unit() { + static Stream adds_owner_to_parameters_of_code_unit() { @SuppressWarnings("unused") class SomeClass { SomeClass(String param) { @@ -224,14 +218,14 @@ void method(String param) { } } JavaClass javaClass = new ClassFileImporter().importClass(SomeClass.class); - return testForEach( + return Stream.of( javaClass.getConstructor(String.class), javaClass.getMethod("method", String.class)); } - @Test - @UseDataProvider - public void test_adds_owner_to_parameters_of_code_unit(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void adds_owner_to_parameters_of_code_unit(JavaCodeUnit codeUnit) { for (JavaParameter parameter : codeUnit.getParameters()) { assertThat(parameter.getOwner()).isEqualTo(codeUnit); } diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaParameterizedTypeTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaParameterizedTypeTest.java index 05b77742a7..388d22e87f 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaParameterizedTypeTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaParameterizedTypeTest.java @@ -8,21 +8,17 @@ import java.util.stream.Stream; import com.tngtech.archunit.core.importer.ClassFileImporter; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class JavaParameterizedTypeTest { - @DataProvider @SuppressWarnings("unused") - public static Object[][] parameterized_types() { + static Stream parameterized_types() { class WithConcreteTypeName> { } class WithTypeVariable> { @@ -42,11 +38,11 @@ class WithWildcards, ? super Map testClass) { + private static Arguments createTestInput(Class testClass) { Type reflectionType = Arrays.stream(testClass.getTypeParameters()) .filter(v -> v.getName().equals("TEST")) .map(v -> v.getBounds()[0]) @@ -59,9 +55,9 @@ private static Object[] createTestInput(Class testClass) { return $(javaType, reflectionType); } - @Test - @UseDataProvider("parameterized_types") - public void name_of_parameterized_type_matches_Reflection_API(JavaType javaType, Type reflectionType) { + @ParameterizedTest + @MethodSource("parameterized_types") + void name_of_parameterized_type_matches_Reflection_API(JavaType javaType, Type reflectionType) { assertThat(javaType.getName()).isEqualTo(reflectionType.getTypeName()); } } diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/SourceTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/SourceTest.java index 909da10a8f..0542ed69f5 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/SourceTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/SourceTest.java @@ -11,32 +11,30 @@ import java.util.List; import java.util.Optional; import java.util.stream.IntStream; +import java.util.stream.Stream; import com.google.common.collect.ImmutableList; import com.google.common.collect.Lists; import com.google.common.io.ByteStreams; import com.tngtech.archunit.ArchConfiguration; import com.tngtech.archunit.core.domain.Source.Md5sum; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.After; import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.testutil.Assertions.assertThat; +import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.TestUtils.uriOf; import static com.tngtech.archunit.testutil.TestUtils.urlOf; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; import static java.nio.charset.StandardCharsets.UTF_8; import static java.util.stream.Collectors.toList; -@RunWith(DataProviderRunner.class) public class SourceTest { - @After - public void tearDown() { + @AfterEach + void tearDown() { ArchConfiguration.get().reset(); } @@ -49,42 +47,40 @@ public void source_file_name() { assertThat(source.getFileName()).as("source file name").isEmpty(); } - @DataProvider - public static List> expectedHexCodes() { - List> testCases = new ArrayList<>(); - testCases.add(ImmutableList.of(new byte[]{0}, "00")); - testCases.add(ImmutableList.of(new byte[]{15}, "0f")); - testCases.add(ImmutableList.of(new byte[]{16}, "10")); - testCases.add(ImmutableList.of(new byte[]{31}, "1f")); - testCases.add(ImmutableList.of(new byte[]{32}, "20")); - testCases.add(ImmutableList.of(new byte[]{(byte) 255}, "ff")); - testCases.add(ImmutableList.of(new byte[]{(byte) 128, 37, 45, 22, 99}, "80252d1663")); - return testCases; + static Stream expectedHexCodes() { + return Stream.of( + $(new byte[]{0}, "00"), + $(new byte[]{15}, "0f"), + $(new byte[]{16}, "10"), + $(new byte[]{31}, "1f"), + $(new byte[]{32}, "20"), + $(new byte[]{(byte) 255}, "ff"), + $(new byte[]{(byte) 128, 37, 45, 22, 99}, "80252d1663") + ); } - @Test - @UseDataProvider("expectedHexCodes") - public void toHex_works(byte[] input, String expectedHexString) { + @ParameterizedTest + @MethodSource("expectedHexCodes") + void toHex_works(byte[] input, String expectedHexString) { assertThat(Md5sum.toHex(input)).as("Bytes").isEqualTo(expectedHexString); } - @DataProvider - public static Object[][] classes() { - return $$($(fileUrl()), $(jarUrl())); + static Stream classes() { + return Stream.of(fileUrl(), jarUrl()); } - @Test - @UseDataProvider("classes") - public void calculates_md5_correctly(URL url) throws Exception { + @ParameterizedTest + @MethodSource("classes") + void calculates_md5_correctly(URL url) throws Exception { Source source = newSource(url); assertThat(source.getUri()).as("source URI").isEqualTo(url.toURI()); assertThat(source.getMd5sum().asBytes()).isEqualTo(expectedMd5BytesAt(url)); } - @Test - @UseDataProvider("classes") - public void equals_hashcode_and_toString(URL url) throws Exception { + @ParameterizedTest + @MethodSource("classes") + void equals_hashcode_and_toString(URL url) throws Exception { Source source = newSource(url); Source equalSource = newSource(url); @@ -95,23 +91,21 @@ public void equals_hashcode_and_toString(URL url) throws Exception { assertThat(source.toString()).as("source.toString()").isEqualTo(expectedToString); } - @DataProvider - public static Object[][] equalMd5Sums() { - return $$( + static Stream equalMd5Sums() { + return Stream.of( $(Md5sum.UNDETERMINED, Md5sum.UNDETERMINED), $(Md5sum.NOT_SUPPORTED, Md5sum.NOT_SUPPORTED), $(md5sumOf("anything"), md5sumOf("anything"))); } - @Test - @UseDataProvider("equalMd5Sums") - public void positive_equals_hashcode_of_md5sums(Md5sum first, Md5sum second) { + @ParameterizedTest + @MethodSource("equalMd5Sums") + void positive_equals_hashcode_of_md5sums(Md5sum first, Md5sum second) { assertThat(first).isEqualTo(second); assertThat(first.hashCode()).isEqualTo(second.hashCode()); } - @DataProvider - public static List> unequalMd5Sums() { + static List unequalMd5Sums() { return createUnequalTestCasesFor( Md5sum.UNDETERMINED, Md5sum.NOT_SUPPORTED, @@ -119,8 +113,8 @@ public static List> unequalMd5Sums() { md5sumOf("totallyDifferent")); } - private static List> createUnequalTestCasesFor(Md5sum... md5sums) { - List> result = new ArrayList<>(); + private static List createUnequalTestCasesFor(Md5sum... md5sums) { + List result = new ArrayList<>(); List input = ImmutableList.copyOf(md5sums); ArrayList shifting = Lists.newArrayList(md5sums); for (int i = 1; i < md5sums.length; i++) { @@ -130,15 +124,15 @@ private static List> createUnequalTestCasesFor(Md5sum... md5sums) { return result; } - private static List> zip(List first, List second) { + private static List zip(List first, List second) { return IntStream.range(0, first.size()) - .mapToObj(i -> ImmutableList.of(first.get(i), second.get(i))) + .mapToObj(i -> $(first.get(i), second.get(i))) .collect(toList()); } - @Test - @UseDataProvider("unequalMd5Sums") - public void negative_equals_of_md5sums(Md5sum first, Md5sum second) { + @ParameterizedTest + @MethodSource("unequalMd5Sums") + void negative_equals_of_md5sums(Md5sum first, Md5sum second) { assertThat(first).isNotEqualTo(second); } @@ -179,11 +173,11 @@ public static byte[] bytesAt(URL url) throws IOException { return ByteStreams.toByteArray(url.openStream()); } - private static Object fileUrl() { + private static URL fileUrl() { return urlOf(SourceTest.class); } - private static Object jarUrl() { + private static URL jarUrl() { return urlOf(Rule.class); } } diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/properties/HasThrowsClauseTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/properties/HasThrowsClauseTest.java index 58b758a1c9..00656b10c6 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/properties/HasThrowsClauseTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/properties/HasThrowsClauseTest.java @@ -1,14 +1,13 @@ package com.tngtech.archunit.core.domain.properties; import java.io.IOException; +import java.util.stream.Stream; import com.tngtech.archunit.base.DescribedPredicate; import com.tngtech.archunit.core.domain.ThrowsClause; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.base.DescribedPredicate.alwaysTrue; import static com.tngtech.archunit.core.domain.Formatters.formatNamesOf; @@ -16,9 +15,7 @@ import static com.tngtech.archunit.core.domain.TestUtils.throwsClause; import static com.tngtech.archunit.core.domain.properties.HasThrowsClause.Predicates.throwsClauseContainingType; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; -@RunWith(DataProviderRunner.class) public class HasThrowsClauseTest { @Test public void predicate_throwsClauseWithTypes_by_type() { @@ -44,18 +41,17 @@ public void predicate_throwsClauseWithTypes_by_type_name() { assertThat(HasThrowsClause.Predicates.throwsClauseWithTypes(Object.class.getName())).rejects(hasThrowsClause); } - @DataProvider - public static Object[][] containing_type_cases() { - return testForEach( + static Stream> containing_type_cases() { + return Stream.of( throwsClauseContainingType(FirstException.class), throwsClauseContainingType(FirstException.class.getName()), throwsClauseContainingType(equivalentTo(FirstException.class).as(FirstException.class.getName())) ); } - @Test - @UseDataProvider("containing_type_cases") - public void predicate_containing_type(DescribedPredicate> predicate) { + @ParameterizedTest + @MethodSource("containing_type_cases") + void predicate_containing_type(DescribedPredicate> predicate) { assertThat(predicate) .accepts(newHasThrowsClause(FirstException.class, SecondException.class)) .rejects(newHasThrowsClause(IOException.class, SecondException.class)) diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/properties/HasTypeTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/properties/HasTypeTest.java index 1375e6d3f5..d481121bd1 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/properties/HasTypeTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/properties/HasTypeTest.java @@ -1,34 +1,31 @@ package com.tngtech.archunit.core.domain.properties; +import java.util.stream.Stream; + import com.tngtech.archunit.base.DescribedPredicate; import com.tngtech.archunit.core.domain.JavaClass; import com.tngtech.archunit.core.domain.JavaType; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.core.domain.JavaClass.Predicates.equivalentTo; import static com.tngtech.archunit.core.domain.TestUtils.importClassWithContext; import static com.tngtech.archunit.core.domain.properties.HasType.Functions.GET_RAW_TYPE; import static com.tngtech.archunit.testutil.Assertions.assertThat; import static com.tngtech.archunit.testutil.Assertions.assertThatType; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; -@RunWith(DataProviderRunner.class) public class HasTypeTest { - @DataProvider - public static Object[][] type_predicates() { - return testForEach( + static Stream> type_predicates() { + return Stream.of( HasType.Predicates.rawType(String.class), HasType.Predicates.rawType(String.class.getName()), HasType.Predicates.rawType(equivalentTo(String.class))); } - @Test - @UseDataProvider("type_predicates") - public void predicate_type(DescribedPredicate predicate) { + @ParameterizedTest + @MethodSource("type_predicates") + void predicate_type(DescribedPredicate predicate) { HasType matchingField = newHasType(String.class); HasType nonmatchingField = newHasType(Object.class); diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAutomaticResolutionTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAutomaticResolutionTest.java index 197dbb7714..9e7c720d24 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAutomaticResolutionTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAutomaticResolutionTest.java @@ -11,8 +11,8 @@ import java.util.List; import java.util.Map; import java.util.function.Supplier; +import java.util.stream.Stream; -import com.google.common.collect.FluentIterable; import com.google.common.collect.ImmutableList; import com.tngtech.archunit.ArchConfiguration; import com.tngtech.archunit.core.domain.InstanceofCheck; @@ -44,11 +44,10 @@ import com.tngtech.archunit.core.importer.testexamples.annotationresolution.SomeAnnotationWithAnnotationParameter; import com.tngtech.archunit.core.importer.testexamples.annotationresolution.SomeAnnotationWithClassParameter; import com.tngtech.archunit.core.importer.testexamples.classhierarchyresolution.Child; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.core.importer.ClassFileImporterTestUtils.getMethodCallsFromClassWithoutAutomaticNullCheck; @@ -68,12 +67,9 @@ import static com.tngtech.archunit.testutil.Assertions.assertThat; import static com.tngtech.archunit.testutil.Assertions.assertThatAnnotation; import static com.tngtech.archunit.testutil.Assertions.assertThatType; +import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.assertion.JavaAnnotationAssertion.annotationProperty; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; -@RunWith(DataProviderRunner.class) public class ClassFileImporterAutomaticResolutionTest { @Test @@ -264,10 +260,9 @@ public void automatically_resolves_meta_annotation_types() { assertThatType(someMetaMetaMetaAnnotation.getType()).matches(SomeMetaMetaMetaAnnotationWithParameters.class); } - @DataProvider - public static Object[][] elementsAnnotatedWithSomeAnnotation() { + static Stream> elementsAnnotatedWithSomeAnnotation() { ImporterWithAdjustedResolutionRuns importer = ImporterWithAdjustedResolutionRuns.disableAllIterationsExcept(MAX_ITERATIONS_FOR_ANNOTATION_TYPES_PROPERTY_NAME); - return testForEach( + return Stream.of( importer.importClass(MetaAnnotatedClass.class), importer.importClass(ClassWithMetaAnnotatedField.class).getField("metaAnnotatedField"), importer.importClass(ClassWithMetaAnnotatedMethod.class).getMethod("metaAnnotatedMethod"), @@ -277,9 +272,9 @@ public static Object[][] elementsAnnotatedWithSomeAnnotation() { ); } - @Test - @UseDataProvider("elementsAnnotatedWithSomeAnnotation") - public void automatically_resolves_parameters_of_meta_annotations(HasAnnotations annotatedWithSomeAnnotation) { + @ParameterizedTest + @MethodSource("elementsAnnotatedWithSomeAnnotation") + void automatically_resolves_parameters_of_meta_annotations(HasAnnotations annotatedWithSomeAnnotation) { JavaAnnotation someAnnotation = annotatedWithSomeAnnotation .getAnnotationOfType(MetaAnnotatedAnnotation.class.getName()); JavaAnnotation metaAnnotationWithParameters = someAnnotation.getRawType() @@ -438,8 +433,7 @@ class SomeClass { assertThat(stubType).isFullyImported(false); } - @DataProvider - public static Object[][] data_automatically_resolves_annotation_parameter_types() { + static List automatically_resolves_annotation_parameter_types() { @SomeAnnotationWithClassParameter(String.class) @SomeAnnotationWithAnnotationParameter(@SomeAnnotationWithClassParameter(File.class)) @AnotherAnnotationWithAnnotationParameter(@SomeAnnotationWithAnnotationParameter(@SomeAnnotationWithClassParameter(Serializable.class))) @@ -476,16 +470,16 @@ class OnParameter { } ImporterWithAdjustedResolutionRuns importer = ImporterWithAdjustedResolutionRuns.disableAllIterationsExcept(MAX_ITERATIONS_FOR_ANNOTATION_TYPES_PROPERTY_NAME); - return FluentIterable.concat( - nestedAnnotationValueTestCases(importer.importClass(OnClass.class)), - nestedAnnotationValueTestCases(importer.importClass(OnField.class).getField("field")), - nestedAnnotationValueTestCases(importer.importClass(OnMethod.class).getMethod("method")), - nestedAnnotationValueTestCases(getOnlyElement(importer.importClass(OnConstructor.class).getConstructors())), - nestedAnnotationValueTestCases(getOnlyElement(importer.importClass(OnParameter.class).getConstructors()).getParameters().get(0)) - ).toArray(Object[].class); + return ImmutableList.builder() + .addAll(nestedAnnotationValueTestCases(importer.importClass(OnClass.class))) + .addAll(nestedAnnotationValueTestCases(importer.importClass(OnField.class).getField("field"))) + .addAll(nestedAnnotationValueTestCases(importer.importClass(OnMethod.class).getMethod("method"))) + .addAll(nestedAnnotationValueTestCases(getOnlyElement(importer.importClass(OnConstructor.class).getConstructors()))) + .addAll(nestedAnnotationValueTestCases(getOnlyElement(importer.importClass(OnParameter.class).getConstructors()).getParameters().get(0))) + .build(); } - private static Iterable nestedAnnotationValueTestCases(HasAnnotations hasAnnotations) { + private static List nestedAnnotationValueTestCases(HasAnnotations hasAnnotations) { return ImmutableList.of( $(getNestedAnnotationClassValue(hasAnnotations, SomeAnnotationWithClassParameter.class), expect(String.class)), $(getNestedAnnotationClassValue(hasAnnotations, SomeAnnotationWithAnnotationParameter.class), expect(File.class)), @@ -506,9 +500,9 @@ private static Class expect(Class clazz) { return clazz; } - @Test - @UseDataProvider - public void test_automatically_resolves_annotation_parameter_types(JavaClass annotationValue, Class expectedType) { + @ParameterizedTest + @MethodSource + void automatically_resolves_annotation_parameter_types(JavaClass annotationValue, Class expectedType) { assertThat(annotationValue).isFullyImported(true); assertThatType(annotationValue).matches(expectedType); } @@ -621,8 +615,7 @@ class Innermost { assertThatType(outermost).matches(Outermost.class); } - @DataProvider - public static Object[][] data_automatically_resolves_generic_type_parameter_bounds() { + static Stream automatically_resolves_generic_type_parameter_bounds() { @SuppressWarnings("unused") class TypeParameterOnClassWithClassBound { } @@ -668,7 +661,7 @@ class TypeArgumentWithInterfaceBoundOnConstructor { } } - return $$( + return Stream.of( $(importFirstTypeParameterClassBound(TypeParameterOnClassWithClassBound.class), String.class), $(importFirstTypeParameterClassBound(TypeParameterOnClassWithInterfaceBound.class), Serializable.class), $(importFirstTypeParameterMethodBound(TypeParameterOnMethodWithClassBound.class), String.class), @@ -682,15 +675,14 @@ class TypeArgumentWithInterfaceBoundOnConstructor { ); } - @Test - @UseDataProvider - public void test_automatically_resolves_generic_type_parameter_bounds(JavaClass bound, Class expectedType) { + @ParameterizedTest + @MethodSource + void automatically_resolves_generic_type_parameter_bounds(JavaClass bound, Class expectedType) { assertThat(bound).isFullyImported(true); assertThatType(bound).matches(expectedType); } - @DataProvider - public static Object[][] data_automatically_resolves_parameterized_generic_type_bounds() { + static Stream automatically_resolves_parameterized_generic_type_bounds() { @SuppressWarnings("unused") class InterfaceTypeParameterBoundsOnClass>> { } @@ -736,7 +728,7 @@ class ClassTypeArgumentBoundsOnConstructor { } } - return $$( + return Stream.of( $(importFirstTypeParameterClassBound(InterfaceTypeParameterBoundsOnClass.class), List.class, Map.class, Serializable.class), $(importFirstTypeParameterClassBound(ClassTypeParameterBoundsOnClass.class), ArrayList.class, HashMap.class, String.class), $(importFirstTypeParameterMethodBound(InterfaceTypeParameterBoundsOnMethod.class), List.class, Map.class, Serializable.class), @@ -750,9 +742,9 @@ class ClassTypeArgumentBoundsOnConstructor { ); } - @Test - @UseDataProvider - public void test_automatically_resolves_parameterized_generic_type_bounds( + @ParameterizedTest + @MethodSource + void automatically_resolves_parameterized_generic_type_bounds( JavaParameterizedType actual1stLevel, Class expected1stLevel, Class expected2ndLevel, Class expected3rdLevel ) { diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterCodeUnitReferencesTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterCodeUnitReferencesTest.java index 2f00bede78..a460d5b220 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterCodeUnitReferencesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterCodeUnitReferencesTest.java @@ -2,6 +2,7 @@ import java.util.function.Consumer; import java.util.function.Supplier; +import java.util.stream.Stream; import com.tngtech.archunit.core.domain.JavaClass; import com.tngtech.archunit.core.domain.JavaClasses; @@ -11,19 +12,16 @@ import com.tngtech.archunit.core.domain.JavaMethodReference; import com.tngtech.archunit.core.importer.testexamples.codeunitreferences.Origin; import com.tngtech.archunit.core.importer.testexamples.codeunitreferences.Target; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.testutil.Assertions.assertThatAccess; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class ClassFileImporterCodeUnitReferencesTest { @SuppressWarnings({"unused", "InnerClassMayBeStatic"}) @@ -51,9 +49,8 @@ void accessesStaticMethodReference() { } } - @DataProvider - public static Object[][] data_imports_static_method_references() { - return $$( + static Stream imports_static_method_references() { + return Stream.of( $( Data_imports_static_method_references.OriginReferencingInterface.class, Data_imports_static_method_references.ReferencedInterfaceTarget.class @@ -64,9 +61,9 @@ public static Object[][] data_imports_static_method_references() { )); } - @Test - @UseDataProvider - public void test_imports_static_method_references(Class originClassInput, Class targetClassInput) { + @ParameterizedTest + @MethodSource + void imports_static_method_references(Class originClassInput, Class targetClassInput) { JavaClasses javaClasses = new ClassFileImporter().importClasses(originClassInput, targetClassInput); JavaClass originClass = javaClasses.get(originClassInput); JavaClass targetClass = javaClasses.get(targetClassInput); @@ -108,9 +105,8 @@ void referencesInstanceMethodBoundToInstance() { } } - @DataProvider - public static Object[][] data_imports_instance_method_references_bound_to_instance() { - return $$( + static Stream imports_instance_method_references_bound_to_instance() { + return Stream.of( $( Data_imports_instance_method_references_bound_to_instance.OriginReferencingInterface.class, Data_imports_instance_method_references_bound_to_instance.ReferencedInterfaceTarget.class @@ -121,9 +117,9 @@ public static Object[][] data_imports_instance_method_references_bound_to_instan )); } - @Test - @UseDataProvider - public void test_imports_instance_method_references_bound_to_instance(Class originClassInput, Class targetClassInput) { + @ParameterizedTest + @MethodSource + void imports_instance_method_references_bound_to_instance(Class originClassInput, Class targetClassInput) { JavaClasses javaClasses = new ClassFileImporter().importClasses(originClassInput, targetClassInput); JavaClass originClass = javaClasses.get(originClassInput); JavaClass targetClass = javaClasses.get(targetClassInput); @@ -161,9 +157,8 @@ void referencesInstanceMethodNotBoundToInstance() { } } - @DataProvider - public static Object[][] data_imports_instance_method_references_not_bound_to_instance() { - return $$( + static Stream imports_instance_method_references_not_bound_to_instance() { + return Stream.of( $( Data_imports_instance_method_references_not_bound_to_instance.OriginReferencingInterface.class, Data_imports_instance_method_references_not_bound_to_instance.ReferencedInterfaceTarget.class @@ -174,9 +169,9 @@ public static Object[][] data_imports_instance_method_references_not_bound_to_in )); } - @Test - @UseDataProvider - public void test_imports_instance_method_references_not_bound_to_instance(Class originClassInput, Class targetClassInput) { + @ParameterizedTest + @MethodSource + void imports_instance_method_references_not_bound_to_instance(Class originClassInput, Class targetClassInput) { JavaClasses javaClasses = new ClassFileImporter().importClasses(originClassInput, targetClassInput); JavaClass originClass = javaClasses.get(originClassInput); JavaClass targetClass = javaClasses.get(targetClassInput); diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericClassesTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericClassesTest.java index f0c6310b2a..2ccadf1b36 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericClassesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericClassesTest.java @@ -8,20 +8,21 @@ import java.util.Map; import java.util.Set; import java.util.function.Function; +import java.util.stream.Stream; import com.tngtech.archunit.ArchConfiguration; import com.tngtech.archunit.core.domain.JavaClass; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.core.importer.DependencyResolutionProcessTestUtils.importClassWithOnlyGenericTypeResolution; import static com.tngtech.archunit.core.importer.DependencyResolutionProcessTestUtils.importClassesWithOnlyGenericTypeResolution; import static com.tngtech.archunit.testutil.ArchConfigurationRule.resetConfigurationAround; import static com.tngtech.archunit.testutil.Assertions.assertThat; import static com.tngtech.archunit.testutil.Assertions.assertThatType; +import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteClass.concreteClass; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteGenericArray.genericArray; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteGenericArray.parameterizedTypeArrayName; @@ -29,10 +30,7 @@ import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteParameterizedType.parameterizedType; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteTypeVariable.typeVariable; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteWildcardType.wildcardType; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; -@RunWith(DataProviderRunner.class) public class ClassFileImporterGenericClassesTest { @Test @@ -215,8 +213,7 @@ class ClassWithSingleTypeParameterBoundByTypeWithUnboundWildcard imports_single_type_bound_with_upper_bound_wildcard() { @SuppressWarnings("unused") class ClassWithSingleTypeParameterBoundByTypeWithWildcardWithUpperClassBound> { } @@ -224,23 +221,22 @@ class ClassWithSingleTypeParameterBoundByTypeWithWildcardWithUpperClassBound> { } - return $$( + return Stream.of( $(ClassWithSingleTypeParameterBoundByTypeWithWildcardWithUpperClassBound.class, String.class), $(ClassWithSingleTypeParameterBoundByTypeWithWildcardWithUpperInterfaceBound.class, Serializable.class) ); } - @Test - @UseDataProvider - public void test_imports_single_type_bound_with_upper_bound_wildcard(Class classWithWildcard, Class expectedUpperBound) { + @ParameterizedTest + @MethodSource + void imports_single_type_bound_with_upper_bound_wildcard(Class classWithWildcard, Class expectedUpperBound) { JavaClass javaClass = importClassWithOnlyGenericTypeResolution(classWithWildcard); assertThatType(javaClass) .hasTypeParameter("T").withBoundsMatching(parameterizedType(List.class).withWildcardTypeParameterWithUpperBound(expectedUpperBound)); } - @DataProvider - public static Object[][] data_imports_single_type_bound_with_lower_bound_wildcard() { + static Stream imports_single_type_bound_with_lower_bound_wildcard() { @SuppressWarnings("unused") class ClassWithSingleTypeParameterBoundByTypeWithWildcardWithLowerClassBound> { } @@ -248,15 +244,15 @@ class ClassWithSingleTypeParameterBoundByTypeWithWildcardWithLowerClassBound> { } - return $$( + return Stream.of( $(ClassWithSingleTypeParameterBoundByTypeWithWildcardWithLowerClassBound.class, String.class), $(ClassWithSingleTypeParameterBoundByTypeWithWildcardWithLowerInterfaceBound.class, Serializable.class) ); } - @Test - @UseDataProvider - public void test_imports_single_type_bound_with_lower_bound_wildcard(Class classWithWildcard, Class expectedLowerBound) { + @ParameterizedTest + @MethodSource + void imports_single_type_bound_with_lower_bound_wildcard(Class classWithWildcard, Class expectedLowerBound) { JavaClass javaClass = importClassWithOnlyGenericTypeResolution(classWithWildcard); assertThatType(javaClass) diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericCodeUnitParameterTypesTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericCodeUnitParameterTypesTest.java index 139257b128..693c09e0b7 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericCodeUnitParameterTypesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericCodeUnitParameterTypesTest.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; import java.util.Set; +import java.util.stream.Stream; import com.google.common.collect.FluentIterable; import com.tngtech.archunit.ArchConfiguration; @@ -14,11 +15,10 @@ import com.tngtech.archunit.core.domain.JavaConstructor; import com.tngtech.archunit.core.domain.JavaType; import com.tngtech.archunit.core.domain.JavaTypeVariable; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.core.importer.DependencyResolutionProcessTestUtils.importClassesWithOnlyGenericTypeResolution; @@ -26,6 +26,7 @@ import static com.tngtech.archunit.testutil.Assertions.assertThat; import static com.tngtech.archunit.testutil.Assertions.assertThatType; import static com.tngtech.archunit.testutil.Assertions.assertThatTypes; +import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteClass.concreteClass; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteGenericArray.genericArray; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteGenericArray.parameterizedTypeArrayName; @@ -33,15 +34,11 @@ import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteParameterizedType.parameterizedType; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteTypeVariable.typeVariable; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteWildcardType.wildcardType; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; +import static java.util.stream.Collectors.toList; -@RunWith(DataProviderRunner.class) public class ClassFileImporterGenericCodeUnitParameterTypesTest { - @DataProvider - public static Object[][] data_imports_non_generic_code_unit_parameter_type() { + static Stream imports_non_generic_code_unit_parameter_type() { class NonGenericParameterType { } @SuppressWarnings("unused") @@ -54,26 +51,25 @@ class NoGenericSignatureOnMethod { void method(NonGenericParameterType param) { } } - Object[][] testCases = testCasesFromSameGenericSignatureOnConstructorAndMethod( + List testCases = testCasesFromSameGenericSignatureOnConstructorAndMethod( NoGenericSignatureOnConstructor.class, NoGenericSignatureOnMethod.class - ); - return $$( - $(testCases[0][0], NonGenericParameterType.class), - $(testCases[1][0], NonGenericParameterType.class) + ).collect(toList()); + return Stream.of( + $(testCases.get(0), NonGenericParameterType.class), + $(testCases.get(1), NonGenericParameterType.class) ); } - @Test - @UseDataProvider - public void test_imports_non_generic_code_unit_parameter_type(JavaCodeUnit codeUnit, Class expectedParameterType) { + @ParameterizedTest + @MethodSource + void imports_non_generic_code_unit_parameter_type(JavaCodeUnit codeUnit, Class expectedParameterType) { JavaType parameterType = codeUnit.getParameterTypes().get(0); assertThatType(parameterType).as("parameter type").matches(expectedParameterType); } - @DataProvider - public static Object[][] data_imports_non_generic_code_unit_parameter_type_when_signature_is_generic() { + static Stream imports_non_generic_code_unit_parameter_type_when_signature_is_generic() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(Object object, int primitive, Object[] objectArray, int[] primitiveArray) { @@ -89,17 +85,16 @@ abstract class GenericSignatureOnMethod { ); } - @Test - @UseDataProvider - public void test_imports_non_generic_code_unit_parameter_type_when_signature_is_generic(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_non_generic_code_unit_parameter_type_when_signature_is_generic(JavaCodeUnit codeUnit) { assertThatType(codeUnit.getParameterTypes().get(0)).as("parameter type").matches(Object.class); assertThatType(codeUnit.getParameterTypes().get(1)).as("parameter type").matches(int.class); assertThatType(codeUnit.getParameterTypes().get(2)).as("parameter type").matches(Object[].class); assertThatType(codeUnit.getParameterTypes().get(3)).as("parameter type").matches(int[].class); } - @DataProvider - public static Object[][] data_imports_generic_code_unit_parameter_type_with_one_type_argument() { + static Stream imports_generic_code_unit_parameter_type_with_one_type_argument() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithSingleTypeParameter param) { @@ -116,9 +111,9 @@ void method(ClassParameterWithSingleTypeParameter param) { ); } - @Test - @UseDataProvider - public void test_imports_generic_code_unit_parameter_type_with_one_type_argument(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_generic_code_unit_parameter_type_with_one_type_argument(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).as("generic parameter type") @@ -145,8 +140,7 @@ public LocalClassThatWillHaveEnclosingClassAsFirstRawConstructorParameter(ClassP parameterizedType(ClassParameterWithSingleTypeParameter.class).withTypeArguments(String.class)); } - @DataProvider - public static Object[][] data_imports_raw_generic_code_unit_parameter_type_as_JavaClass_instead_of_JavaParameterizedType() { + static Stream imports_raw_generic_code_unit_parameter_type_as_JavaClass_instead_of_JavaParameterizedType() { @SuppressWarnings({"unused", "rawtypes"}) class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithSingleTypeParameter param) { @@ -164,16 +158,15 @@ void method(ClassParameterWithSingleTypeParameter param) { ); } - @Test - @UseDataProvider - public void test_imports_raw_generic_code_unit_parameter_type_as_JavaClass_instead_of_JavaParameterizedType(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_raw_generic_code_unit_parameter_type_as_JavaClass_instead_of_JavaParameterizedType(JavaCodeUnit codeUnit) { JavaType rawGenericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(rawGenericParameterType).as("raw generic parameter type").matches(ClassParameterWithSingleTypeParameter.class); } - @DataProvider - public static Object[][] data_imports_generic_code_unit_parameter_type_with_array_type_argument() { + static Stream imports_generic_code_unit_parameter_type_with_array_type_argument() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithSingleTypeParameter param) { @@ -191,9 +184,9 @@ void method(ClassParameterWithSingleTypeParameter param) { ); } - @Test - @UseDataProvider - public void test_imports_generic_code_unit_parameter_type_with_array_type_argument(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_generic_code_unit_parameter_type_with_array_type_argument(JavaCodeUnit codeUnit) { JavaType genericMethodParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericMethodParameterType).as("generic parameter type") @@ -201,8 +194,7 @@ public void test_imports_generic_code_unit_parameter_type_with_array_type_argume .hasActualTypeArguments(String[].class); } - @DataProvider - public static Object[][] data_imports_generic_code_unit_parameter_type_with_primitive_array_type_argument() { + static Stream imports_generic_code_unit_parameter_type_with_primitive_array_type_argument() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithSingleTypeParameter param) { @@ -220,9 +212,9 @@ void method(ClassParameterWithSingleTypeParameter param) { ); } - @Test - @UseDataProvider - public void test_imports_generic_code_unit_parameter_type_with_primitive_array_type_argument(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_generic_code_unit_parameter_type_with_primitive_array_type_argument(JavaCodeUnit codeUnit) { JavaType genericMethodParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericMethodParameterType).as("generic parameter type") @@ -230,8 +222,7 @@ public void test_imports_generic_code_unit_parameter_type_with_primitive_array_t .hasActualTypeArguments(int[].class); } - @DataProvider - public static Object[][] data_imports_generic_code_unit_parameter_type_with_multiple_type_arguments() { + static Stream imports_generic_code_unit_parameter_type_with_multiple_type_arguments() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithThreeTypeParameters param) { @@ -249,9 +240,9 @@ void method(ClassParameterWithThreeTypeParameters pa ); } - @Test - @UseDataProvider - public void test_imports_generic_code_unit_parameter_type_with_multiple_type_arguments(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_generic_code_unit_parameter_type_with_multiple_type_arguments(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).as("generic parameter type") @@ -259,8 +250,7 @@ public void test_imports_generic_code_unit_parameter_type_with_multiple_type_arg .hasActualTypeArguments(String.class, Serializable.class, File.class); } - @DataProvider - public static Object[][] data_imports_generic_code_unit_parameter_type_with_single_actual_type_argument_parameterized_with_concrete_class() { + static Stream imports_generic_code_unit_parameter_type_with_single_actual_type_argument_parameterized_with_concrete_class() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithSingleTypeParameter> param) { @@ -278,9 +268,9 @@ void method(ClassParameterWithSingleTypeParameter imports_generic_code_unit_parameter_type_with_multiple_actual_type_arguments_parameterized_with_concrete_classes() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithThreeTypeParameters< @@ -314,9 +303,9 @@ void method(ClassParameterWithThreeTypeParameters< ); } - @Test - @UseDataProvider - public void test_imports_generic_code_unit_parameter_type_with_multiple_actual_type_arguments_parameterized_with_concrete_classes(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_generic_code_unit_parameter_type_with_multiple_actual_type_arguments_parameterized_with_concrete_classes(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).as("generic parameter type").hasActualTypeArguments( @@ -329,8 +318,7 @@ public void test_imports_generic_code_unit_parameter_type_with_multiple_actual_t ); } - @DataProvider - public static Object[][] data_imports_generic_code_unit_parameter_type_with_single_unbound_wildcard() { + static Stream imports_generic_code_unit_parameter_type_with_single_unbound_wildcard() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithSingleTypeParameter param) { @@ -348,16 +336,15 @@ void method(ClassParameterWithSingleTypeParameter param) { ); } - @Test - @UseDataProvider - public void test_imports_generic_code_unit_parameter_type_with_single_unbound_wildcard(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_generic_code_unit_parameter_type_with_single_unbound_wildcard(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).as("generic parameter type").hasActualTypeArguments(wildcardType()); } - @DataProvider - public static Object[][] data_imports_generic_code_unit_parameter_type_with_single_actual_type_argument_parameterized_with_unbound_wildcard() { + static Stream imports_generic_code_unit_parameter_type_with_single_actual_type_argument_parameterized_with_unbound_wildcard() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithSingleTypeParameter> param) { @@ -375,9 +362,9 @@ void method(ClassParameterWithSingleTypeParameter imports_generic_code_unit_parameter_type_with_actual_type_arguments_parameterized_with_bounded_wildcards() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithTwoTypeParameters< @@ -409,9 +395,9 @@ void method(ClassParameterWithTwoTypeParameters< ); } - @Test - @UseDataProvider - public void test_imports_generic_code_unit_parameter_type_with_actual_type_arguments_parameterized_with_bounded_wildcards(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_generic_code_unit_parameter_type_with_actual_type_arguments_parameterized_with_bounded_wildcards(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).as("generic parameter type").hasActualTypeArguments( @@ -422,8 +408,7 @@ public void test_imports_generic_code_unit_parameter_type_with_actual_type_argum ); } - @DataProvider - public static Object[][] data_imports_generic_code_unit_parameter_type_with_actual_type_arguments_with_multiple_wildcards_with_various_bounds() { + static Stream imports_generic_code_unit_parameter_type_with_actual_type_arguments_with_multiple_wildcards_with_various_bounds() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithTwoTypeParameters< @@ -445,9 +430,9 @@ void method(ClassParameterWithTwoTypeParameters< ); } - @Test - @UseDataProvider - public void test_imports_generic_code_unit_parameter_type_with_actual_type_arguments_with_multiple_wildcards_with_various_bounds(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_generic_code_unit_parameter_type_with_actual_type_arguments_with_multiple_wildcards_with_various_bounds(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).as("generic parameter type").hasActualTypeArguments( @@ -462,8 +447,7 @@ public void test_imports_generic_code_unit_parameter_type_with_actual_type_argum ); } - @DataProvider - public static Object[][] data_imports_type_variable_as_generic_code_unit_parameter_type() { + static Stream imports_type_variable_as_generic_code_unit_parameter_type() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(T param) { @@ -481,9 +465,9 @@ void method(T param) { ); } - @Test - @UseDataProvider - public void test_imports_type_variable_as_generic_code_unit_parameter_type(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_type_variable_as_generic_code_unit_parameter_type(JavaCodeUnit codeUnit) { JavaType genericMethodParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericMethodParameterType).as("generic parameter type") @@ -491,8 +475,7 @@ public void test_imports_type_variable_as_generic_code_unit_parameter_type(JavaC .hasErasure(String.class); } - @DataProvider - public static Object[][] data_imports_generic_code_unit_parameter_type_parameterized_with_type_variable() { + static Stream imports_generic_code_unit_parameter_type_parameterized_with_type_variable() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithSingleTypeParameter param) { @@ -510,16 +493,15 @@ void method(ClassParameterWithSingleTypeParameter param) { ); } - @Test - @UseDataProvider - public void test_imports_generic_code_unit_parameter_type_parameterized_with_type_variable(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_generic_code_unit_parameter_type_parameterized_with_type_variable(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).as("generic parameter type").hasActualTypeArguments(typeVariable("OF_CLASS")); } - @DataProvider - public static Object[][] data_imports_generic_code_unit_parameter_type_with_actual_type_argument_parameterized_with_type_variable() { + static Stream imports_generic_code_unit_parameter_type_with_actual_type_argument_parameterized_with_type_variable() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithSingleTypeParameter> param) { @@ -537,9 +519,9 @@ void method(ClassParameterWithSingleTypeParameter references_type_variable_assigned_to_actual_type_argument_of_generic_code_unit_parameter_type() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithSingleTypeParameter> param) { @@ -567,9 +548,9 @@ void method(ClassParameterWithSingleTypeParameter references_outer_type_variable_assigned_to_actual_type_argument_of_generic_code_unit_parameter_type_of_inner_class() { @SuppressWarnings("unused") class OuterWithTypeParameter { class SomeInner { @@ -603,9 +583,9 @@ void method(ClassParameterWithSingleTypeParameter param) { ); } - @Test - @UseDataProvider - public void test_references_outer_type_variable_assigned_to_actual_type_argument_of_generic_code_unit_parameter_type_of_inner_class(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void references_outer_type_variable_assigned_to_actual_type_argument_of_generic_code_unit_parameter_type_of_inner_class(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).as("generic parameter type").hasActualTypeArguments( @@ -613,8 +593,7 @@ public void test_references_outer_type_variable_assigned_to_actual_type_argument ); } - @DataProvider - public static Object[][] data_creates_new_stub_type_variables_for_type_variables_of_enclosing_classes_that_are_out_of_context_for_generic_code_unit_parameter_type_of_inner_class() { + static Stream creates_new_stub_type_variables_for_type_variables_of_enclosing_classes_that_are_out_of_context_for_generic_code_unit_parameter_type_of_inner_class() { @SuppressWarnings("unused") class OuterWithTypeParameter { class SomeInner { @@ -637,15 +616,15 @@ void method(ClassParameterWithSingleTypeParameter param) { OuterWithTypeParameter.SomeInner.GenericSignatureOnMethod.class); }); - return testForEach( + return Stream.of( getOnlyElement(classes.get(OuterWithTypeParameter.SomeInner.GenericSignatureOnConstructor.class).getConstructors()), getOnlyElement(classes.get(OuterWithTypeParameter.SomeInner.GenericSignatureOnMethod.class).getMethods()) ); } - @Test - @UseDataProvider - public void test_creates_new_stub_type_variables_for_type_variables_of_enclosing_classes_that_are_out_of_context_for_generic_code_unit_parameter_type_of_inner_class(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void creates_new_stub_type_variables_for_type_variables_of_enclosing_classes_that_are_out_of_context_for_generic_code_unit_parameter_type_of_inner_class(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).as("generic parameter type").hasActualTypeArguments( @@ -653,8 +632,7 @@ public void test_creates_new_stub_type_variables_for_type_variables_of_enclosing ); } - @DataProvider - public static Object[][] data_considers_hierarchy_of_methods_and_classes_for_type_parameter_context() throws ClassNotFoundException { + static Stream considers_hierarchy_of_methods_and_classes_for_type_parameter_context() throws ClassNotFoundException { @SuppressWarnings("unused") class Level1 { void level2() { @@ -676,9 +654,9 @@ void method(T4 param) { ); } - @Test - @UseDataProvider - public void test_considers_hierarchy_of_methods_and_classes_for_type_parameter_context(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void considers_hierarchy_of_methods_and_classes_for_type_parameter_context(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).as("generic parameter type") @@ -689,8 +667,7 @@ public void test_considers_hierarchy_of_methods_and_classes_for_type_parameter_c typeVariable("T1").withUpperBounds(String.class))))); } - @DataProvider - public static Object[][] data_imports_wildcards_of_generic_code_unit_parameter_type_bound_by_type_variables() { + static Stream imports_wildcards_of_generic_code_unit_parameter_type_bound_by_type_variables() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithTwoTypeParameters< @@ -712,9 +689,9 @@ void method(ClassParameterWithTwoTypeParameters< ); } - @Test - @UseDataProvider - public void test_imports_wildcards_of_generic_code_unit_parameter_type_bound_by_type_variables(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_wildcards_of_generic_code_unit_parameter_type_bound_by_type_variables(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).as("generic parameter type").hasActualTypeArguments( @@ -727,8 +704,7 @@ public void test_imports_wildcards_of_generic_code_unit_parameter_type_bound_by_ ); } - @DataProvider - public static Object[][] data_imports_wildcards_of_generic_code_unit_parameter_type_bound_by_type_variables_of_enclosing_classes() { + static Stream imports_wildcards_of_generic_code_unit_parameter_type_bound_by_type_variables_of_enclosing_classes() { @SuppressWarnings("unused") class OuterWithTypeParameter { class SomeInner { @@ -756,9 +732,9 @@ void method(ClassParameterWithTwoTypeParameters< ); } - @Test - @UseDataProvider - public void test_imports_wildcards_of_generic_code_unit_parameter_type_bound_by_type_variables_of_enclosing_classes(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_wildcards_of_generic_code_unit_parameter_type_bound_by_type_variables_of_enclosing_classes(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).as("generic parameter type").hasActualTypeArguments( @@ -771,8 +747,7 @@ public void test_imports_wildcards_of_generic_code_unit_parameter_type_bound_by_ ); } - @DataProvider - public static Object[][] data_creates_new_stub_type_variables_for_wildcards_bound_by_type_variables_of_enclosing_classes_that_are_out_of_context() { + static Stream creates_new_stub_type_variables_for_wildcards_bound_by_type_variables_of_enclosing_classes_that_are_out_of_context() { @SuppressWarnings("unused") class OuterWithTypeParameter { class SomeInner { @@ -800,15 +775,15 @@ void method(ClassParameterWithTwoTypeParameters< ClassParameterWithSingleTypeParameter.class); }); - return testForEach( + return Stream.of( getOnlyElement(classes.get(OuterWithTypeParameter.SomeInner.GenericSignatureOnConstructor.class).getConstructors()), getOnlyElement(classes.get(OuterWithTypeParameter.SomeInner.GenericSignatureOnMethod.class).getMethods()) ); } - @Test - @UseDataProvider - public void test_creates_new_stub_type_variables_for_wildcards_bound_by_type_variables_of_enclosing_classes_that_are_out_of_context(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void creates_new_stub_type_variables_for_wildcards_bound_by_type_variables_of_enclosing_classes_that_are_out_of_context(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).as("generic parameter type").hasActualTypeArguments( @@ -821,8 +796,7 @@ public void test_creates_new_stub_type_variables_for_wildcards_bound_by_type_var ); } - @DataProvider - public static Object[][] data_imports_complex_generic_code_unit_parameter_type_with_multiple_nested_actual_type_arguments_with_self_referencing_type_definitions() { + static Stream imports_complex_generic_code_unit_parameter_type_with_multiple_nested_actual_type_arguments_with_self_referencing_type_definitions() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithThreeTypeParameters< @@ -858,9 +832,9 @@ void method(ClassParameterWithThreeTypeParameters< ); } - @Test - @UseDataProvider - public void test_imports_complex_generic_code_unit_parameter_type_with_multiple_nested_actual_type_arguments_with_self_referencing_type_definitions(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_complex_generic_code_unit_parameter_type_with_multiple_nested_actual_type_arguments_with_self_referencing_type_definitions(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); // @formatter:off @@ -898,8 +872,7 @@ public void test_imports_complex_generic_code_unit_parameter_type_with_multiple_ // @formatter:on } - @DataProvider - public static Object[][] data_imports_complex_generic_array_code_unit_parameter_type() { + static Stream imports_complex_generic_array_code_unit_parameter_type() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(List, Serializable>>>[] param) { @@ -917,9 +890,9 @@ void method(List, Serializable>>> ); } - @Test - @UseDataProvider - public void test_imports_complex_generic_array_code_unit_parameter_type(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_complex_generic_array_code_unit_parameter_type(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).matches( @@ -938,8 +911,7 @@ public void test_imports_complex_generic_array_code_unit_parameter_type(JavaCode concreteClass(Serializable.class)))))); } - @DataProvider - public static Object[][] data_imports_complex_generic_code_unit_parameter_type_with_multiple_nested_actual_type_arguments_with_concrete_array_bounds() { + static Stream imports_complex_generic_code_unit_parameter_type_with_multiple_nested_actual_type_arguments_with_concrete_array_bounds() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithThreeTypeParameters< @@ -963,9 +935,9 @@ void method(ClassParameterWithThreeTypeParameters< ); } - @Test - @UseDataProvider - public void test_imports_complex_generic_code_unit_parameter_type_with_multiple_nested_actual_type_arguments_with_concrete_array_bounds(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_complex_generic_code_unit_parameter_type_with_multiple_nested_actual_type_arguments_with_concrete_array_bounds(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).hasActualTypeArguments( @@ -980,8 +952,7 @@ public void test_imports_complex_generic_code_unit_parameter_type_with_multiple_ concreteClass(Serializable[][].class)))); } - @DataProvider - public static Object[][] data_imports_generic_code_unit_parameter_type_with_parameterized_array_bounds() { + static Stream imports_generic_code_unit_parameter_type_with_parameterized_array_bounds() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithThreeTypeParameters[], List[][], List[][][]> param) { @@ -999,9 +970,9 @@ void method(ClassParameterWithThreeTypeParameters[], List ); } - @Test - @UseDataProvider - public void test_imports_generic_code_unit_parameter_type_with_parameterized_array_bounds(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_generic_code_unit_parameter_type_with_parameterized_array_bounds(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).hasActualTypeArguments( @@ -1016,8 +987,7 @@ public void test_imports_generic_code_unit_parameter_type_with_parameterized_arr parameterizedType(List.class).withTypeArguments(String[][].class))))); } - @DataProvider - public static Object[][] data_imports_generic_array_code_unit_parameter_type() { + static Stream imports_generic_array_code_unit_parameter_type() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(X[] first, Y[][] second) { @@ -1035,9 +1005,9 @@ void method(X[] first, Y[][] second) { ); } - @Test - @UseDataProvider - public void test_imports_generic_array_code_unit_parameter_type(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_generic_array_code_unit_parameter_type(JavaCodeUnit codeUnit) { assertThatType(codeUnit.getParameterTypes().get(0)).matches( genericArray(typeVariableArrayName("X", 1)).withComponentType( typeVariable("X").withUpperBounds(Serializable.class))); @@ -1047,8 +1017,7 @@ public void test_imports_generic_array_code_unit_parameter_type(JavaCodeUnit cod typeVariable("Y").withUpperBounds(String.class)))); } - @DataProvider - public static Object[][] data_imports_complex_generic_code_unit_parameter_type_with_multiple_nested_actual_type_arguments_with_generic_array_bounds() { + static Stream imports_complex_generic_code_unit_parameter_type_with_multiple_nested_actual_type_arguments_with_generic_array_bounds() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor(ClassParameterWithFourTypeParameters< @@ -1074,9 +1043,9 @@ void method(ClassParameterWithFourTypeParameters< ); } - @Test - @UseDataProvider - public void test_imports_complex_generic_code_unit_parameter_type_with_multiple_nested_actual_type_arguments_with_generic_array_bounds(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_complex_generic_code_unit_parameter_type_with_multiple_nested_actual_type_arguments_with_generic_array_bounds(JavaCodeUnit codeUnit) { JavaType genericParameterType = codeUnit.getParameterTypes().get(0); assertThatType(genericParameterType).hasActualTypeArguments( @@ -1107,8 +1076,7 @@ public void test_imports_complex_generic_code_unit_parameter_type_with_multiple_ ); } - @DataProvider - public static Object[][] data_imports_multiple_generic_code_unit_parameter_types() { + static Stream imports_multiple_generic_code_unit_parameter_types() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor( @@ -1144,9 +1112,9 @@ void method( ); } - @Test - @UseDataProvider - public void test_imports_multiple_generic_code_unit_parameter_types(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_multiple_generic_code_unit_parameter_types(JavaCodeUnit codeUnit) { List genericParameterTypes = codeUnit.getParameterTypes(); // @formatter:off @@ -1186,7 +1154,7 @@ public void test_imports_multiple_generic_code_unit_parameter_types(JavaCodeUnit } @SuppressWarnings("rawtypes") - private static Object[][] testCasesFromSameGenericSignatureOnConstructorAndMethod( + private static Stream testCasesFromSameGenericSignatureOnConstructorAndMethod( Class genericSignatureOnConstructor, Class genericSignatureOnMethod, Class... additionalClasses @@ -1195,7 +1163,7 @@ private static Object[][] testCasesFromSameGenericSignatureOnConstructorAndMetho FluentIterable.from(additionalClasses).append(genericSignatureOnConstructor, genericSignatureOnMethod).toArray(Class.class) ); - return testForEach( + return Stream.of( getOnlyElement(classes.get(genericSignatureOnConstructor).getConstructors()), getOnlyElement(classes.get(genericSignatureOnMethod).getMethods()) ); diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericMethodSignaturesTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericMethodSignaturesTest.java index 89ede1e8ed..cfb5d4913c 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericMethodSignaturesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericMethodSignaturesTest.java @@ -8,16 +8,14 @@ import java.util.Map; import java.util.Set; import java.util.function.Function; +import java.util.stream.Stream; import com.google.common.collect.FluentIterable; import com.tngtech.archunit.ArchConfiguration; import com.tngtech.archunit.core.domain.JavaClasses; import com.tngtech.archunit.core.domain.JavaCodeUnit; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.core.importer.DependencyResolutionProcessTestUtils.importClassesWithOnlyGenericTypeResolution; @@ -31,13 +29,10 @@ import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteParameterizedType.parameterizedType; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteTypeVariable.typeVariable; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteWildcardType.wildcardType; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; -@RunWith(DataProviderRunner.class) public class ClassFileImporterGenericMethodSignaturesTest { - @DataProvider - public static Object[][] data_imports_empty_list_of_type_parameters_for_non_generic_code_unit() { + static Stream imports_empty_list_of_type_parameters_for_non_generic_code_unit() { @SuppressWarnings("unused") class NoGenericSignatureOnConstructor { NoGenericSignatureOnConstructor() { @@ -51,14 +46,13 @@ void noGenericSignatureOnMethod() { return testCasesFromSameGenericSignatureOnConstructorAndMethod(NoGenericSignatureOnConstructor.class, NoGenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_empty_list_of_type_parameters_for_non_generic_code_unit(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_empty_list_of_type_parameters_for_non_generic_code_unit(JavaCodeUnit codeUnit) { assertThat(codeUnit.getTypeParameters()).as("type parameters of non generic code unit").isEmpty(); } - @DataProvider - public static Object[][] data_imports_single_generic_type_parameter_of_code_unit() { + static Stream imports_single_generic_type_parameter_of_code_unit() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor() { @@ -72,14 +66,13 @@ void genericSignatureOnMethod() { return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_single_generic_type_parameter_of_code_unit(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_single_generic_type_parameter_of_code_unit(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasOnlyTypeParameter("T").withBoundsMatching(Object.class); } - @DataProvider - public static Object[][] data_imports_multiple_generic_type_parameters_of_code_unit() { + static Stream imports_multiple_generic_type_parameters_of_code_unit() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor() { @@ -93,14 +86,13 @@ void genericSignatureOnMethod() { return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_multiple_generic_type_parameters_of_code_unit(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_multiple_generic_type_parameters_of_code_unit(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasTypeParameters("A", "B", "C"); } - @DataProvider - public static Object[][] data_imports_simple_class_bound_of_type_variable() { + static Stream imports_simple_class_bound_of_type_variable() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor() { @@ -114,14 +106,13 @@ void genericSignatureOnMethod() { return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_simple_class_bound_of_type_variable(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_simple_class_bound_of_type_variable(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasOnlyTypeParameter("T").withBoundsMatching(String.class); } - @DataProvider - public static Object[][] data_imports_single_simple_class_bounds_of_multiple_type_variables() { + static Stream imports_single_simple_class_bounds_of_multiple_type_variables() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor() { @@ -135,9 +126,9 @@ void genericSignatureOnMeth return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_single_simple_class_bounds_of_multiple_type_variables(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_single_simple_class_bounds_of_multiple_type_variables(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit) .hasTypeParameters("A", "B", "C") .hasTypeParameter("A").withBoundsMatching(String.class) @@ -145,8 +136,7 @@ public void test_imports_single_simple_class_bounds_of_multiple_type_variables(J .hasTypeParameter("C").withBoundsMatching(File.class); } - @DataProvider - public static Object[][] data_imports_simple_interface_bound_of_single_type_variable() { + static Stream imports_simple_interface_bound_of_single_type_variable() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor() { @@ -160,14 +150,13 @@ void genericSignatureOnMethod() { return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_simple_interface_bound_of_single_type_variable(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_simple_interface_bound_of_single_type_variable(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasOnlyTypeParameter("T").withBoundsMatching(Serializable.class); } - @DataProvider - public static Object[][] data_imports_multiple_simple_bounds_of_single_type_variable() { + static Stream imports_multiple_simple_bounds_of_single_type_variable() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor() { @@ -181,14 +170,13 @@ void genericSignatureOnMethod() { return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_multiple_simple_bounds_of_single_type_variable(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_multiple_simple_bounds_of_single_type_variable(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasOnlyTypeParameter("T").withBoundsMatching(String.class, Serializable.class, Runnable.class); } - @DataProvider - public static Object[][] data_imports_multiple_simple_bounds_of_multiple_type_variables() { + static Stream imports_multiple_simple_bounds_of_multiple_type_variables() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor() { @@ -202,9 +190,9 @@ imports_single_class_bound_with_single_type_parameter_assigned_to_concrete_class() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { > GenericSignatureOnConstructor() { @@ -227,15 +214,14 @@ > void genericSignatureO return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_single_class_bound_with_single_type_parameter_assigned_to_concrete_class(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_single_class_bound_with_single_type_parameter_assigned_to_concrete_class(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasOnlyTypeParameter("T") .withBoundsMatching(parameterizedType(ClassParameterWithSingleTypeParameter.class).withTypeArguments(String.class)); } - @DataProvider - public static Object[][] data_imports_single_class_bound_with_single_type_parameter_assigned_to_array_type_argument() { + static Stream imports_single_class_bound_with_single_type_parameter_assigned_to_array_type_argument() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { > GenericSignatureOnConstructor() { @@ -249,15 +235,14 @@ > void genericSignatur return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_single_class_bound_with_single_type_parameter_assigned_to_array_type_argument(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_single_class_bound_with_single_type_parameter_assigned_to_array_type_argument(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasOnlyTypeParameter("T") .withBoundsMatching(parameterizedType(ClassParameterWithSingleTypeParameter.class).withTypeArguments(String[].class)); } - @DataProvider - public static Object[][] data_imports_single_class_bound_with_single_type_parameter_assigned_to_primitive_array_type_argument() { + static Stream imports_single_class_bound_with_single_type_parameter_assigned_to_primitive_array_type_argument() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { > GenericSignatureOnConstructor() { @@ -271,15 +256,14 @@ > void genericSignatureOn return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_single_class_bound_with_single_type_parameter_assigned_to_primitive_array_type_argument(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_single_class_bound_with_single_type_parameter_assigned_to_primitive_array_type_argument(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasOnlyTypeParameter("T") .withBoundsMatching(parameterizedType(ClassParameterWithSingleTypeParameter.class).withTypeArguments(int[].class)); } - @DataProvider - public static Object[][] data_imports_multiple_class_bounds_with_single_type_parameters_assigned_to_concrete_types() { + static Stream imports_multiple_class_bounds_with_single_type_parameters_assigned_to_concrete_types() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { < @@ -301,17 +285,16 @@ > void genericSignatureOnMethod() { return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_multiple_class_bounds_with_single_type_parameters_assigned_to_concrete_types(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_multiple_class_bounds_with_single_type_parameters_assigned_to_concrete_types(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasTypeParameters("A", "B", "C") .hasTypeParameter("A").withBoundsMatching(parameterizedType(ClassParameterWithSingleTypeParameter.class).withTypeArguments(File.class)) .hasTypeParameter("B").withBoundsMatching(parameterizedType(InterfaceParameterWithSingleTypeParameter.class).withTypeArguments(Serializable.class)) .hasTypeParameter("C").withBoundsMatching(parameterizedType(InterfaceParameterWithSingleTypeParameter.class).withTypeArguments(String.class)); } - @DataProvider - public static Object[][] data_imports_multiple_class_bounds_with_multiple_type_parameters_assigned_to_concrete_types() { + static Stream imports_multiple_class_bounds_with_multiple_type_parameters_assigned_to_concrete_types() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { < @@ -329,9 +312,9 @@ B extends Map & Iterable & Function> return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_multiple_class_bounds_with_multiple_type_parameters_assigned_to_concrete_types(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_multiple_class_bounds_with_multiple_type_parameters_assigned_to_concrete_types(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasTypeParameters("A", "B") .hasTypeParameter("A") .withBoundsMatching( @@ -344,8 +327,7 @@ public void test_imports_multiple_class_bounds_with_multiple_type_parameters_ass parameterizedType(Function.class).withTypeArguments(Integer.class, Long.class)); } - @DataProvider - public static Object[][] data_imports_single_type_bound_with_unbound_wildcard() { + static Stream imports_single_type_bound_with_unbound_wildcard() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { > GenericSignatureOnConstructor() { @@ -359,15 +341,14 @@ > void genericSignatureOnMethod() { return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_single_type_bound_with_unbound_wildcard(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_single_type_bound_with_unbound_wildcard(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit) .hasTypeParameter("T").withBoundsMatching(parameterizedType(List.class).withWildcardTypeParameter()); } - @DataProvider - public static Object[][] data_imports_single_type_bound_with_wildcard_upper_bound_by_class() { + static Stream imports_single_type_bound_with_wildcard_upper_bound_by_class() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { > GenericSignatureOnConstructor() { @@ -383,17 +364,16 @@ > void genericSignatureOnMethod() { ); } - @Test - @UseDataProvider - public void test_imports_single_type_bound_with_wildcard_upper_bound_by_class(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_single_type_bound_with_wildcard_upper_bound_by_class(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit) .hasTypeParameter("T") .withBoundsMatching(parameterizedType(List.class) .withWildcardTypeParameterWithUpperBound(String.class)); } - @DataProvider - public static Object[][] data_imports_single_type_bound_with_wildcard_upper_bound_by_interface() { + static Stream imports_single_type_bound_with_wildcard_upper_bound_by_interface() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { > GenericSignatureOnConstructor() { @@ -409,17 +389,16 @@ > void genericSignatureOnMethod() { ); } - @Test - @UseDataProvider - public void test_imports_single_type_bound_with_wildcard_upper_bound_by_interface(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_single_type_bound_with_wildcard_upper_bound_by_interface(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit) .hasTypeParameter("T") .withBoundsMatching(parameterizedType(List.class) .withWildcardTypeParameterWithUpperBound(Serializable.class)); } - @DataProvider - public static Object[][] data_imports_single_type_bound_with_wildcard_lower_bound_by_class() { + static Stream imports_single_type_bound_with_wildcard_lower_bound_by_class() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { > GenericSignatureOnConstructor() { @@ -435,17 +414,16 @@ > void genericSignatureOnMethod() { ); } - @Test - @UseDataProvider - public void test_imports_single_type_bound_with_wildcard_lower_bound_by_class(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_single_type_bound_with_wildcard_lower_bound_by_class(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit) .hasTypeParameter("T") .withBoundsMatching(parameterizedType(List.class) .withWildcardTypeParameterWithLowerBound(String.class)); } - @DataProvider - public static Object[][] data_imports_single_type_bound_with_wildcard_lower_bound_by_interface() { + static Stream imports_single_type_bound_with_wildcard_lower_bound_by_interface() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { > GenericSignatureOnConstructor() { @@ -461,17 +439,16 @@ > void genericSignatureOnMethod() { ); } - @Test - @UseDataProvider - public void test_imports_single_type_bound_with_wildcard_lower_bound_by_interface(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_single_type_bound_with_wildcard_lower_bound_by_interface(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit) .hasTypeParameter("T") .withBoundsMatching(parameterizedType(List.class) .withWildcardTypeParameterWithLowerBound(Serializable.class)); } - @DataProvider - public static Object[][] data_imports_multiple_type_bounds_with_multiple_wildcards_with_various_bounds() { + static Stream imports_multiple_type_bounds_with_multiple_wildcards_with_various_bounds() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { , B extends Reference & Map> GenericSignatureOnConstructor() { @@ -485,9 +462,9 @@ class GenericSignatureOnMethod { return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_multiple_type_bounds_with_multiple_wildcards_with_various_bounds(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_multiple_type_bounds_with_multiple_wildcards_with_various_bounds(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasTypeParameters("A", "B") .hasTypeParameter("A") .withBoundsMatching( @@ -509,8 +486,7 @@ public void test_imports_multiple_type_bounds_with_multiple_wildcards_with_vario )); } - @DataProvider - public static Object[][] data_references_type_variable_bound() { + static Stream references_type_variable_bound() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { GenericSignatureOnConstructor() { @@ -524,16 +500,15 @@ void genericSignatureOnMethod() { return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_references_type_variable_bound(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void references_type_variable_bound(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasTypeParameters("U", "T", "V") .hasTypeParameter("U").withBoundsMatching(typeVariable("T").withUpperBounds(String.class)) .hasTypeParameter("V").withBoundsMatching(typeVariable("T").withUpperBounds(String.class)); } - @DataProvider - public static Object[][] data_references_type_variable_bound_for_inner_classes() { + static Stream references_type_variable_bound_for_inner_classes() { @SuppressWarnings("unused") class Outer { class SomeInner { @@ -561,9 +536,9 @@ void genericSignatureOn ); } - @Test - @UseDataProvider - public void test_references_type_variable_bound_for_inner_classes(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void references_type_variable_bound_for_inner_classes(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasTypeParameters("MOST_INNER1", "MOST_INNER2") .hasTypeParameter("MOST_INNER1") .withBoundsMatching( @@ -575,8 +550,7 @@ public void test_references_type_variable_bound_for_inner_classes(JavaCodeUnit c typeVariable("T").withUpperBounds(String.class)))); } - @DataProvider - public static Object[][] data_imports_inner_class_as_type_variable_bound() { + static Stream imports_inner_class_as_type_variable_bound() { @SuppressWarnings("unused") class ConstructorWithTypeParameterBoundByInnerClass { .SomeInner, U extends ConstructorWithTypeParameterBoundByInnerClass.SomeInner.EvenMoreInner> ConstructorWithTypeParameterBoundByInnerClass() { @@ -604,9 +578,9 @@ class EvenMoreInner { ); } - @Test - @UseDataProvider - public void test_imports_inner_class_as_type_variable_bound(JavaCodeUnit codeUnit) throws ClassNotFoundException { + @ParameterizedTest + @MethodSource + void imports_inner_class_as_type_variable_bound(JavaCodeUnit codeUnit) throws ClassNotFoundException { Class expectedInnerClass = Class.forName(codeUnit.getOwner().getName() + "$SomeInner"); Class expectedMoreInnerClass = Class.forName(codeUnit.getOwner().getName() + "$SomeInner$EvenMoreInner"); @@ -618,8 +592,7 @@ public void test_imports_inner_class_as_type_variable_bound(JavaCodeUnit codeUni .withBoundsMatching(expectedMoreInnerClass); } - @DataProvider - public static Object[][] data_creates_new_stub_type_variables_for_type_variables_of_enclosing_classes_that_are_out_of_context() { + static Stream creates_new_stub_type_variables_for_type_variables_of_enclosing_classes_that_are_out_of_context() { @SuppressWarnings("unused") class Outer { @SuppressWarnings("InnerClassMayBeStatic") @@ -647,15 +620,15 @@ void genericSignatureOn Outer.SomeInner.EvenMoreInnerDeclaringOwn.GenericSignatureOnMethod.class); }); - return testForEach( + return Stream.of( getOnlyElement(classes.get(Outer.SomeInner.EvenMoreInnerDeclaringOwn.GenericSignatureOnConstructor.class).getConstructors()), getOnlyElement(classes.get(Outer.SomeInner.EvenMoreInnerDeclaringOwn.GenericSignatureOnMethod.class).getMethods()) ); } - @Test - @UseDataProvider - public void test_creates_new_stub_type_variables_for_type_variables_of_enclosing_classes_that_are_out_of_context(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void creates_new_stub_type_variables_for_type_variables_of_enclosing_classes_that_are_out_of_context(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasTypeParameters("MOST_INNER1", "MOST_INNER2") .hasTypeParameter("MOST_INNER1") .withBoundsMatching(typeVariable("T").withoutUpperBounds()) @@ -663,8 +636,7 @@ public void test_creates_new_stub_type_variables_for_type_variables_of_enclosing .withBoundsMatching(typeVariable("MORE_INNER2").withoutUpperBounds()); } - @DataProvider - public static Object[][] data_considers_hierarchy_of_methods_and_classes_for_type_parameter_context() throws ClassNotFoundException { + static Stream considers_hierarchy_of_methods_and_classes_for_type_parameter_context() throws ClassNotFoundException { @SuppressWarnings("unused") class Level1 { void level2() { @@ -691,9 +663,9 @@ void genericSignatureOnMethod() { Level1.class); } - @Test - @UseDataProvider - public void test_considers_hierarchy_of_methods_and_classes_for_type_parameter_context(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void considers_hierarchy_of_methods_and_classes_for_type_parameter_context(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasTypeParameters("T41", "T42") .hasTypeParameter("T41") .withBoundsMatching( @@ -704,8 +676,7 @@ public void test_considers_hierarchy_of_methods_and_classes_for_type_parameter_c .withBoundsMatching(typeVariable("T1").withUpperBounds(String.class)); } - @DataProvider - public static Object[][] data_imports_wild_cards_bound_by_type_variables() { + static Stream imports_wild_cards_bound_by_type_variables() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { , V extends List> GenericSignatureOnConstructor() { @@ -722,9 +693,9 @@ , V extends List> void ); } - @Test - @UseDataProvider - public void test_imports_wild_cards_bound_by_type_variables(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_wild_cards_bound_by_type_variables(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasTypeParameters("T", "U", "V") .hasTypeParameter("U") .withBoundsMatching( @@ -736,8 +707,7 @@ public void test_imports_wild_cards_bound_by_type_variables(JavaCodeUnit codeUni typeVariable("T").withUpperBounds(String.class))); } - @DataProvider - public static Object[][] data_imports_wild_cards_bound_by_type_variables_of_enclosing_classes() { + static Stream imports_wild_cards_bound_by_type_variables_of_enclosing_classes() { @SuppressWarnings("unused") class Outer, V extends List> { class Inner> { @@ -762,9 +732,9 @@ , MOST_INNER2 extends List> voi ); } - @Test - @UseDataProvider - public void test_imports_wild_cards_bound_by_type_variables_of_enclosing_classes(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_wild_cards_bound_by_type_variables_of_enclosing_classes(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasTypeParameters("MOST_INNER1", "MOST_INNER2") .hasTypeParameter("MOST_INNER1") .withBoundsMatching( @@ -778,8 +748,7 @@ public void test_imports_wild_cards_bound_by_type_variables_of_enclosing_classes typeVariable("T").withUpperBounds(String.class))))); } - @DataProvider - public static Object[][] data_creates_new_stub_type_variables_for_wildcards_bound_by_type_variables_of_enclosing_classes_that_are_out_of_context() { + static Stream creates_new_stub_type_variables_for_wildcards_bound_by_type_variables_of_enclosing_classes_that_are_out_of_context() { @SuppressWarnings("unused") class Outer, V extends List> { class Inner> { @@ -805,15 +774,15 @@ , MOST_INNER2 extends List> voi List.class); }); - return testForEach( + return Stream.of( getOnlyElement(classes.get(Outer.Inner.GenericSignatureOnConstructor.class).getConstructors()), getOnlyElement(classes.get(Outer.Inner.GenericSignatureOnMethod.class).getMethods()) ); } - @Test - @UseDataProvider - public void test_creates_new_stub_type_variables_for_wildcards_bound_by_type_variables_of_enclosing_classes_that_are_out_of_context(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void creates_new_stub_type_variables_for_wildcards_bound_by_type_variables_of_enclosing_classes_that_are_out_of_context(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit).hasTypeParameters("MOST_INNER1", "MOST_INNER2") .hasTypeParameter("MOST_INNER1") .withBoundsMatching( @@ -825,8 +794,7 @@ public void test_creates_new_stub_type_variables_for_wildcards_bound_by_type_var typeVariable("V").withoutUpperBounds())); } - @DataProvider - public static Object[][] data_imports_complex_type_with_multiple_nested_parameters_with_various_bounds_and_recursive_type_definitions() { + static Stream imports_complex_type_with_multiple_nested_parameters_with_various_bounds_and_recursive_type_definitions() { @SuppressWarnings({"unused", "rawtypes"}) class GenericSignatureOnConstructor { < @@ -860,9 +828,9 @@ > void genericSignatureOnMethod() { return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_complex_type_with_multiple_nested_parameters_with_various_bounds_and_recursive_type_definitions(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_complex_type_with_multiple_nested_parameters_with_various_bounds_and_recursive_type_definitions(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit) .hasTypeParameter("A") .withBoundsMatching( @@ -897,8 +865,7 @@ public void test_imports_complex_type_with_multiple_nested_parameters_with_vario .hasTypeParameter("RAW").withBoundsMatching(List.class); } - @DataProvider - public static Object[][] data_imports_complex_type_with_multiple_nested_parameters_with_concrete_array_bounds() { + static Stream imports_complex_type_with_multiple_nested_parameters_with_concrete_array_bounds() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { < @@ -920,9 +887,9 @@ > void genericSignatureOnMethod() { return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_complex_type_with_multiple_nested_parameters_with_concrete_array_bounds(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_complex_type_with_multiple_nested_parameters_with_concrete_array_bounds(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit) .hasTypeParameter("A") .withBoundsMatching( @@ -942,8 +909,7 @@ public void test_imports_complex_type_with_multiple_nested_parameters_with_concr ); } - @DataProvider - public static Object[][] data_imports_type_with_parameterized_array_bounds() { + static Stream imports_type_with_parameterized_array_bounds() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { < @@ -961,9 +927,9 @@ > void genericSignatureOnMethod() { return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_type_with_parameterized_array_bounds(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_type_with_parameterized_array_bounds(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit) .hasTypeParameter("T") .withBoundsMatching( @@ -979,8 +945,7 @@ public void test_imports_type_with_parameterized_array_bounds(JavaCodeUnit codeU parameterizedType(List.class).withTypeArguments(String[][].class)))))); } - @DataProvider - public static Object[][] data_imports_complex_type_with_multiple_nested_parameters_with_generic_array_bounds() { + static Stream imports_complex_type_with_multiple_nested_parameters_with_generic_array_bounds() { @SuppressWarnings("unused") class GenericSignatureOnConstructor { < @@ -1006,9 +971,9 @@ > void genericSignatureOnMethod() { return testCasesFromSameGenericSignatureOnConstructorAndMethod(GenericSignatureOnConstructor.class, GenericSignatureOnMethod.class); } - @Test - @UseDataProvider - public void test_imports_complex_type_with_multiple_nested_parameters_with_generic_array_bounds(JavaCodeUnit codeUnit) { + @ParameterizedTest + @MethodSource + void imports_complex_type_with_multiple_nested_parameters_with_generic_array_bounds(JavaCodeUnit codeUnit) { assertThatCodeUnit(codeUnit) .hasTypeParameter("A") .withBoundsMatching( @@ -1041,7 +1006,7 @@ public void test_imports_complex_type_with_multiple_nested_parameters_with_gener } @SuppressWarnings("rawtypes") - private static Object[][] testCasesFromSameGenericSignatureOnConstructorAndMethod( + private static Stream testCasesFromSameGenericSignatureOnConstructorAndMethod( Class genericSignatureOnConstructor, Class genericSignatureOnMethod, Class... additionalClasses @@ -1050,7 +1015,7 @@ private static Object[][] testCasesFromSameGenericSignatureOnConstructorAndMetho FluentIterable.from(additionalClasses).append(genericSignatureOnConstructor, genericSignatureOnMethod).toArray(Class.class) ); - return testForEach( + return Stream.of( getOnlyElement(classes.get(genericSignatureOnConstructor).getConstructors()), getOnlyElement(classes.get(genericSignatureOnMethod).getMethods()) ); diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterLambdaDependenciesTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterLambdaDependenciesTest.java index b3d8af99d9..43cb81b98f 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterLambdaDependenciesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterLambdaDependenciesTest.java @@ -7,6 +7,7 @@ import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; +import java.util.stream.Stream; import com.tngtech.archunit.core.domain.AccessTarget.MethodCallTarget; import com.tngtech.archunit.core.domain.InstanceofCheck; @@ -23,12 +24,11 @@ import com.tngtech.archunit.core.domain.TryCatchBlock; import com.tngtech.archunit.core.importer.testexamples.instanceofcheck.CheckingInstanceofFromLambda; import com.tngtech.archunit.core.importer.testexamples.referencedclassobjects.ReferencingClassObjectsFromLambda; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; import org.assertj.core.api.Condition; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.core.domain.Formatters.formatNamesOf; @@ -42,15 +42,13 @@ import static com.tngtech.archunit.testutil.Assertions.assertThatCall; import static com.tngtech.archunit.testutil.Assertions.assertThatInstanceofChecks; import static com.tngtech.archunit.testutil.Assertions.assertThatReferencedClassObjects; +import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.assertion.AccessesAssertion.access; import static com.tngtech.archunit.testutil.assertion.InstanceofChecksAssertion.instanceofCheck; import static com.tngtech.archunit.testutil.assertion.ReferencedClassObjectsAssertion.referencedClassObject; import static com.tngtech.archunit.testutil.assertion.TryCatchBlockAssertion.tryCatchBlock; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; import static java.util.stream.Collectors.toSet; -@RunWith(DataProviderRunner.class) public class ClassFileImporterLambdaDependenciesTest { @Test public void imports_method_call_from_lambda_without_parameter() { @@ -474,8 +472,7 @@ void method() { } } - @DataProvider - public static Object[][] data_adds_information_about_being_declared_inside_a_lambda_to_accesses() { + static Stream adds_information_about_being_declared_inside_a_lambda_to_accesses() { @SuppressWarnings("unused") class FieldAccessCase { Object fieldAccessDirect(Data_of_adds_information_about_being_declared_inside_a_lambda_to_accesses.Target target) { @@ -529,7 +526,7 @@ Supplier caller, Class target) { + @ParameterizedTest + @MethodSource + void adds_information_about_being_declared_inside_a_lambda_to_accesses(Class caller, Class target) { Set> accesses = new ClassFileImporter() .importClasses(caller, target) .get(caller).getAccessesFromSelf().stream() diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/LocationTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/LocationTest.java index bd8cdbb1eb..7fb390e324 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/LocationTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/LocationTest.java @@ -14,6 +14,7 @@ import java.util.Set; import java.util.jar.JarFile; import java.util.regex.Pattern; +import java.util.stream.Stream; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Sets; @@ -21,23 +22,18 @@ import com.tngtech.archunit.base.DescribedPredicate; import com.tngtech.archunit.core.InitialConfigurationTest; import com.tngtech.archunit.core.importer.resolvers.ClassResolverFactoryTest; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; import org.assertj.core.api.Condition; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.base.Preconditions.checkState; import static com.google.common.io.ByteStreams.toByteArray; import static com.google.common.primitives.Bytes.asList; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; import static java.util.Collections.singleton; import static java.util.stream.Collectors.toList; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class LocationTest { @Test public void file_resources_are_not_detected_as_JARs() { @@ -195,17 +191,16 @@ public void equals_and_hashcode() { assertThat(location).isNotEqualTo(new Object()); } - @DataProvider - public static Object[][] file_locations_pointing_to_jar() throws MalformedURLException { + static Stream file_locations_pointing_to_jar() throws MalformedURLException { String jarFileName = new TestJarFile().withEntry(classFileResource(LocationTest.class)).createAndReturnName(); - return $$( - $(Location.of(new File(jarFileName).toURI().toURL())), - $(Location.of(new File(jarFileName).toURI()))); + return Stream.of( + Location.of(new File(jarFileName).toURI().toURL()), + Location.of(new File(jarFileName).toURI())); } - @Test - @UseDataProvider("file_locations_pointing_to_jar") - public void JAR_protocol_is_added_to_file_urls_that_point_to_JARs(Location location) throws MalformedURLException { + @ParameterizedTest + @MethodSource("file_locations_pointing_to_jar") + 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"); @@ -247,25 +242,24 @@ public void JAR_location_as_ClassFileSource() throws IOException { asList(toByteArray(streamOfClass(Location.class)))); } - @DataProvider - public static Object[][] locations_of_own_class() throws URISyntaxException { - return $$( - $(Location.of(urlOfClass(LocationTest.class))), - $(Location.of(urlOfClass(LocationTest.class).toURI()))); + static Stream locations_of_own_class() throws URISyntaxException { + return Stream.of( + Location.of(urlOfClass(LocationTest.class)), + Location.of(urlOfClass(LocationTest.class).toURI())); } - @Test - @UseDataProvider("locations_of_own_class") - public void contains(Location location) { + @ParameterizedTest + @MethodSource("locations_of_own_class") + void contains(Location location) { assertThat(location.contains("archunit")).as("location contains 'archunit'").isTrue(); assertThat(location.contains("/archunit/")).as("location contains '/archunit/'").isTrue(); assertThat(location.contains(getClass().getSimpleName())).as("location contains own simple class name").isTrue(); assertThat(location.contains("wrong")).as("location contains 'wrong'").isFalse(); } - @Test - @UseDataProvider("locations_of_own_class") - public void matches(Location location) { + @ParameterizedTest + @MethodSource("locations_of_own_class") + void matches(Location location) { assertThat(location.matches(Pattern.compile("archunit.*"))).as("location matches 'archunit.*'").isFalse(); assertThat(location.matches(Pattern.compile(".*archunit.*"))).as("location matches '.*archunit.*'").isTrue(); assertThat(location.matches(Pattern.compile(".*/archunit/.*"))).as("location contains '/archunit/'").isTrue(); @@ -286,11 +280,10 @@ public void location_of_path() throws URISyntaxException { assertThat(Location.of(Paths.get(url.toURI())).asURI()).isEqualTo(url.toURI()); } - @DataProvider - public static Object[][] base_locations() { - return $$( - $(Location.of(withoutTrailingSlash(Paths.get("/some/path").toUri()))), - $(Location.of(withTrailingSlash(Paths.get("/some/path/").toUri())))); + static Stream base_locations() { + return Stream.of( + Location.of(withoutTrailingSlash(Paths.get("/some/path").toUri())), + Location.of(withTrailingSlash(Paths.get("/some/path/").toUri()))); } private static URI withoutTrailingSlash(URI uri) { @@ -301,9 +294,9 @@ private static URI withTrailingSlash(URI uri) { return URI.create(uri.toString().replaceAll("/*$", "/")); } - @Test - @UseDataProvider("base_locations") - public void append(Location location) { + @ParameterizedTest + @MethodSource("base_locations") + void append(Location location) { Location appendAbsolute = location.append("/bar/baz"); Location appendRelative = location.append("bar/baz"); diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/NormalizedResourceNameTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/NormalizedResourceNameTest.java index 58a6e8bfe4..0a18b73f28 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/NormalizedResourceNameTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/NormalizedResourceNameTest.java @@ -1,20 +1,17 @@ package com.tngtech.archunit.core.importer; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import java.util.stream.Stream; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class NormalizedResourceNameTest { - @DataProvider - public static Object[][] resource_name_starts_with_cases() { - return $$( + static Stream resource_name_starts_with_cases() { + return Stream.of( $("com", "com", true), $("com/foo", "com", true), $("/com/", "/com", true), @@ -29,9 +26,9 @@ public static Object[][] resource_name_starts_with_cases() { ); } - @Test - @UseDataProvider("resource_name_starts_with_cases") - public void resource_name_starts_with_other_resource_name( + @ParameterizedTest + @MethodSource("resource_name_starts_with_cases") + void resource_name_starts_with_other_resource_name( String resourceName, String startsWith, boolean expectedResult) { assertThat(NormalizedResourceName.from(resourceName).startsWith(NormalizedResourceName.from(startsWith))) @@ -39,9 +36,8 @@ public void resource_name_starts_with_other_resource_name( .isEqualTo(expectedResult); } - @DataProvider - public static Object[][] names_to_absolute_names() { - return $$( + static Stream names_to_absolute_names() { + return Stream.of( $("", "/"), $("com", "/com/"), $("com/foo", "/com/foo/"), @@ -50,17 +46,16 @@ public static Object[][] names_to_absolute_names() { ); } - @Test - @UseDataProvider("names_to_absolute_names") - public void creates_absolute_path(String input, String expectedAbsolutePath) { + @ParameterizedTest + @MethodSource("names_to_absolute_names") + void creates_absolute_path(String input, String expectedAbsolutePath) { NormalizedResourceName resourceName = NormalizedResourceName.from(input); assertThat(resourceName.toAbsolutePath()).isEqualTo(expectedAbsolutePath); } - @DataProvider - public static Object[][] names_to_entry_names() { - return $$( + static Stream names_to_entry_names() { + return Stream.of( $("", ""), $("/com", "com/"), $("/com/foo", "com/foo/"), @@ -69,9 +64,9 @@ public static Object[][] names_to_entry_names() { ); } - @Test - @UseDataProvider("names_to_entry_names") - public void creates_entry_name(String input, String expectedEntryName) { + @ParameterizedTest + @MethodSource("names_to_entry_names") + void creates_entry_name(String input, String expectedEntryName) { NormalizedResourceName resourceName = NormalizedResourceName.from(input); assertThat(resourceName.toEntryName()).isEqualTo(expectedEntryName); diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/resolvers/ClassResolverFromClassPathTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/resolvers/ClassResolverFromClassPathTest.java index c56f414ac4..9daed0dd8b 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/resolvers/ClassResolverFromClassPathTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/resolvers/ClassResolverFromClassPathTest.java @@ -6,42 +6,38 @@ import java.net.URL; import java.util.Optional; import java.util.function.Function; +import java.util.stream.Stream; import com.tngtech.archunit.core.domain.JavaClass; import com.tngtech.archunit.core.importer.resolvers.ClassResolver.ClassUriImporter; import com.tngtech.archunit.testutil.TestUtils; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; import static com.tngtech.archunit.core.domain.TestUtils.importClassWithContext; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -@RunWith(DataProviderRunner.class) -public class ClassResolverFromClassPathTest { - @Rule - public final MockitoRule mockitoRule = MockitoJUnit.rule(); +@ExtendWith(MockitoExtension.class) +class ClassResolverFromClassPathTest { @Mock private ClassUriImporter uriImporter; private final ClassResolverFromClasspath resolver = new ClassResolverFromClasspath(); - @Before - public void setUp() { + @BeforeEach + void setUp() { resolver.setClassUriImporter(uriImporter); } @@ -63,17 +59,16 @@ public void is_resilient_if_URI_cant_be_located() { verifyNoMoreInteractions(uriImporter); } - @DataProvider - public static Object[][] urls_with_spaces() throws MalformedURLException, URISyntaxException { - return $$( + static Stream urls_with_spaces() throws MalformedURLException, URISyntaxException { + return Stream.of( $(new URL("file:/C:/Some Windows/URL with spaces 123/any.jar"), new URI("file:/C:/Some%20Windows/URL%20with%20spaces%20123/any.jar")), $(new URL("file:/Some Unix/URL with spaces 123/any.jar"), new URI("file:/Some%20Unix/URL%20with%20spaces%20123/any.jar")) ); } - @Test - @UseDataProvider("urls_with_spaces") - public void is_resilient_against_wrongly_encoded_ClassLoader_resource_URLs(URL urlReturnedByClassLoader, URI expectedUriDerivedFromUrl) { + @ParameterizedTest + @MethodSource("urls_with_spaces") + void is_resilient_against_wrongly_encoded_ClassLoader_resource_URLs(URL urlReturnedByClassLoader, URI expectedUriDerivedFromUrl) { // it seems like some OSGI ClassLoaders incorrectly return URLs with unencoded spaces. // This lead to `url.toURI()` throwing an exception -> https://github.com/TNG/ArchUnit/issues/683 verifyUrlCannotBeConvertedToUriInTheCurrentForm(urlReturnedByClassLoader); diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/ArchConditionTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/ArchConditionTest.java index 66c53afda2..d86f032e82 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/ArchConditionTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/ArchConditionTest.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Objects; import java.util.function.Function; +import java.util.stream.Stream; import com.google.common.collect.HashMultiset; import com.google.common.collect.Multiset; @@ -13,11 +14,9 @@ import com.tngtech.archunit.core.domain.JavaClass; import com.tngtech.archunit.core.importer.ClassFileImporter; import com.tngtech.archunit.lang.ArchCondition.ConditionByPredicate; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.base.DescribedPredicate.alwaysFalse; import static com.tngtech.archunit.base.DescribedPredicate.alwaysTrue; @@ -25,11 +24,8 @@ import static com.tngtech.archunit.lang.conditions.ArchConditions.never; import static com.tngtech.archunit.lang.conditions.ArchConditions.not; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; import static java.util.Collections.singleton; -@RunWith(DataProviderRunner.class) public class ArchConditionTest { @Test public void as_inits_delegate() { @@ -128,27 +124,26 @@ public void or_handles_all_violated_conditions_as_unit() { 1, "1 is not greater than 1 and 1 is not greater than 2 and 1 is not greater than 3")); } - @DataProvider - public static Object[][] conditionCombinations() { - return $$( - $(new ConditionCombination("and") { + static Stream conditionCombinations() { + return Stream.of( + new ConditionCombination("and") { @Override ArchCondition combine(ArchCondition first, ArchCondition second) { return first.and(second); } - }), - $(new ConditionCombination("or") { + }, + new ConditionCombination("or") { @Override ArchCondition combine(ArchCondition first, ArchCondition second) { return first.or(second); } - }) + } ); } - @Test - @UseDataProvider("conditionCombinations") - public void join_inits_all_conditions(ConditionCombination combination) { + @ParameterizedTest + @MethodSource("conditionCombinations") + void join_inits_all_conditions(ConditionCombination combination) { ConditionWithInitAndFinish one = someCondition("one"); ConditionWithInitAndFinish two = someCondition("two"); @@ -158,9 +153,9 @@ public void join_inits_all_conditions(ConditionCombination combination) { assertThat(two.allObjectsToTest).containsExactly("init"); } - @Test - @UseDataProvider("conditionCombinations") - public void join_finishes_all_conditions(ConditionCombination combination) { + @ParameterizedTest + @MethodSource("conditionCombinations") + void join_finishes_all_conditions(ConditionCombination combination) { ConditionWithInitAndFinish one = someCondition("one"); ConditionWithInitAndFinish two = someCondition("two"); @@ -171,9 +166,9 @@ public void join_finishes_all_conditions(ConditionCombination combination) { assertThat(two.eventsFromFinish).isEqualTo(events); } - @Test - @UseDataProvider("conditionCombinations") - public void and_joins_descriptions(ConditionCombination combination) { + @ParameterizedTest + @MethodSource("conditionCombinations") + void and_joins_descriptions(ConditionCombination combination) { ConditionWithInitAndFinish one = someCondition("one"); ConditionWithInitAndFinish two = someCondition("two"); diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/conditions/NeverConditionTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/conditions/NeverConditionTest.java index 776f9d66ac..c1b941af11 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/conditions/NeverConditionTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/conditions/NeverConditionTest.java @@ -1,23 +1,20 @@ package com.tngtech.archunit.lang.conditions; import java.util.Collections; +import java.util.stream.Stream; import com.tngtech.archunit.lang.ArchCondition; import com.tngtech.archunit.lang.ArchConditionTest.ConditionWithInitAndFinish; import com.tngtech.archunit.lang.ConditionEvents; import com.tngtech.archunit.lang.SimpleConditionEvent; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.lang.ArchConditionTest.someCondition; import static com.tngtech.archunit.lang.conditions.ArchConditions.never; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; -@RunWith(DataProviderRunner.class) public class NeverConditionTest { private static final String ORIGINALLY_MISMATCH = "originally mismatch"; private static final String ORIGINALLY_NO_MISMATCH = "originally no mismatch"; @@ -47,14 +44,13 @@ private static void addOneViolatedOneSatisfied(Object item, ConditionEvents even events.add(new SimpleConditionEvent(item, true, ORIGINALLY_NO_MISMATCH)); } - @DataProvider - public static Object[][] conditions() { - return testForEach(ONE_VIOLATED_ONE_SATISFIED, ONE_VIOLATED_ONE_SATISFIED_IN_FINISH); + static Stream> conditions() { + return Stream.of(ONE_VIOLATED_ONE_SATISFIED, ONE_VIOLATED_ONE_SATISFIED_IN_FINISH); } - @Test - @UseDataProvider("conditions") - public void inverts_condition(ArchCondition condition) { + @ParameterizedTest + @MethodSource("conditions") + void inverts_condition(ArchCondition condition) { ConditionEvents events = ConditionEvents.Factory.create(); condition.check(new Object(), events); condition.finish(events); diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/TransformersTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/TransformersTest.java index 536271c9fc..1c96405373 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/TransformersTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/TransformersTest.java @@ -2,6 +2,7 @@ import java.util.HashSet; import java.util.Set; +import java.util.stream.Stream; import com.google.common.collect.Sets; import com.tngtech.archunit.base.DescribedIterable; @@ -9,20 +10,17 @@ import com.tngtech.archunit.core.domain.JavaClasses; import com.tngtech.archunit.core.domain.JavaMember; import com.tngtech.archunit.lang.ClassesTransformer; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.core.domain.TestUtils.importClasses; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.Arrays.stream; import static java.util.stream.Collectors.toSet; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class TransformersTest { @Test public void test_classes() { @@ -33,9 +31,8 @@ public void test_classes() { assertThat(output).hasSameElementsAs(input); } - @DataProvider - public static Object[][] members_testcases() { - return $$( + static Stream members_testcases() { + return Stream.of( $(Transformers.members(), Sets.union( createMemberStrings(ClassWithMembers.class, @@ -61,9 +58,9 @@ public static Object[][] members_testcases() { ); } - @Test - @UseDataProvider("members_testcases") - public void test_members(ClassesTransformer transformer, Set expectedMembers) { + @ParameterizedTest + @MethodSource("members_testcases") + void test_members(ClassesTransformer transformer, Set expectedMembers) { DescribedIterable actualMembers = transformer.transform(importClasses(ClassWithMembers.class, AnotherClassWithMembers.class)); assertThat(createMemberStrings(actualMembers)).isEqualTo(expectedMembers); diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldConjunctionTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldConjunctionTest.java index 8f78537859..21229c23c0 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldConjunctionTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldConjunctionTest.java @@ -1,15 +1,13 @@ package com.tngtech.archunit.lang.syntax.elements; import java.util.Comparator; +import java.util.stream.Stream; import com.tngtech.archunit.lang.ArchRule; import com.tngtech.archunit.lang.EvaluationResult; import com.tngtech.archunit.lang.FailureReport; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.core.domain.TestUtils.importClasses; import static com.tngtech.archunit.lang.conditions.ArchConditions.accessClassesThat; @@ -19,27 +17,23 @@ import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses; import static com.tngtech.archunit.lang.syntax.elements.ClassesShouldTest.locationPattern; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; import static java.util.regex.Pattern.quote; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class ClassesShouldConjunctionTest { - @DataProvider - public static Object[][] ORed_conditions() { - return $$( - $(classes() + static Stream ORed_conditions() { + return Stream.of( + classes() .should(haveFullyQualifiedName(RightOne.class.getName())) - .orShould(haveFullyQualifiedName(RightTwo.class.getName()))), - $(classes() + .orShould(haveFullyQualifiedName(RightTwo.class.getName())), + classes() .should().haveFullyQualifiedName(RightOne.class.getName()) - .orShould().haveFullyQualifiedName(RightTwo.class.getName()))); + .orShould().haveFullyQualifiedName(RightTwo.class.getName())); } - @Test - @UseDataProvider("ORed_conditions") - public void orShould_ORs_conditions(ArchRule rule) { + @ParameterizedTest + @MethodSource("ORed_conditions") + void orShould_ORs_conditions(ArchRule rule) { EvaluationResult result = rule .evaluate(importClasses(RightOne.class, RightTwo.class, Wrong.class)); @@ -54,20 +48,19 @@ public void orShould_ORs_conditions(ArchRule rule) { doesntHaveFqnMessage(Wrong.class, RightTwo.class))); } - @DataProvider - public static Object[][] ORed_conditions_that() { - return $$( - $(noClasses() + static Stream ORed_conditions_that() { + return Stream.of( + noClasses() .should(accessClassesThat(have(fullyQualifiedName(Wrong.class.getName())))) - .orShould(haveFullyQualifiedName(Wrong.class.getName()))), - $(noClasses() + .orShould(haveFullyQualifiedName(Wrong.class.getName())), + noClasses() .should().accessClassesThat().haveFullyQualifiedName(Wrong.class.getName()) - .orShould().haveFullyQualifiedName(Wrong.class.getName()))); + .orShould().haveFullyQualifiedName(Wrong.class.getName())); } - @Test - @UseDataProvider("ORed_conditions_that") - public void orShould_ORs_conditions_that(ArchRule rule) { + @ParameterizedTest + @MethodSource("ORed_conditions_that") + void orShould_ORs_conditions_that(ArchRule rule) { EvaluationResult result = rule .evaluate(importClasses(RightOne.class, RightTwo.class, Wrong.class, OtherWrong.class)); @@ -81,20 +74,19 @@ public void orShould_ORs_conditions_that(ArchRule rule) { otherWrongCallsWrongRegex()); } - @DataProvider - public static Object[][] ANDed_conditions() { - return $$( - $(classes() + static Stream ANDed_conditions() { + return Stream.of( + classes() .should(haveFullyQualifiedName(RightOne.class.getName())) - .andShould(haveFullyQualifiedName(RightTwo.class.getName()))), - $(classes() + .andShould(haveFullyQualifiedName(RightTwo.class.getName())), + classes() .should().haveFullyQualifiedName(RightOne.class.getName()) - .andShould().haveFullyQualifiedName(RightTwo.class.getName()))); + .andShould().haveFullyQualifiedName(RightTwo.class.getName())); } - @Test - @UseDataProvider("ANDed_conditions") - public void andShould_ANDs_conditions(ArchRule rule) { + @ParameterizedTest + @MethodSource("ANDed_conditions") + void andShould_ANDs_conditions(ArchRule rule) { EvaluationResult result = rule .evaluate(importClasses(RightOne.class, RightTwo.class, Wrong.class)); @@ -119,20 +111,19 @@ private Class locationOf(Class clazz) { return clazz.getEnclosingClass() != null ? clazz.getEnclosingClass() : clazz; } - @DataProvider - public static Object[][] ANDed_conditions_that() { - return $$( - $(noClasses() + static Stream ANDed_conditions_that() { + return Stream.of( + noClasses() .should(accessClassesThat(have(fullyQualifiedName(Wrong.class.getName())))) - .andShould(haveFullyQualifiedName(OtherWrong.class.getName()))), - $(noClasses() + .andShould(haveFullyQualifiedName(OtherWrong.class.getName())), + noClasses() .should().accessClassesThat().haveFullyQualifiedName(Wrong.class.getName()) - .andShould().haveFullyQualifiedName(OtherWrong.class.getName()))); + .andShould().haveFullyQualifiedName(OtherWrong.class.getName())); } - @Test - @UseDataProvider("ANDed_conditions_that") - public void andShould_ANDs_conditions_that(ArchRule rule) { + @ParameterizedTest + @MethodSource("ANDed_conditions_that") + void andShould_ANDs_conditions_that(ArchRule rule) { EvaluationResult result = rule .evaluate(importClasses(RightOne.class, RightTwo.class, Wrong.class, OtherWrong.class)); diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesThatTestsExistTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesThatTestsExistTest.java index 4dc169273d..582d814e89 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesThatTestsExistTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesThatTestsExistTest.java @@ -7,6 +7,7 @@ import com.google.common.collect.ImmutableSet; import com.google.common.collect.Multiset; import org.junit.Test; +import org.junit.jupiter.params.ParameterizedTest; import static java.util.Arrays.stream; import static java.util.stream.Collectors.toSet; @@ -37,7 +38,9 @@ public void for_each_context_all_syntax_elements_are_tested() { private Set getMethodsStartingWith(String prefix, Class testClass) { return stream(testClass.getDeclaredMethods()) - .filter(method -> method.getAnnotation(Test.class) != null) + .filter(method -> method.getAnnotation(Test.class) != null || + method.getAnnotation(org.junit.jupiter.api.Test.class) != null || + method.getAnnotation(ParameterizedTest.class) != null) .filter(method -> method.getName().startsWith(prefix)) .collect(toSet()); } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/CodeUnitsShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/CodeUnitsShouldTest.java index e5cd6a3fdb..2b92b3d0e8 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/CodeUnitsShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/CodeUnitsShouldTest.java @@ -4,6 +4,7 @@ import java.util.Collections; import java.util.List; import java.util.Set; +import java.util.stream.Stream; import com.google.common.base.Joiner; import com.google.common.collect.ImmutableSet; @@ -21,11 +22,10 @@ import com.tngtech.archunit.lang.syntax.elements.GivenCodeUnitsTest.A; import com.tngtech.archunit.lang.syntax.elements.GivenCodeUnitsTest.ClassWithVariousMembers; import com.tngtech.archunit.lang.syntax.elements.GivenCodeUnitsTest.FirstException; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.google.common.collect.Sets.union; @@ -56,11 +56,9 @@ import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.assertViolation; import static com.tngtech.archunit.lang.syntax.elements.MembersShouldTest.parseMembers; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.regex.Pattern.quote; -@RunWith(DataProviderRunner.class) public class CodeUnitsShouldTest { @Test @@ -126,9 +124,8 @@ public void check(JavaConstructor constructor, ConditionEvents events) { assertThat(Joiner.on(" ").join(result.getFailureReport().getDetails())).contains("expected violation"); } - @DataProvider - public static Object[][] restricted_parameter_types_rules() { - return $$( + static Stream restricted_parameter_types_rules() { + return Stream.of( $(codeUnits().should().haveRawParameterTypes(String.class), union(allMethodsExcept(METHOD_ONE_ARG), allConstructorsExcept(CONSTRUCTOR_ONE_ARG))), $(codeUnits().should().haveRawParameterTypes(String.class.getName()), @@ -170,18 +167,17 @@ public static Object[][] restricted_parameter_types_rules() { ); } - @Test - @UseDataProvider("restricted_parameter_types_rules") - public void parameter_types_predicates(ArchRule rule, Collection expectedMembers) { + @ParameterizedTest + @MethodSource("restricted_parameter_types_rules") + void parameter_types_predicates(ArchRule rule, Collection expectedMembers) { EvaluationResult result = rule.evaluate(importClasses(ClassWithVariousMembers.class)); Set actualMembers = parseMembers(ClassWithVariousMembers.class, result.getFailureReport().getDetails()); assertThat(actualMembers).hasSameElementsAs(expectedMembers); } - @DataProvider - public static Object[][] restricted_return_type_rules() { - return $$( + static Stream restricted_return_type_rules() { + return Stream.of( $(codeUnits().should().haveRawReturnType(String.class), union(allMethodsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS), ALL_CONSTRUCTOR_DESCRIPTIONS)), $(codeUnits().should().haveRawReturnType(String.class.getName()), @@ -223,18 +219,17 @@ public static Object[][] restricted_return_type_rules() { ); } - @Test - @UseDataProvider("restricted_return_type_rules") - public void return_type_predicates(ArchRule rule, Collection expectedMembers) { + @ParameterizedTest + @MethodSource("restricted_return_type_rules") + void return_type_predicates(ArchRule rule, Collection expectedMembers) { EvaluationResult result = rule.evaluate(importClasses(ClassWithVariousMembers.class)); Set actualMembers = parseMembers(ClassWithVariousMembers.class, result.getFailureReport().getDetails()); assertThat(actualMembers).hasSameElementsAs(expectedMembers); } - @DataProvider - public static Object[][] restricted_throwable_type_rules() { - return $$( + static Stream restricted_throwable_type_rules() { + return Stream.of( $(codeUnits().should().declareThrowableOfType(FirstException.class), ImmutableSet.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS, CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), $(codeUnits().should().declareThrowableOfType(FirstException.class.getName()), @@ -276,27 +271,26 @@ public static Object[][] restricted_throwable_type_rules() { ); } - @Test - @UseDataProvider("restricted_throwable_type_rules") - public void throwable_type_predicates(ArchRule rule, Collection expectedMembers) { + @ParameterizedTest + @MethodSource("restricted_throwable_type_rules") + void throwable_type_predicates(ArchRule rule, Collection expectedMembers) { EvaluationResult result = rule.evaluate(importClasses(ClassWithVariousMembers.class)); Set actualMembers = parseMembers(ClassWithVariousMembers.class, result.getFailureReport().getDetails()); assertThat(actualMembers).hasSameElementsAs(expectedMembers); } - @DataProvider - public static Object[][] restricted_constructor_calls_by_classes_rules() { - return $$( + static Stream restricted_constructor_calls_by_classes_rules() { + return Stream.of( $(constructors().should(onlyBeCalledByClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)))), $(constructors().should().onlyBeCalled().byClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class))), $(constructors().should().onlyBeCalled().byClassesThat().belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)) ); } - @Test - @UseDataProvider("restricted_constructor_calls_by_classes_rules") - public void restricted_constructor_calls_by_classes_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("restricted_constructor_calls_by_classes_rules") + void restricted_constructor_calls_by_classes_predicate(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses(ClassWithMethodAndConstructor.class, ClassCorrectlyCallingMethodAndConstructor.class, ClassWronglyCallingMethodAndConstructor.class)); @@ -309,18 +303,17 @@ public void restricted_constructor_calls_by_classes_predicate(ArchRule rule) { quote(CONSTRUCTOR_ONE_ARG))); } - @DataProvider - public static Object[][] restricted_method_calls_by_classes_rules() { - return $$( + static Stream restricted_method_calls_by_classes_rules() { + return Stream.of( $(methods().should(onlyBeCalledByClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)))), $(methods().should().onlyBeCalled().byClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class))), $(methods().should().onlyBeCalled().byClassesThat().belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)) ); } - @Test - @UseDataProvider("restricted_method_calls_by_classes_rules") - public void restricted_method_calls_by_classes_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("restricted_method_calls_by_classes_rules") + void restricted_method_calls_by_classes_predicate(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses(ClassWithMethodAndConstructor.class, ClassCorrectlyCallingMethodAndConstructor.class, ClassWronglyCallingMethodAndConstructor.class)); @@ -333,18 +326,17 @@ public void restricted_method_calls_by_classes_predicate(ArchRule rule) { quote(METHOD_ONE_ARG))); } - @DataProvider - public static Object[][] restricted_code_unit_calls_by_classes_rules() { - return $$( + static Stream restricted_code_unit_calls_by_classes_rules() { + return Stream.of( $(codeUnits().should(onlyBeCalledByClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)))), $(codeUnits().should().onlyBeCalled().byClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class))), $(codeUnits().should().onlyBeCalled().byClassesThat().belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)) ); } - @Test - @UseDataProvider("restricted_code_unit_calls_by_classes_rules") - public void restricted_code_units_calls_by_classes_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("restricted_code_unit_calls_by_classes_rules") + void restricted_code_units_calls_by_classes_predicate(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses(ClassWithMethodAndConstructor.class, ClassCorrectlyCallingMethodAndConstructor.class, ClassWronglyCallingMethodAndConstructor.class)); @@ -362,17 +354,16 @@ public void restricted_code_units_calls_by_classes_predicate(ArchRule rule) { quote(CONSTRUCTOR_ONE_ARG))); } - @DataProvider - public static Object[][] restricted_code_unit_calls_by_methods_rules() { - return $$( + static Stream restricted_code_unit_calls_by_methods_rules() { + return Stream.of( $(codeUnits().should(onlyBeCalledByMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), $(codeUnits().should().onlyBeCalled().byMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } - @Test - @UseDataProvider("restricted_code_unit_calls_by_methods_rules") - public void restricted_code_units_calls_by_methods_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("restricted_code_unit_calls_by_methods_rules") + void restricted_code_units_calls_by_methods_predicate(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses(ClassWithMethodAndConstructor.class, ClassCorrectlyCallingMethodAndConstructor.class, ClassWronglyCallingMethodAndConstructor.class)); @@ -400,17 +391,16 @@ public void restricted_code_units_calls_by_methods_predicate(ArchRule rule) { quote(METHOD_ONE_ARG))); } - @DataProvider - public static Object[][] restricted_code_unit_calls_by_constructors_rules() { - return $$( + static Stream restricted_code_unit_calls_by_constructors_rules() { + return Stream.of( $(codeUnits().should(onlyBeCalledByConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), $(codeUnits().should().onlyBeCalled().byConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } - @Test - @UseDataProvider("restricted_code_unit_calls_by_constructors_rules") - public void restricted_code_units_calls_by_constructors_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("restricted_code_unit_calls_by_constructors_rules") + void restricted_code_units_calls_by_constructors_predicate(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses(ClassWithMethodAndConstructor.class, ClassCorrectlyCallingMethodAndConstructor.class, ClassWronglyCallingMethodAndConstructor.class)); @@ -438,17 +428,16 @@ public void restricted_code_units_calls_by_constructors_predicate(ArchRule rule) quote(METHOD_ONE_ARG))); } - @DataProvider - public static Object[][] restricted_code_unit_calls_by_code_units_rules() { - return $$( + static Stream restricted_code_unit_calls_by_code_units_rules() { + return Stream.of( $(codeUnits().should(onlyBeCalledByCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), $(codeUnits().should().onlyBeCalled().byCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } - @Test - @UseDataProvider("restricted_code_unit_calls_by_code_units_rules") - public void restricted_code_units_calls_by_code_units_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("restricted_code_unit_calls_by_code_units_rules") + void restricted_code_units_calls_by_code_units_predicate(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses(ClassWithMethodAndConstructor.class, ClassCorrectlyCallingMethodAndConstructor.class, ClassWronglyCallingMethodAndConstructor.class)); @@ -466,17 +455,16 @@ public void restricted_code_units_calls_by_code_units_predicate(ArchRule rule) { quote(CONSTRUCTOR_ONE_ARG))); } - @DataProvider - public static Object[][] restricted_methods_calls_by_methods_rules() { - return $$( + static Stream restricted_methods_calls_by_methods_rules() { + return Stream.of( $(methods().should(onlyBeCalledByMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), $(methods().should().onlyBeCalled().byMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } - @Test - @UseDataProvider("restricted_methods_calls_by_methods_rules") - public void restricted_methods_calls_by_methods_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("restricted_methods_calls_by_methods_rules") + void restricted_methods_calls_by_methods_predicate(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses(ClassWithMethodAndConstructor.class, ClassCorrectlyCallingMethodAndConstructor.class, ClassWronglyCallingMethodAndConstructor.class)); @@ -494,17 +482,16 @@ public void restricted_methods_calls_by_methods_predicate(ArchRule rule) { quote(METHOD_ONE_ARG))); } - @DataProvider - public static Object[][] restricted_methods_calls_by_constructors_rules() { - return $$( + static Stream restricted_methods_calls_by_constructors_rules() { + return Stream.of( $(methods().should(onlyBeCalledByConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), $(methods().should().onlyBeCalled().byConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } - @Test - @UseDataProvider("restricted_methods_calls_by_constructors_rules") - public void restricted_methods_calls_by_constructors_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("restricted_methods_calls_by_constructors_rules") + void restricted_methods_calls_by_constructors_predicate(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses(ClassWithMethodAndConstructor.class, ClassCorrectlyCallingMethodAndConstructor.class, ClassWronglyCallingMethodAndConstructor.class)); @@ -522,17 +509,16 @@ public void restricted_methods_calls_by_constructors_predicate(ArchRule rule) { quote(METHOD_ONE_ARG))); } - @DataProvider - public static Object[][] restricted_methods_calls_by_code_units_rules() { - return $$( + static Stream restricted_methods_calls_by_code_units_rules() { + return Stream.of( $(methods().should(onlyBeCalledByCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), $(methods().should().onlyBeCalled().byCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } - @Test - @UseDataProvider("restricted_methods_calls_by_code_units_rules") - public void restricted_methods_calls_by_code_units_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("restricted_methods_calls_by_code_units_rules") + void restricted_methods_calls_by_code_units_predicate(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses(ClassWithMethodAndConstructor.class, ClassCorrectlyCallingMethodAndConstructor.class, ClassWronglyCallingMethodAndConstructor.class)); @@ -545,17 +531,16 @@ public void restricted_methods_calls_by_code_units_predicate(ArchRule rule) { quote(METHOD_ONE_ARG))); } - @DataProvider - public static Object[][] restricted_constructors_calls_by_methods_rules() { - return $$( + static Stream restricted_constructors_calls_by_methods_rules() { + return Stream.of( $(constructors().should(onlyBeCalledByMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), $(constructors().should().onlyBeCalled().byMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } - @Test - @UseDataProvider("restricted_constructors_calls_by_methods_rules") - public void restricted_constructors_calls_by_methods_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("restricted_constructors_calls_by_methods_rules") + void restricted_constructors_calls_by_methods_predicate(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses(ClassWithMethodAndConstructor.class, ClassCorrectlyCallingMethodAndConstructor.class, ClassWronglyCallingMethodAndConstructor.class)); @@ -573,17 +558,16 @@ public void restricted_constructors_calls_by_methods_predicate(ArchRule rule) { quote(CONSTRUCTOR_ONE_ARG))); } - @DataProvider - public static Object[][] restricted_constructors_calls_by_constructors_rules() { - return $$( + static Stream restricted_constructors_calls_by_constructors_rules() { + return Stream.of( $(constructors().should(onlyBeCalledByConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), $(constructors().should().onlyBeCalled().byConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } - @Test - @UseDataProvider("restricted_constructors_calls_by_constructors_rules") - public void restricted_constructors_calls_by_constructors_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("restricted_constructors_calls_by_constructors_rules") + void restricted_constructors_calls_by_constructors_predicate(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses(ClassWithMethodAndConstructor.class, ClassCorrectlyCallingMethodAndConstructor.class, ClassWronglyCallingMethodAndConstructor.class)); @@ -601,17 +585,16 @@ public void restricted_constructors_calls_by_constructors_predicate(ArchRule rul quote(CONSTRUCTOR_ONE_ARG))); } - @DataProvider - public static Object[][] restricted_constructors_calls_by_code_units_rules() { - return $$( + static Stream restricted_constructors_calls_by_code_units_rules() { + return Stream.of( $(constructors().should().onlyBeCalled().byCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))), $(constructors().should(onlyBeCalledByCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))) ); } - @Test - @UseDataProvider("restricted_constructors_calls_by_code_units_rules") - public void restricted_constructors_calls_by_code_units_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("restricted_constructors_calls_by_code_units_rules") + void restricted_constructors_calls_by_code_units_predicate(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses(ClassWithMethodAndConstructor.class, ClassCorrectlyCallingMethodAndConstructor.class, ClassWronglyCallingMethodAndConstructor.class)); diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/FieldsShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/FieldsShouldTest.java index 51604103fe..e556455277 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/FieldsShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/FieldsShouldTest.java @@ -4,16 +4,16 @@ import java.util.List; import java.util.Map; import java.util.Set; +import java.util.stream.Stream; import com.google.common.collect.ImmutableList; import com.tngtech.archunit.core.importer.ClassFileImporter; import com.tngtech.archunit.lang.ArchRule; import com.tngtech.archunit.lang.EvaluationResult; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.core.domain.JavaClass.Predicates.equivalentTo; @@ -26,13 +26,10 @@ import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.assertViolation; import static com.tngtech.archunit.lang.syntax.elements.MembersShouldTest.parseMembers; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; +import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.regex.Pattern.quote; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class FieldsShouldTest { @Test @@ -52,9 +49,8 @@ public void complex_field_syntax() { .containsPattern(String.format("%s.* is not annotated with @%s", FIELD_A, A.class.getSimpleName())); } - @DataProvider - public static Object[][] restricted_property_rule_ends() { - return $$( + static Stream restricted_property_rule_ends() { + return Stream.of( $(fields().should().haveRawType(String.class), ImmutableList.of(FIELD_B, FIELD_C, FIELD_D)), $(fields().should().haveRawType(String.class.getName()), ImmutableList.of(FIELD_B, FIELD_C, FIELD_D)), $(fields().should().haveRawType(equivalentTo(String.class).as(String.class.getName())), ImmutableList.of(FIELD_B, FIELD_C, FIELD_D)), @@ -68,9 +64,9 @@ public static Object[][] restricted_property_rule_ends() { ); } - @Test - @UseDataProvider("restricted_property_rule_ends") - public void property_predicates(ArchRule rule, Collection expectedViolatingFields) { + @ParameterizedTest + @MethodSource("restricted_property_rule_ends") + void property_predicates(ArchRule rule, Collection expectedViolatingFields) { EvaluationResult result = rule .evaluate(importClasses(ClassWithVariousMembers.class)); @@ -78,17 +74,16 @@ public void property_predicates(ArchRule rule, Collection expectedViolat assertThat(actualFields).hasSameElementsAs(expectedViolatingFields); } - @DataProvider - public static Object[][] data_be_accessed_by_methods() { - return testForEach( + static Stream be_accessed_by_methods() { + return Stream.of( fields().should().notBeAccessedByMethodsThat(have(name("toFind"))), noFields().should().beAccessedByMethodsThat(have(name("toFind"))) ); } - @Test - @UseDataProvider - public void test_be_accessed_by_methods(ArchRule ruleCheckingAccessToMethod) { + @ParameterizedTest + @MethodSource + void be_accessed_by_methods(ArchRule ruleCheckingAccessToMethod) { class ClassWithAccessedField { String field; } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassShouldTest.java index 9b25883183..152acac74b 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassShouldTest.java @@ -4,6 +4,7 @@ import java.util.Collection; import java.util.List; import java.util.regex.Pattern; +import java.util.stream.Stream; import com.tngtech.archunit.core.domain.JavaClasses; import com.tngtech.archunit.core.domain.JavaModifier; @@ -13,11 +14,9 @@ import com.tngtech.archunit.lang.conditions.ArchConditions; import com.tngtech.archunit.lang.syntax.elements.testclasses.ClassWithPublicAndPrivateConstructor; import com.tngtech.archunit.lang.syntax.elements.testclasses.SomeClass; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.core.domain.Formatters.joinSingleQuoted; import static com.tngtech.archunit.core.domain.JavaModifier.PUBLIC; @@ -34,19 +33,15 @@ import static com.tngtech.archunit.lang.syntax.elements.ClassesShouldTest.singleLineFailureReportOf; import static com.tngtech.archunit.testutil.Assertions.assertThat; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; +import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.regex.Pattern.quote; -@RunWith(DataProviderRunner.class) public class GivenClassShouldTest { private static final String ANY_NUMBER_OF_NON_NEWLINE_CHARS_REGEX = "[^" + FAILURE_REPORT_NEWLINE_MARKER + "]*"; - @DataProvider - public static Object[][] theClass_should_haveFullyQualifiedName_rules() { - return $$( + static Stream theClass_should_haveFullyQualifiedName_rules() { + return Stream.of( $(theClass(SomeClass.class).should().haveFullyQualifiedName(SomeClass.class.getName()), theClass(SomeClass.class).should().notHaveFullyQualifiedName(SomeClass.class.getName())), $(theClass(SomeClass.class).should(ArchConditions.haveFullyQualifiedName(SomeClass.class.getName())), @@ -58,9 +53,9 @@ public static Object[][] theClass_should_haveFullyQualifiedName_rules() { ); } - @Test - @UseDataProvider("theClass_should_haveFullyQualifiedName_rules") - public void theClass_should_haveFullyQualifiedName(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_haveFullyQualifiedName_rules") + void theClass_should_haveFullyQualifiedName(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class) .haveSuccessfulRuleText("the class %s should have fully qualified name '%s'", SomeClass.class.getName(), SomeClass.class.getName()) @@ -74,9 +69,8 @@ public void theClass_should_haveFullyQualifiedName(ArchRule satisfiedRule, ArchR .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_haveFullyQualifiedName_rules() { - return $$( + static Stream noClass_should_haveFullyQualifiedName_rules() { + return Stream.of( $(noClass(SomeClass.class).should().notHaveFullyQualifiedName(SomeClass.class.getName()), noClass(SomeClass.class).should().haveFullyQualifiedName(SomeClass.class.getName())), $(noClass(SomeClass.class).should(ArchConditions.notHaveFullyQualifiedName(SomeClass.class.getName())), @@ -88,9 +82,9 @@ public static Object[][] noClass_should_haveFullyQualifiedName_rules() { ); } - @Test - @UseDataProvider("noClass_should_haveFullyQualifiedName_rules") - public void noClass_should_haveFullyQualifiedName(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_haveFullyQualifiedName_rules") + void noClass_should_haveFullyQualifiedName(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class) .haveSuccessfulRuleText("no class %s should not have fully qualified name '%s'", SomeClass.class.getName(), SomeClass.class.getName()) @@ -103,9 +97,8 @@ public void noClass_should_haveFullyQualifiedName(ArchRule satisfiedRule, ArchRu .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_haveSimpleName_rules() { - return $$( + static Stream theClass_should_haveSimpleName_rules() { + return Stream.of( $(theClass(SomeClass.class).should().haveSimpleName(SomeClass.class.getSimpleName()), theClass(SomeClass.class).should().notHaveSimpleName(SomeClass.class.getSimpleName())), $(theClass(SomeClass.class).should(ArchConditions.haveSimpleName(SomeClass.class.getSimpleName())), @@ -117,9 +110,9 @@ public static Object[][] theClass_should_haveSimpleName_rules() { ); } - @Test - @UseDataProvider("theClass_should_haveSimpleName_rules") - public void haveSimpleName(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_haveSimpleName_rules") + void haveSimpleName(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class) .haveSuccessfulRuleText("the class %s should have simple name '%s'", SomeClass.class.getName(), SomeClass.class.getSimpleName()) @@ -132,9 +125,8 @@ public void haveSimpleName(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { .doNotContainFailureDetail(quote(Object.class.getSimpleName())); } - @DataProvider - public static Object[][] noClass_should_haveSimpleName_rules() { - return $$( + static Stream noClass_should_haveSimpleName_rules() { + return Stream.of( $(noClass(SomeClass.class).should().notHaveSimpleName(SomeClass.class.getSimpleName()), noClass(SomeClass.class).should().haveSimpleName(SomeClass.class.getSimpleName())), $(noClass(SomeClass.class).should(ArchConditions.notHaveSimpleName(SomeClass.class.getSimpleName())), @@ -146,9 +138,9 @@ public static Object[][] noClass_should_haveSimpleName_rules() { ); } - @Test - @UseDataProvider("noClass_should_haveSimpleName_rules") - public void noClass_should_haveSimpleName(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_haveSimpleName_rules") + void noClass_should_haveSimpleName(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class) .haveSuccessfulRuleText("no class %s should not have simple name '%s'", SomeClass.class.getName(), SomeClass.class.getSimpleName()) @@ -161,10 +153,9 @@ public void noClass_should_haveSimpleName(ArchRule satisfiedRule, ArchRule unsat .doNotContainFailureDetail(quote(Object.class.getSimpleName())); } - @DataProvider - public static Object[][] theClass_should_haveNameMatching_rules() { + static Stream theClass_should_haveNameMatching_rules() { String regex = containsPartOfRegex(SomeClass.class.getSimpleName()); - return $$( + return Stream.of( $(theClass(SomeClass.class).should().haveNameMatching(regex), theClass(SomeClass.class).should().haveNameNotMatching(regex)), $(theClass(SomeClass.class).should(ArchConditions.haveNameMatching(regex)), @@ -176,9 +167,9 @@ public static Object[][] theClass_should_haveNameMatching_rules() { ); } - @Test - @UseDataProvider("theClass_should_haveNameMatching_rules") - public void theClass_should_haveNameMatching(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_haveNameMatching_rules") + void theClass_should_haveNameMatching(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { String regex = containsPartOfRegex(SomeClass.class.getSimpleName()); assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class) @@ -193,10 +184,9 @@ public void theClass_should_haveNameMatching(ArchRule satisfiedRule, ArchRule un .doNotContainFailureDetail(quote(regex)); } - @DataProvider - public static Object[][] noClass_should_haveNameMatching_rules() { + static Stream noClass_should_haveNameMatching_rules() { String regex = containsPartOfRegex(SomeClass.class.getSimpleName()); - return $$( + return Stream.of( $(noClass(SomeClass.class).should().haveNameNotMatching(regex), noClass(SomeClass.class).should().haveNameMatching(regex)), $(noClass(SomeClass.class).should(ArchConditions.haveNameNotMatching(regex)), @@ -208,9 +198,9 @@ public static Object[][] noClass_should_haveNameMatching_rules() { ); } - @Test - @UseDataProvider("noClass_should_haveNameMatching_rules") - public void noClass_should_haveNameMatching(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_haveNameMatching_rules") + void noClass_should_haveNameMatching(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { String regex = containsPartOfRegex(SomeClass.class.getSimpleName()); assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class) @@ -225,11 +215,10 @@ public void noClass_should_haveNameMatching(ArchRule satisfiedRule, ArchRule uns .doNotContainFailureDetail(quote(regex)); } - @DataProvider - public static Object[][] theClass_should_haveSimpleNameStartingWith_rules() { + static Stream theClass_should_haveSimpleNameStartingWith_rules() { String simpleName = SomeClass.class.getSimpleName(); String prefix = simpleName.substring(0, simpleName.length() - 1); - return $$( + return Stream.of( $(theClass(SomeClass.class).should().haveSimpleNameStartingWith(prefix), theClass(SomeClass.class).should().haveSimpleNameNotStartingWith(prefix)), $(theClass(SomeClass.class).should(ArchConditions.haveSimpleNameStartingWith(prefix)), @@ -241,9 +230,9 @@ public static Object[][] theClass_should_haveSimpleNameStartingWith_rules() { ); } - @Test - @UseDataProvider("theClass_should_haveSimpleNameStartingWith_rules") - public void theClass_should_haveSimpleNameStartingWith(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_haveSimpleNameStartingWith_rules") + 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) @@ -258,12 +247,10 @@ public void theClass_should_haveSimpleNameStartingWith(ArchRule satisfiedRule, A .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_haveSimpleNameStartingWith_rules() { - + static Stream noClass_should_haveSimpleNameStartingWith_rules() { String simpleName = SomeClass.class.getSimpleName(); String prefix = simpleName.substring(0, simpleName.length() - 1); - return $$( + return Stream.of( $(noClass(SomeClass.class).should().haveSimpleNameNotStartingWith(prefix), noClass(SomeClass.class).should().haveSimpleNameStartingWith(prefix)), $(noClass(SomeClass.class).should(ArchConditions.haveSimpleNameNotStartingWith(prefix)), @@ -275,9 +262,9 @@ public static Object[][] noClass_should_haveSimpleNameStartingWith_rules() { ); } - @Test - @UseDataProvider("noClass_should_haveSimpleNameStartingWith_rules") - public void noClass_should_haveSimpleNameStartingWith(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_haveSimpleNameStartingWith_rules") + void noClass_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) @@ -292,12 +279,10 @@ public void noClass_should_haveSimpleNameStartingWith(ArchRule satisfiedRule, Ar .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_haveSimpleNameContaining_rules() { + static Stream theClass_should_haveSimpleNameContaining_rules() { String simpleName = SomeClass.class.getSimpleName(); String infix = simpleName.substring(1, simpleName.length() - 1); - - return $$( + return Stream.of( $(theClass(SomeClass.class).should().haveSimpleNameContaining(infix), theClass(SomeClass.class).should().haveSimpleNameNotContaining(infix)), $(theClass(SomeClass.class).should(ArchConditions.haveSimpleNameContaining(infix)), @@ -309,9 +294,9 @@ public static Object[][] theClass_should_haveSimpleNameContaining_rules() { ); } - @Test - @UseDataProvider("theClass_should_haveSimpleNameContaining_rules") - public void theClass_should_haveSimpleNameContaining(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_haveSimpleNameContaining_rules") + 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) @@ -326,12 +311,10 @@ public void theClass_should_haveSimpleNameContaining(ArchRule satisfiedRule, Arc .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_haveSimpleNameContaining_rules() { - + static Stream noClass_should_haveSimpleNameContaining_rules() { String simpleName = SomeClass.class.getSimpleName(); String infix = simpleName.substring(1, simpleName.length() - 1); - return $$( + return Stream.of( $(noClass(SomeClass.class).should().haveSimpleNameNotContaining(infix), noClass(SomeClass.class).should().haveSimpleNameContaining(infix)), $(noClass(SomeClass.class).should(ArchConditions.haveSimpleNameNotContaining(infix)), @@ -343,9 +326,9 @@ public static Object[][] noClass_should_haveSimpleNameContaining_rules() { ); } - @Test - @UseDataProvider("noClass_should_haveSimpleNameContaining_rules") - public void noClass_should_haveSimpleNameContaining(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_haveSimpleNameContaining_rules") + void noClass_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) @@ -360,12 +343,11 @@ public void noClass_should_haveSimpleNameContaining(ArchRule satisfiedRule, Arch .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_haveSimpleNameEndingWith_rules() { + static Stream theClass_should_haveSimpleNameEndingWith_rules() { String simpleName = SomeClass.class.getSimpleName(); String suffix = simpleName.substring(1); - return $$( + return Stream.of( $(theClass(SomeClass.class).should().haveSimpleNameEndingWith(suffix), theClass(SomeClass.class).should().haveSimpleNameNotEndingWith(suffix)), $(theClass(SomeClass.class).should(ArchConditions.haveSimpleNameEndingWith(suffix)), @@ -377,9 +359,9 @@ public static Object[][] theClass_should_haveSimpleNameEndingWith_rules() { ); } - @Test - @UseDataProvider("theClass_should_haveSimpleNameEndingWith_rules") - public void theClass_should_haveSimpleNameEndingWith(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_haveSimpleNameEndingWith_rules") + void theClass_should_haveSimpleNameEndingWith(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { String simpleName = SomeClass.class.getSimpleName(); String suffix = simpleName.substring(1); assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class) @@ -394,12 +376,10 @@ public void theClass_should_haveSimpleNameEndingWith(ArchRule satisfiedRule, Arc .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_haveSimpleNameEndingWith_rules() { - + static Stream noClass_should_haveSimpleNameEndingWith_rules() { String simpleName = SomeClass.class.getSimpleName(); String suffix = simpleName.substring(1); - return $$( + return Stream.of( $(noClass(SomeClass.class).should().haveSimpleNameNotEndingWith(suffix), noClass(SomeClass.class).should().haveSimpleNameEndingWith(suffix)), $(noClass(SomeClass.class).should(ArchConditions.haveSimpleNameNotEndingWith(suffix)), @@ -411,9 +391,9 @@ public static Object[][] noClass_should_haveSimpleNameEndingWith_rules() { ); } - @Test - @UseDataProvider("noClass_should_haveSimpleNameEndingWith_rules") - public void noClass_should_haveSimpleNameEndingWith(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_haveSimpleNameEndingWith_rules") + void noClass_should_haveSimpleNameEndingWith(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { String simpleName = SomeClass.class.getSimpleName(); String suffix = simpleName.substring(1); assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class) @@ -428,10 +408,9 @@ public void noClass_should_haveSimpleNameEndingWith(ArchRule satisfiedRule, Arch .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_resideInAPackage_rules() { + static Stream theClass_should_resideInAPackage_rules() { String thePackage = SomeClass.class.getPackage().getName(); - return $$( + return Stream.of( $(theClass(SomeClass.class).should().resideInAPackage(thePackage), theClass(SomeClass.class).should().resideOutsideOfPackage(thePackage)), $(theClass(SomeClass.class).should(ArchConditions.resideInAPackage(thePackage)), @@ -443,9 +422,9 @@ public static Object[][] theClass_should_resideInAPackage_rules() { ); } - @Test - @UseDataProvider("theClass_should_resideInAPackage_rules") - public void theClass_should_resideInAPackage(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_resideInAPackage_rules") + void theClass_should_resideInAPackage(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { String thePackage = SomeClass.class.getPackage().getName(); assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class) .haveSuccessfulRuleText("the class %s should reside in a package '%s'", @@ -459,10 +438,9 @@ public void theClass_should_resideInAPackage(ArchRule satisfiedRule, ArchRule un .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_resideInAPackage_rules() { + static Stream noClass_should_resideInAPackage_rules() { String thePackage = SomeClass.class.getPackage().getName(); - return $$( + return Stream.of( $(noClass(SomeClass.class).should().resideOutsideOfPackage(thePackage), noClass(SomeClass.class).should().resideInAPackage(thePackage)), $(noClass(SomeClass.class).should(ArchConditions.resideOutsideOfPackage(thePackage)), @@ -474,9 +452,9 @@ public static Object[][] noClass_should_resideInAPackage_rules() { ); } - @Test - @UseDataProvider("noClass_should_resideInAPackage_rules") - public void noClass_should_resideInAPackage(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_resideInAPackage_rules") + void noClass_should_resideInAPackage(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { String thePackage = SomeClass.class.getPackage().getName(); assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class) @@ -491,12 +469,10 @@ public void noClass_should_resideInAPackage(ArchRule satisfiedRule, ArchRule uns .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_resideInAnyPackage_rules() { - + static Stream theClass_should_resideInAnyPackage_rules() { String firstPackage = SomeClass.class.getPackage().getName(); String secondPackage = Object.class.getPackage().getName(); - return $$( + return Stream.of( $(theClass(SomeClass.class).should().resideInAnyPackage(firstPackage, secondPackage), theClass(SomeClass.class).should().resideOutsideOfPackages(firstPackage, secondPackage)), $(theClass(SomeClass.class).should(ArchConditions.resideInAnyPackage(firstPackage, secondPackage)), @@ -508,9 +484,9 @@ public static Object[][] theClass_should_resideInAnyPackage_rules() { ); } - @Test - @UseDataProvider("theClass_should_resideInAnyPackage_rules") - public void theClass_should_resideInAnyPackage(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_resideInAnyPackage_rules") + void theClass_should_resideInAnyPackage(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { String firstPackage = SomeClass.class.getPackage().getName(); String secondPackage = Object.class.getPackage().getName(); String[] packageIdentifiers = {firstPackage, secondPackage}; @@ -529,12 +505,11 @@ public void theClass_should_resideInAnyPackage(ArchRule satisfiedRule, ArchRule .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_resideInAnyPackage_rules() { + static Stream noClass_should_resideInAnyPackage_rules() { String firstPackage = SomeClass.class.getPackage().getName(); String secondPackage = Object.class.getPackage().getName(); - return $$( + return Stream.of( $(noClass(SomeClass.class).should().resideOutsideOfPackages(firstPackage, secondPackage), noClass(SomeClass.class).should().resideInAnyPackage(firstPackage, secondPackage)), $(noClass(SomeClass.class).should(ArchConditions.resideOutsideOfPackages(firstPackage, secondPackage)), @@ -546,9 +521,9 @@ public static Object[][] noClass_should_resideInAnyPackage_rules() { ); } - @Test - @UseDataProvider("noClass_should_resideInAnyPackage_rules") - public void noClass_should_resideInAnyPackage(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_resideInAnyPackage_rules") + void noClass_should_resideInAnyPackage(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { String firstPackage = SomeClass.class.getPackage().getName(); String secondPackage = Object.class.getPackage().getName(); String[] packageIdentifiers = {firstPackage, secondPackage}; @@ -567,9 +542,8 @@ public void noClass_should_resideInAnyPackage(ArchRule satisfiedRule, ArchRule u .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_bePublic_rules() { - return $$( + static Stream theClass_should_bePublic_rules() { + return Stream.of( $(theClass(SomeClass.class).should().bePublic(), theClass(SomeClass.class).should().notBePublic()), $(theClass(SomeClass.class).should(ArchConditions.bePublic()), @@ -581,9 +555,9 @@ public static Object[][] theClass_should_bePublic_rules() { ); } - @Test - @UseDataProvider("theClass_should_bePublic_rules") - public void theClass_should_bePublic(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_bePublic_rules") + void theClass_should_bePublic(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class) .haveSuccessfulRuleText("the class %s should be public", SomeClass.class.getName()) @@ -596,9 +570,8 @@ public void theClass_should_bePublic(ArchRule satisfiedRule, ArchRule unsatisfie .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_bePublic_rules() { - return $$( + static Stream noClass_should_bePublic_rules() { + return Stream.of( $(noClass(SomeClass.class).should().notBePublic(), noClass(SomeClass.class).should().bePublic()), $(noClass(SomeClass.class).should(ArchConditions.notBePublic()), @@ -610,9 +583,9 @@ public static Object[][] noClass_should_bePublic_rules() { ); } - @Test - @UseDataProvider("noClass_should_bePublic_rules") - public void noClass_should_bePublic(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_bePublic_rules") + void noClass_should_bePublic(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, SomeClass.class, Object.class) .haveSuccessfulRuleText("no class %s should not be public", SomeClass.class.getName()) @@ -625,9 +598,8 @@ public void noClass_should_bePublic(ArchRule satisfiedRule, ArchRule unsatisfied .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_bePrivate_rules() { - return $$( + static Stream theClass_should_bePrivate_rules() { + return Stream.of( $(theClass(PrivateClass.class).should().bePrivate(), theClass(PrivateClass.class).should().notBePrivate()), $(theClass(PrivateClass.class).should(ArchConditions.bePrivate()), @@ -639,9 +611,9 @@ public static Object[][] theClass_should_bePrivate_rules() { ); } - @Test - @UseDataProvider("theClass_should_bePrivate_rules") - public void theClass_should_bePrivate(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_bePrivate_rules") + void theClass_should_bePrivate(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, PrivateClass.class, Object.class) .haveSuccessfulRuleText("the class %s should be private", PrivateClass.class.getName()) @@ -654,9 +626,8 @@ public void theClass_should_bePrivate(ArchRule satisfiedRule, ArchRule unsatisfi .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_bePrivate_rules() { - return $$( + static Stream noClass_should_bePrivate_rules() { + return Stream.of( $(noClass(PrivateClass.class).should().notBePrivate(), noClass(PrivateClass.class).should().bePrivate()), $(noClass(PrivateClass.class).should(ArchConditions.notBePrivate()), @@ -668,9 +639,9 @@ public static Object[][] noClass_should_bePrivate_rules() { ); } - @Test - @UseDataProvider("noClass_should_bePrivate_rules") - public void noClass_should_bePrivate(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_bePrivate_rules") + void noClass_should_bePrivate(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, PrivateClass.class, Object.class) .haveSuccessfulRuleText("no class %s should not be private", PrivateClass.class.getName()) @@ -683,9 +654,8 @@ public void noClass_should_bePrivate(ArchRule satisfiedRule, ArchRule unsatisfie .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_haveOnlyFinalFields_rules() { - return $$( + static Stream theClass_should_haveOnlyFinalFields_rules() { + return Stream.of( $(theClass(ClassWithFinalFields.class).should().haveOnlyFinalFields(), theClass(ClassWithNonFinalFields.class).should().haveOnlyFinalFields()), $(theClass(ClassWithFinalFields.class).should(ArchConditions.haveOnlyFinalFields()), @@ -697,9 +667,9 @@ public static Object[][] theClass_should_haveOnlyFinalFields_rules() { ); } - @Test - @UseDataProvider("theClass_should_haveOnlyFinalFields_rules") - public void theClass_should_haveOnlyFinalFields(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_haveOnlyFinalFields_rules") + 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()) @@ -714,9 +684,8 @@ public void theClass_should_haveOnlyFinalFields(ArchRule satisfiedRule, ArchRule .doNotContainFailureDetail(quote(ClassWithFinalFields.class.getName())); } - @DataProvider - public static Object[][] noClass_should_haveOnlyFinalFields_rules() { - return $$( + static Stream noClass_should_haveOnlyFinalFields_rules() { + return Stream.of( $(noClass(ClassWithNonFinalFields.class).should().haveOnlyFinalFields(), noClass(ClassWithFinalFields.class).should().haveOnlyFinalFields()), $(noClass(ClassWithNonFinalFields.class).should(ArchConditions.haveOnlyFinalFields()), @@ -728,9 +697,9 @@ public static Object[][] noClass_should_haveOnlyFinalFields_rules() { ); } - @Test - @UseDataProvider("noClass_should_haveOnlyFinalFields_rules") - public void noClass_should_haveOnlyFinalFields(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_haveOnlyFinalFields_rules") + void noClass_should_haveOnlyFinalFields(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, ClassWithFinalFields.class, ClassWithNonFinalFields.class) .haveSuccessfulRuleText("no class %s should have only final fields", ClassWithNonFinalFields.class.getName()) @@ -742,16 +711,15 @@ public void noClass_should_haveOnlyFinalFields(ArchRule satisfiedRule, ArchRule .doNotContainFailureDetail(quote(ClassWithNonFinalFields.class.getName())); } - @DataProvider - public static Object[][] classes_should_have_only_private_constructor_rules() { - return testForEach( + static Stream classes_should_have_only_private_constructor_rules() { + return Stream.of( classes().should().haveOnlyPrivateConstructors(), classes().should(haveOnlyPrivateConstructors())); } - @Test - @UseDataProvider("classes_should_have_only_private_constructor_rules") - public void classes_should_have_only_private_constructor(ArchRule rule) { + @ParameterizedTest + @MethodSource("classes_should_have_only_private_constructor_rules") + void classes_should_have_only_private_constructor(ArchRule rule) { assertThatRule(rule).hasDescriptionContaining("classes should have only private constructors"); assertThatRule(rule).checking(importClasses(ClassWithPrivateConstructors.class)) .hasNoViolation(); @@ -761,9 +729,8 @@ public void classes_should_have_only_private_constructor(ArchRule rule) { ClassWithPublicAndPrivateConstructor.class.getSimpleName(), 5)); } - @DataProvider - public static Object[][] theClass_should_beProtected_rules() { - return $$( + static Stream theClass_should_beProtected_rules() { + return Stream.of( $(theClass(ProtectedClass.class).should().beProtected(), theClass(ProtectedClass.class).should().notBeProtected()), $(theClass(ProtectedClass.class).should(ArchConditions.beProtected()), @@ -775,9 +742,9 @@ public static Object[][] theClass_should_beProtected_rules() { ); } - @Test - @UseDataProvider("theClass_should_beProtected_rules") - public void theClass_should_beProtected(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_beProtected_rules") + void theClass_should_beProtected(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, ProtectedClass.class, Object.class) .haveSuccessfulRuleText("the class %s should be protected", ProtectedClass.class.getName()) @@ -790,9 +757,8 @@ public void theClass_should_beProtected(ArchRule satisfiedRule, ArchRule unsatis .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_beProtected_rules() { - return $$( + static Stream noClass_should_beProtected_rules() { + return Stream.of( $(noClass(ProtectedClass.class).should().notBeProtected(), noClass(ProtectedClass.class).should().beProtected()), $(noClass(ProtectedClass.class).should(ArchConditions.notBeProtected()), @@ -804,9 +770,9 @@ public static Object[][] noClass_should_beProtected_rules() { ); } - @Test - @UseDataProvider("noClass_should_beProtected_rules") - public void noClass_should_beProtected(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_beProtected_rules") + void noClass_should_beProtected(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, ProtectedClass.class, Object.class) .haveSuccessfulRuleText("no class %s should not be protected", ProtectedClass.class.getName()) @@ -819,9 +785,8 @@ public void noClass_should_beProtected(ArchRule satisfiedRule, ArchRule unsatisf .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_bePackagePrivate_rules() { - return $$( + static Stream theClass_should_bePackagePrivate_rules() { + return Stream.of( $(theClass(PackagePrivateClass.class).should().bePackagePrivate(), theClass(PackagePrivateClass.class).should().notBePackagePrivate()), $(theClass(PackagePrivateClass.class).should(ArchConditions.bePackagePrivate()), @@ -833,9 +798,9 @@ public static Object[][] theClass_should_bePackagePrivate_rules() { ); } - @Test - @UseDataProvider("theClass_should_bePackagePrivate_rules") - public void theClass_should_bePackagePrivate(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_bePackagePrivate_rules") + void theClass_should_bePackagePrivate(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, PackagePrivateClass.class, Object.class) .haveSuccessfulRuleText("the class %s should be package private", PackagePrivateClass.class.getName()) @@ -856,9 +821,8 @@ public void theClass_should_bePackagePrivate(ArchRule satisfiedRule, ArchRule un .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_bePackagePrivate_rules() { - return $$( + static Stream noClass_should_bePackagePrivate_rules() { + return Stream.of( $(noClass(PackagePrivateClass.class).should().notBePackagePrivate(), noClass(PackagePrivateClass.class).should().bePackagePrivate()), $(noClass(PackagePrivateClass.class).should(ArchConditions.notBePackagePrivate()), @@ -870,9 +834,9 @@ public static Object[][] noClass_should_bePackagePrivate_rules() { ); } - @Test - @UseDataProvider("noClass_should_bePackagePrivate_rules") - public void noClass_should_bePackagePrivate(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_bePackagePrivate_rules") + void noClass_should_bePackagePrivate(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, PackagePrivateClass.class, Object.class) .haveSuccessfulRuleText("no class %s should not be package private", PackagePrivateClass.class.getName()) @@ -893,9 +857,8 @@ public void noClass_should_bePackagePrivate(ArchRule satisfiedRule, ArchRule uns .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_haveModifier_public_rules() { - return $$( + static Stream theClass_should_haveModifier_public_rules() { + return Stream.of( $(theClass(PublicClass.class).should().haveModifier(PUBLIC), theClass(PublicClass.class).should().notHaveModifier(PUBLIC)), $(theClass(PublicClass.class).should(ArchConditions.haveModifier(PUBLIC)), @@ -907,9 +870,9 @@ public static Object[][] theClass_should_haveModifier_public_rules() { ); } - @Test - @UseDataProvider("theClass_should_haveModifier_public_rules") - public void theClass_should_haveModifier_public(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_haveModifier_public_rules") + void theClass_should_haveModifier_public(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, PublicClass.class, Object.class) .haveSuccessfulRuleText("the class %s should have modifier %s", PublicClass.class.getName(), PUBLIC) @@ -922,9 +885,8 @@ public void theClass_should_haveModifier_public(ArchRule satisfiedRule, ArchRule .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_haveModifier_public_rules() { - return $$( + static Stream noClass_should_haveModifier_public_rules() { + return Stream.of( $(noClass(PublicClass.class).should().notHaveModifier(PUBLIC), noClass(PublicClass.class).should().haveModifier(PUBLIC)), $(noClass(PublicClass.class).should(ArchConditions.notHaveModifier(PUBLIC)), @@ -936,9 +898,9 @@ public static Object[][] noClass_should_haveModifier_public_rules() { ); } - @Test - @UseDataProvider("noClass_should_haveModifier_public_rules") - public void noClass_should_haveModifier_public(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_haveModifier_public_rules") + void noClass_should_haveModifier_public(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, PublicClass.class, Object.class) .haveSuccessfulRuleText("no class %s should not have modifier %s", PublicClass.class.getName(), PUBLIC) @@ -951,9 +913,8 @@ public void noClass_should_haveModifier_public(ArchRule satisfiedRule, ArchRule .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_beAnnotatedWith_rules() { - return $$( + static Stream theClass_should_beAnnotatedWith_rules() { + return Stream.of( $(theClass(SomeAnnotatedClass.class).should().beAnnotatedWith(RuntimeRetentionAnnotation.class), theClass(SomeAnnotatedClass.class).should().notBeAnnotatedWith(RuntimeRetentionAnnotation.class)), $(theClass(SomeAnnotatedClass.class).should(ArchConditions.beAnnotatedWith(RuntimeRetentionAnnotation.class)), @@ -965,9 +926,9 @@ public static Object[][] theClass_should_beAnnotatedWith_rules() { ); } - @Test - @UseDataProvider("theClass_should_beAnnotatedWith_rules") - public void theClass_should_beAnnotatedWith(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_beAnnotatedWith_rules") + void theClass_should_beAnnotatedWith(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, SomeAnnotatedClass.class, Object.class) .haveSuccessfulRuleText("the class %s should be annotated with @%s", SomeAnnotatedClass.class.getName(), RuntimeRetentionAnnotation.class.getSimpleName()) @@ -980,9 +941,8 @@ public void theClass_should_beAnnotatedWith(ArchRule satisfiedRule, ArchRule uns .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_beAnnotatedWith_rules() { - return $$( + static Stream noClass_should_beAnnotatedWith_rules() { + return Stream.of( $(noClass(SomeAnnotatedClass.class).should().notBeAnnotatedWith(RuntimeRetentionAnnotation.class), noClass(SomeAnnotatedClass.class).should().beAnnotatedWith(RuntimeRetentionAnnotation.class)), $(noClass(SomeAnnotatedClass.class).should(ArchConditions.notBeAnnotatedWith(RuntimeRetentionAnnotation.class)), @@ -994,9 +954,9 @@ public static Object[][] noClass_should_beAnnotatedWith_rules() { ); } - @Test - @UseDataProvider("noClass_should_beAnnotatedWith_rules") - public void noClass_should_beAnnotatedWith(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_beAnnotatedWith_rules") + void noClass_should_beAnnotatedWith(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, SomeAnnotatedClass.class, Object.class) .haveSuccessfulRuleText("no class %s should not be annotated with @%s", SomeAnnotatedClass.class.getName(), RuntimeRetentionAnnotation.class.getSimpleName()) @@ -1009,9 +969,8 @@ public void noClass_should_beAnnotatedWith(ArchRule satisfiedRule, ArchRule unsa .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_implement_rules() { - return $$( + static Stream theClass_should_implement_rules() { + return Stream.of( $(theClass(ArrayList.class).should().implement(Collection.class), theClass(ArrayList.class).should().notImplement(Collection.class)), $(theClass(ArrayList.class).should(ArchConditions.implement(Collection.class)), @@ -1023,9 +982,9 @@ public static Object[][] theClass_should_implement_rules() { ); } - @Test - @UseDataProvider("theClass_should_implement_rules") - public void theClass_should_implement(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_implement_rules") + void theClass_should_implement(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, ArrayList.class, Object.class) .haveSuccessfulRuleText("the class %s should implement %s", ArrayList.class.getName(), Collection.class.getName()) @@ -1038,9 +997,8 @@ public void theClass_should_implement(ArchRule satisfiedRule, ArchRule unsatisfi .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_implement_rules() { - return $$( + static Stream noClass_should_implement_rules() { + return Stream.of( $(noClass(ArrayList.class).should().notImplement(Collection.class), noClass(ArrayList.class).should().implement(Collection.class)), $(noClass(ArrayList.class).should(ArchConditions.notImplement(Collection.class)), @@ -1052,9 +1010,9 @@ public static Object[][] noClass_should_implement_rules() { ); } - @Test - @UseDataProvider("noClass_should_implement_rules") - public void noClass_should_implement(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_implement_rules") + void noClass_should_implement(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, ArrayList.class, Object.class) .haveSuccessfulRuleText("no class %s should not implement %s", ArrayList.class.getName(), Collection.class.getName()) @@ -1067,9 +1025,8 @@ public void noClass_should_implement(ArchRule satisfiedRule, ArchRule unsatisfie .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_beAssignableTo_rules() { - return $$( + static Stream theClass_should_beAssignableTo_rules() { + return Stream.of( $(theClass(List.class).should().beAssignableTo(Collection.class), theClass(List.class).should().notBeAssignableTo(Collection.class)), $(theClass(List.class).should(ArchConditions.beAssignableTo(Collection.class)), @@ -1081,9 +1038,9 @@ public static Object[][] theClass_should_beAssignableTo_rules() { ); } - @Test - @UseDataProvider("theClass_should_beAssignableTo_rules") - public void theClass_should_beAssignableTo(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_beAssignableTo_rules") + void theClass_should_beAssignableTo(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, List.class, Collection.class) .haveSuccessfulRuleText("the class %s should be assignable to %s", List.class.getName(), Collection.class.getName()) @@ -1096,9 +1053,8 @@ public void theClass_should_beAssignableTo(ArchRule satisfiedRule, ArchRule unsa .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_beAssignableTo_rules() { - return $$( + static Stream noClass_should_beAssignableTo_rules() { + return Stream.of( $(noClass(List.class).should().notBeAssignableTo(Collection.class), noClass(List.class).should().beAssignableTo(Collection.class)), $(noClass(List.class).should(ArchConditions.notBeAssignableTo(Collection.class)), @@ -1110,9 +1066,9 @@ public static Object[][] noClass_should_beAssignableTo_rules() { ); } - @Test - @UseDataProvider("noClass_should_beAssignableTo_rules") - public void noClass_should_beAssignableTo(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_beAssignableTo_rules") + void noClass_should_beAssignableTo(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, List.class, Collection.class) .haveSuccessfulRuleText("no class %s should not be assignable to %s", List.class.getName(), Collection.class.getName()) @@ -1125,9 +1081,8 @@ public void noClass_should_beAssignableTo(ArchRule satisfiedRule, ArchRule unsat .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_beAssignableFrom_rules() { - return $$( + static Stream theClass_should_beAssignableFrom_rules() { + return Stream.of( $(theClass(Collection.class).should().beAssignableFrom(List.class), theClass(Collection.class).should().notBeAssignableFrom(List.class)), $(theClass(Collection.class).should(ArchConditions.beAssignableFrom(List.class)), @@ -1139,9 +1094,9 @@ public static Object[][] theClass_should_beAssignableFrom_rules() { ); } - @Test - @UseDataProvider("theClass_should_beAssignableFrom_rules") - public void theClass_should_beAssignableFrom(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_beAssignableFrom_rules") + void theClass_should_beAssignableFrom(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, Collection.class, List.class) .haveSuccessfulRuleText("the class %s should be assignable from %s", Collection.class.getName(), List.class.getName()) @@ -1154,9 +1109,8 @@ public void theClass_should_beAssignableFrom(ArchRule satisfiedRule, ArchRule un .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] noClass_should_beAssignableFrom_rules() { - return $$( + static Stream noClass_should_beAssignableFrom_rules() { + return Stream.of( $(noClass(Collection.class).should().notBeAssignableFrom(List.class), noClass(Collection.class).should().beAssignableFrom(List.class)), $(noClass(Collection.class).should(ArchConditions.notBeAssignableFrom(List.class)), @@ -1168,9 +1122,9 @@ public static Object[][] noClass_should_beAssignableFrom_rules() { ); } - @Test - @UseDataProvider("noClass_should_beAssignableFrom_rules") - public void noClass_should_beAssignableFrom(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_beAssignableFrom_rules") + void noClass_should_beAssignableFrom(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, Collection.class, List.class) .haveSuccessfulRuleText("no class %s should not be assignable from %s", Collection.class.getName(), List.class.getName()) @@ -1183,9 +1137,8 @@ public void noClass_should_beAssignableFrom(ArchRule satisfiedRule, ArchRule uns .doNotContainFailureDetail(quote(Object.class.getName())); } - @DataProvider - public static Object[][] theClass_should_getField_rules() { - return $$( + static Stream theClass_should_getField_rules() { + return Stream.of( $(theClass(ClassAccessingField.class).should().getField(ClassWithField.class, "field"), theClass(ClassAccessingWrongField.class).should().getField(ClassWithField.class, "field")), $(theClass(ClassAccessingField.class).should(ArchConditions.getField(ClassWithField.class, "field")), @@ -1197,9 +1150,9 @@ public static Object[][] theClass_should_getField_rules() { ); } - @Test - @UseDataProvider("theClass_should_getField_rules") - public void theClass_should_getField(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_getField_rules") + 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") @@ -1211,9 +1164,8 @@ public void theClass_should_getField(ArchRule satisfiedRule, ArchRule unsatisfie .doNotContainFailureDetail(quote(ClassAccessingField.class.getName()) + ANY_NUMBER_OF_NON_NEWLINE_CHARS_REGEX + "get"); } - @DataProvider - public static Object[][] noClass_should_getField_rules() { - return $$( + static Stream noClass_should_getField_rules() { + return Stream.of( $(noClass(ClassAccessingWrongField.class).should().getField(ClassWithField.class, "field"), noClass(ClassAccessingField.class).should().getField(ClassWithField.class, "field")), $(noClass(ClassAccessingWrongField.class).should(ArchConditions.getField(ClassWithField.class, "field")), @@ -1225,9 +1177,9 @@ public static Object[][] noClass_should_getField_rules() { ); } - @Test - @UseDataProvider("noClass_should_getField_rules") - public void noClass_should_getField(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_getField_rules") + void noClass_should_getField(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, ClassWithField.class, ClassAccessingWrongField.class, ClassAccessingField.class) .haveSuccessfulRuleText("no class %s should get field %s.%s", ClassAccessingWrongField.class.getName(), ClassWithField.class.getSimpleName(), "field") @@ -1239,9 +1191,8 @@ public void noClass_should_getField(ArchRule satisfiedRule, ArchRule unsatisfied .doNotContainFailureDetail(quote(ClassAccessingWrongField.class.getName())); } - @DataProvider - public static Object[][] theClass_should_accessField_rules() { - return $$( + static Stream theClass_should_accessField_rules() { + return Stream.of( $(theClass(ClassAccessingField.class).should().accessField(ClassWithField.class, "field"), theClass(ClassAccessingWrongField.class).should().accessField(ClassWithField.class, "field")), $(theClass(ClassAccessingField.class).should(ArchConditions.accessField(ClassWithField.class, "field")), @@ -1253,9 +1204,9 @@ public static Object[][] theClass_should_accessField_rules() { ); } - @Test - @UseDataProvider("theClass_should_accessField_rules") - public void theClass_should_accessField(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_accessField_rules") + 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") @@ -1267,9 +1218,8 @@ public void theClass_should_accessField(ArchRule satisfiedRule, ArchRule unsatis .doNotContainFailureDetail(quote(ClassAccessingField.class.getName()) + ANY_NUMBER_OF_NON_NEWLINE_CHARS_REGEX + "accesses"); } - @DataProvider - public static Object[][] noClass_should_accessField_rules() { - return $$( + static Stream noClass_should_accessField_rules() { + return Stream.of( $(noClass(ClassAccessingWrongField.class).should().accessField(ClassWithField.class, "field"), noClass(ClassAccessingField.class).should().accessField(ClassWithField.class, "field")), $(noClass(ClassAccessingWrongField.class).should(ArchConditions.accessField(ClassWithField.class, "field")), @@ -1281,9 +1231,9 @@ public static Object[][] noClass_should_accessField_rules() { ); } - @Test - @UseDataProvider("noClass_should_accessField_rules") - public void noClass_should_accessField(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_accessField_rules") + void noClass_should_accessField(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, ClassWithField.class, ClassAccessingWrongField.class, ClassAccessingField.class) .haveSuccessfulRuleText("no class %s should access field %s.%s", ClassAccessingWrongField.class.getName(), ClassWithField.class.getSimpleName(), "field") @@ -1295,9 +1245,8 @@ public void noClass_should_accessField(ArchRule satisfiedRule, ArchRule unsatisf .doNotContainFailureDetail(quote(ClassAccessingWrongField.class.getName())); } - @DataProvider - public static Object[][] theClass_should_getFieldWhere_rules() { - return $$( + static Stream theClass_should_getFieldWhere_rules() { + return Stream.of( $(theClass(ClassAccessingField.class).should().getFieldWhere(accessTargetIs(ClassWithField.class)), theClass(ClassAccessingWrongField.class).should().getFieldWhere(accessTargetIs(ClassWithField.class))), $(theClass(ClassAccessingField.class).should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class))), @@ -1309,9 +1258,9 @@ public static Object[][] theClass_should_getFieldWhere_rules() { ); } - @Test - @UseDataProvider("theClass_should_getFieldWhere_rules") - public void theClass_should_getFieldWhere(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_getFieldWhere_rules") + void theClass_should_getFieldWhere(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, ClassWithField.class, ClassAccessingWrongField.class, ClassAccessingField.class) .haveSuccessfulRuleText("the class %s should get field where target is %s", ClassAccessingField.class.getName(), ClassWithField.class.getSimpleName()) @@ -1323,9 +1272,8 @@ public void theClass_should_getFieldWhere(ArchRule satisfiedRule, ArchRule unsat .doNotContainFailureDetail(quote(ClassAccessingField.class.getSimpleName()) + ".*accesses"); } - @DataProvider - public static Object[][] noClass_should_getFieldWhere_rules() { - return $$( + static Stream noClass_should_getFieldWhere_rules() { + return Stream.of( $(noClass(ClassAccessingWrongField.class).should().getFieldWhere(accessTargetIs(ClassWithField.class)), noClass(ClassAccessingField.class).should().getFieldWhere(accessTargetIs(ClassWithField.class))), $(noClass(ClassAccessingWrongField.class).should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class))), @@ -1337,9 +1285,9 @@ public static Object[][] noClass_should_getFieldWhere_rules() { ); } - @Test - @UseDataProvider("noClass_should_getFieldWhere_rules") - public void noClass_should_getFieldWhere(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_getFieldWhere_rules") + void noClass_should_getFieldWhere(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, ClassWithField.class, ClassAccessingWrongField.class, ClassAccessingField.class) .haveSuccessfulRuleText("no class %s should get field where target is %s", ClassAccessingWrongField.class.getName(), ClassWithField.class.getSimpleName()) @@ -1351,9 +1299,8 @@ public void noClass_should_getFieldWhere(ArchRule satisfiedRule, ArchRule unsati .doNotContainFailureDetail(quote(ClassAccessingWrongField.class.getSimpleName())); } - @DataProvider - public static Object[][] theClass_should_accessFieldWhere_rules() { - return $$( + static Stream theClass_should_accessFieldWhere_rules() { + return Stream.of( $(theClass(ClassAccessingField.class).should().accessFieldWhere(accessTargetIs(ClassWithField.class)), theClass(ClassAccessingWrongField.class).should().accessFieldWhere(accessTargetIs(ClassWithField.class))), $(theClass(ClassAccessingField.class).should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class))), @@ -1366,9 +1313,9 @@ public static Object[][] theClass_should_accessFieldWhere_rules() { ); } - @Test - @UseDataProvider("theClass_should_accessFieldWhere_rules") - public void theClass_should_accessFieldWhere(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("theClass_should_accessFieldWhere_rules") + void theClass_should_accessFieldWhere(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, ClassWithField.class, ClassAccessingWrongField.class, ClassAccessingField.class) .haveSuccessfulRuleText("the class %s should access field where target is %s", ClassAccessingField.class.getName(), ClassWithField.class.getSimpleName()) @@ -1380,9 +1327,8 @@ public void theClass_should_accessFieldWhere(ArchRule satisfiedRule, ArchRule un .doNotContainFailureDetail(quote(ClassAccessingField.class.getSimpleName()) + ANY_NUMBER_OF_NON_NEWLINE_CHARS_REGEX + "accesses"); } - @DataProvider - public static Object[][] noClass_should_accessFieldWhere_rules() { - return $$( + static Stream noClass_should_accessFieldWhere_rules() { + return Stream.of( $(noClass(ClassAccessingWrongField.class).should().accessFieldWhere(accessTargetIs(ClassWithField.class)), noClass(ClassAccessingField.class).should().accessFieldWhere(accessTargetIs(ClassWithField.class))), $(noClass(ClassAccessingWrongField.class).should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class))), @@ -1394,9 +1340,9 @@ public static Object[][] noClass_should_accessFieldWhere_rules() { ); } - @Test - @UseDataProvider("noClass_should_accessFieldWhere_rules") - public void noClass_should_accessFieldWhere(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { + @ParameterizedTest + @MethodSource("noClass_should_accessFieldWhere_rules") + void noClass_should_accessFieldWhere(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { assertThatRules(satisfiedRule, unsatisfiedRule, ClassWithField.class, ClassAccessingWrongField.class, ClassAccessingField.class) .haveSuccessfulRuleText("no class %s should access field where target is %s", ClassAccessingWrongField.class.getName(), ClassWithField.class.getSimpleName()) diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenFieldsTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenFieldsTest.java index 8c6bd45468..36b263bbab 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenFieldsTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenFieldsTest.java @@ -4,15 +4,15 @@ import java.util.List; import java.util.Map; import java.util.Set; +import java.util.stream.Stream; import com.google.common.collect.ImmutableSet; import com.tngtech.archunit.lang.EvaluationResult; import com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.DescribedRuleStart; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.Sets.difference; import static com.tngtech.archunit.core.domain.JavaClass.Predicates.equivalentTo; @@ -24,11 +24,9 @@ import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.beAnnotatedWith; import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.described; import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.everythingViolationPrintMemberName; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class GivenFieldsTest { @Test @@ -46,9 +44,8 @@ public void complex_field_syntax() { String.format("Member '%s' is not annotated with @A", FIELD_C)); } - @DataProvider - public static Object[][] restricted_property_rule_starts() { - return $$( + static Stream restricted_property_rule_starts() { + return Stream.of( $(described(fields().that().haveRawType(String.class)), ImmutableSet.of(FIELD_A)), $(described(fields().that().haveRawType(String.class.getName())), ImmutableSet.of(FIELD_A)), $(described(fields().that().haveRawType(equivalentTo(String.class))), ImmutableSet.of(FIELD_A)), @@ -66,9 +63,9 @@ public static Object[][] restricted_property_rule_starts() { ); } - @Test - @UseDataProvider("restricted_property_rule_starts") - public void property_predicates(DescribedRuleStart ruleStart, Collection expectedMembers) { + @ParameterizedTest + @MethodSource("restricted_property_rule_starts") + void property_predicates(DescribedRuleStart ruleStart, Collection expectedMembers) { EvaluationResult result = ruleStart.should(everythingViolationPrintMemberName()) .evaluate(importClasses(ClassWithVariousMembers.class)); diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMethodsTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMethodsTest.java index b14b43206a..49e6a7169f 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMethodsTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMethodsTest.java @@ -1,28 +1,26 @@ package com.tngtech.archunit.lang.syntax.elements; +import java.util.Collection; +import java.util.stream.Stream; + import com.google.common.collect.ImmutableSet; import com.tngtech.archunit.lang.EvaluationResult; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; - -import java.util.Collection; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.core.domain.TestUtils.importClasses; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.methods; -import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.*; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.DescribedRuleStart; +import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.described; +import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.everythingViolationPrintMemberName; +import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class GivenMethodsTest { - @DataProvider - public static Object[][] restricted_property_rule_starts() { - return $$( + static Stream restricted_property_rule_starts() { + return Stream.of( $(described(methods().that().areFinal()), ImmutableSet.of(METHOD_A, METHOD_B)), $(described(methods().that().areNotFinal()), ImmutableSet.of(METHOD_C, METHOD_D)), $(described(methods().that().areStatic()), ImmutableSet.of(METHOD_B, METHOD_D)), @@ -32,9 +30,9 @@ public static Object[][] restricted_property_rule_starts() { ); } - @Test - @UseDataProvider("restricted_property_rule_starts") - public void property_predicates(DescribedRuleStart ruleStart, Collection expectedMembers) { + @ParameterizedTest + @MethodSource("restricted_property_rule_starts") + void property_predicates(DescribedRuleStart ruleStart, Collection expectedMembers) { EvaluationResult result = ruleStart.should(everythingViolationPrintMemberName()) .evaluate(importClasses(ClassWithVariousMembers.class)); diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MembersShouldConjunctionTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MembersShouldConjunctionTest.java index aa9eb4e3b2..c6b9d4c4af 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MembersShouldConjunctionTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MembersShouldConjunctionTest.java @@ -1,27 +1,23 @@ package com.tngtech.archunit.lang.syntax.elements; +import java.util.stream.Stream; + import com.tngtech.archunit.lang.ArchRule; import com.tngtech.archunit.lang.EvaluationResult; import com.tngtech.archunit.lang.FailureReport; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.core.domain.JavaConstructor.CONSTRUCTOR_NAME; import static com.tngtech.archunit.core.domain.TestUtils.importClasses; import static com.tngtech.archunit.lang.conditions.ArchConditions.beDeclaredIn; import static com.tngtech.archunit.lang.conditions.ArchConditions.not; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.members; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class MembersShouldConjunctionTest { - @DataProvider - public static Object[][] ORed_conditions() { - return testForEach( + static Stream ORed_conditions() { + return Stream.of( members() .should(beDeclaredIn(RightOne.class)) .orShould(beDeclaredIn(RightTwo.class)), @@ -31,9 +27,9 @@ public static Object[][] ORed_conditions() { ); } - @Test - @UseDataProvider("ORed_conditions") - public void orShould_ORs_conditions(ArchRule rule) { + @ParameterizedTest + @MethodSource("ORed_conditions") + void orShould_ORs_conditions(ArchRule rule) { EvaluationResult result = rule .evaluate(importClasses(RightOne.class, RightTwo.class, WrongOne.class)); @@ -44,16 +40,15 @@ public void orShould_ORs_conditions(ArchRule rule) { RightOne.class.getName(), RightTwo.class.getName())); assertThat(report.getDetails()).containsOnly( String.format("%s and %s", - isNotDeclaredInMessage(WrongOne.class, CONSTRUCTOR_NAME, RightOne.class, 111), - isNotDeclaredInMessage(WrongOne.class, CONSTRUCTOR_NAME, RightTwo.class, 111)), + isNotDeclaredInMessage(WrongOne.class, CONSTRUCTOR_NAME, RightOne.class, 106), + isNotDeclaredInMessage(WrongOne.class, CONSTRUCTOR_NAME, RightTwo.class, 106)), String.format("%s and %s", - isNotDeclaredInMessage(WrongOne.class, "wrongMethod1", RightOne.class, 113), - isNotDeclaredInMessage(WrongOne.class, "wrongMethod1", RightTwo.class, 113))); + isNotDeclaredInMessage(WrongOne.class, "wrongMethod1", RightOne.class, 108), + isNotDeclaredInMessage(WrongOne.class, "wrongMethod1", RightTwo.class, 108))); } - @DataProvider - public static Object[][] ANDed_conditions() { - return testForEach( + static Stream ANDed_conditions() { + return Stream.of( members() .should(not(beDeclaredIn(WrongOne.class))) .andShould(not(beDeclaredIn(WrongTwo.class))), @@ -63,9 +58,9 @@ public static Object[][] ANDed_conditions() { ); } - @Test - @UseDataProvider("ANDed_conditions") - public void andShould_ANDs_conditions(ArchRule rule) { + @ParameterizedTest + @MethodSource("ANDed_conditions") + void andShould_ANDs_conditions(ArchRule rule) { EvaluationResult result = rule .evaluate(importClasses(RightOne.class, RightTwo.class, WrongOne.class, WrongTwo.class)); @@ -75,10 +70,10 @@ public void andShould_ANDs_conditions(ArchRule rule) { "members should not be declared in %s and should not be declared in %s", WrongOne.class.getName(), WrongTwo.class.getName())); assertThat(report.getDetails()).containsOnly( - isDeclaredInMessage(WrongOne.class, CONSTRUCTOR_NAME, 111), - isDeclaredInMessage(WrongOne.class, "wrongMethod1", 113), - isDeclaredInMessage(WrongTwo.class, CONSTRUCTOR_NAME, 117), - isDeclaredInMessage(WrongTwo.class, "wrongMethod2", 119)); + isDeclaredInMessage(WrongOne.class, CONSTRUCTOR_NAME, 106), + isDeclaredInMessage(WrongOne.class, "wrongMethod1", 108), + isDeclaredInMessage(WrongTwo.class, CONSTRUCTOR_NAME, 112), + isDeclaredInMessage(WrongTwo.class, "wrongMethod2", 114)); } private String isDeclaredInMessage(Class clazz, String methodName, int lineNumber) { diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MethodsShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MethodsShouldTest.java index 8193627128..01b66d39e7 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MethodsShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MethodsShouldTest.java @@ -1,30 +1,26 @@ package com.tngtech.archunit.lang.syntax.elements; +import java.util.Collection; +import java.util.Set; +import java.util.stream.Stream; + import com.google.common.collect.ImmutableSet; import com.tngtech.archunit.lang.ArchRule; import com.tngtech.archunit.lang.EvaluationResult; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; - -import java.util.Collection; -import java.util.Set; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.core.domain.TestUtils.importClasses; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.methods; import static com.tngtech.archunit.lang.syntax.elements.MembersShouldTest.parseMembers; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class MethodsShouldTest { - @DataProvider - public static Object[][] restricted_property_rule_ends() { - return $$( + static Stream restricted_property_rule_ends() { + return Stream.of( $(methods().should().beFinal(), ImmutableSet.of(METHOD_C, METHOD_D)), $(methods().should().notBeFinal(), ImmutableSet.of(METHOD_A, METHOD_B)), $(methods().should().beStatic(), ImmutableSet.of(METHOD_A, METHOD_C)), @@ -34,9 +30,9 @@ public static Object[][] restricted_property_rule_ends() { ); } - @Test - @UseDataProvider("restricted_property_rule_ends") - public void property_predicates(ArchRule ruleStart, Collection expectedMembers) { + @ParameterizedTest + @MethodSource("restricted_property_rule_ends") + void property_predicates(ArchRule ruleStart, Collection expectedMembers) { EvaluationResult result = ruleStart.evaluate(importClasses(ClassWithVariousMembers.class)); Set actualMethods = parseMembers(ClassWithVariousMembers.class, result.getFailureReport().getDetails()); diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ShouldClassesThatTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ShouldClassesThatTest.java index ef9d39dd2b..55e6b95441 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ShouldClassesThatTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ShouldClassesThatTest.java @@ -10,6 +10,7 @@ import java.util.List; import java.util.Set; import java.util.function.Function; +import java.util.stream.Stream; import com.tngtech.archunit.base.DescribedPredicate; import com.tngtech.archunit.core.domain.JavaClass; @@ -19,14 +20,10 @@ import com.tngtech.archunit.core.domain.properties.HasType; import com.tngtech.archunit.core.importer.ClassFileImporter; import com.tngtech.archunit.lang.ArchRule; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.base.DescribedPredicate.equalTo; @@ -46,32 +43,25 @@ import static com.tngtech.archunit.testutil.Assertions.assertThatRule; import static com.tngtech.archunit.testutil.Assertions.assertThatType; import static com.tngtech.archunit.testutil.Assertions.assertThatTypes; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; import static java.util.regex.Pattern.quote; -@RunWith(DataProviderRunner.class) public class ShouldClassesThatTest { - @Rule - public final MockitoRule rule = MockitoJUnit.rule(); - - @DataProvider - public static Object[][] no_classes_should_that_rule_starts() { - return testForEach( + static Stream> no_classes_should_that_rule_starts() { + return Stream.of( noClasses().should().accessClassesThat(), noClasses().should().dependOnClassesThat()); } - @DataProvider - public static Object[][] classes_should_only_that_rule_starts() { - return testForEach( + static Stream> classes_should_only_that_rule_starts() { + return Stream.of( classes().should().onlyAccessClassesThat(), classes().should().onlyDependOnClassesThat()); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void haveFullyQualifiedName(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void haveFullyQualifiedName(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.haveFullyQualifiedName(List.class.getName())) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -79,9 +69,9 @@ public void haveFullyQualifiedName(ClassesThat noClass assertThatType(getOnlyElement(classes)).matches(ClassAccessingList.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void doNotHaveFullyQualifiedName(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void doNotHaveFullyQualifiedName(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.doNotHaveFullyQualifiedName(List.class.getName())) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -89,9 +79,9 @@ public void doNotHaveFullyQualifiedName(ClassesThat no assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void haveSimpleName(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void haveSimpleName(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.haveSimpleName(List.class.getSimpleName())) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -99,9 +89,9 @@ public void haveSimpleName(ClassesThat noClassesShould assertThatType(getOnlyElement(classes)).matches(ClassAccessingList.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void doNotHaveSimpleName(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void doNotHaveSimpleName(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.doNotHaveSimpleName(List.class.getSimpleName())) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -109,9 +99,9 @@ public void doNotHaveSimpleName(ClassesThat noClassesS assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void haveNameMatching(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void haveNameMatching(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.haveNameMatching(".*\\.List")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -119,9 +109,9 @@ public void haveNameMatching(ClassesThat noClassesShou assertThatType(getOnlyElement(classes)).matches(ClassAccessingList.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void haveNameNotMatching(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void haveNameNotMatching(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.haveNameNotMatching(".*\\.List")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -129,9 +119,9 @@ public void haveNameNotMatching(ClassesThat noClassesS assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void haveSimpleNameStartingWith(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void haveSimpleNameStartingWith(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.haveSimpleNameStartingWith("Lis")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -139,9 +129,9 @@ public void haveSimpleNameStartingWith(ClassesThat noC assertThatType(getOnlyElement(classes)).matches(ClassAccessingList.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void haveSimpleNameNotStartingWith(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void haveSimpleNameNotStartingWith(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.haveSimpleNameNotStartingWith("Lis")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -149,9 +139,9 @@ public void haveSimpleNameNotStartingWith(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void haveSimpleNameContaining(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void haveSimpleNameContaining(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.haveSimpleNameContaining("is")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -159,9 +149,9 @@ public void haveSimpleNameContaining(ClassesThat noCla assertThatType(getOnlyElement(classes)).matches(ClassAccessingList.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void haveSimpleNameNotContaining(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void haveSimpleNameNotContaining(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.haveSimpleNameNotContaining("is")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -169,9 +159,9 @@ public void haveSimpleNameNotContaining(ClassesThat no assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void haveSimpleNameEndingWith(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void haveSimpleNameEndingWith(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.haveSimpleNameEndingWith("ist")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -179,9 +169,9 @@ public void haveSimpleNameEndingWith(ClassesThat noCla assertThatType(getOnlyElement(classes)).matches(ClassAccessingList.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void haveSimpleNameNotEndingWith(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void haveSimpleNameNotEndingWith(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.haveSimpleNameNotEndingWith("ist")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -189,9 +179,9 @@ public void haveSimpleNameNotEndingWith(ClassesThat no assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void resideInAPackage(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void resideInAPackage(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.resideInAPackage("..tngtech..")) .on(ClassAccessingPublicClass.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -199,9 +189,9 @@ public void resideInAPackage(ClassesThat noClassesShou assertThatTypes(classes).matchInAnyOrder(ClassAccessingPublicClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void resideOutsideOfPackage(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void resideOutsideOfPackage(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.resideOutsideOfPackage("..tngtech..")) .on(ClassAccessingPublicClass.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -209,9 +199,9 @@ public void resideOutsideOfPackage(ClassesThat noClass assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void resideInAnyPackage(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void resideInAnyPackage(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.resideInAnyPackage("..tngtech..", "java.lang.reflect")) .on(ClassAccessingPublicClass.class, ClassAccessingString.class, ClassAccessingConstructor.class); @@ -219,9 +209,9 @@ public void resideInAnyPackage(ClassesThat noClassesSh assertThatTypes(classes).matchInAnyOrder(ClassAccessingPublicClass.class, ClassAccessingConstructor.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void resideOutsideOfPackages(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void resideOutsideOfPackages(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.resideOutsideOfPackages("..tngtech..", "java.lang.reflect") ).on(ClassAccessingPublicClass.class, ClassAccessingString.class, ClassAccessingConstructor.class); @@ -229,9 +219,9 @@ public void resideOutsideOfPackages(ClassesThat noClas assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void arePublic(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void arePublic(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(noClassesShouldThatRuleStart.arePublic()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -239,9 +229,9 @@ public void arePublic(ClassesThat noClassesShouldThatR assertThatTypes(classes).matchInAnyOrder(ClassAccessingPublicClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotPublic(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotPublic(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(noClassesShouldThatRuleStart.areNotPublic()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -250,9 +240,9 @@ public void areNotPublic(ClassesThat noClassesShouldTh ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areProtected(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areProtected(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(noClassesShouldThatRuleStart.areProtected()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -260,9 +250,9 @@ public void areProtected(ClassesThat noClassesShouldTh assertThatTypes(classes).matchInAnyOrder(ClassAccessingProtectedClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotProtected(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotProtected(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(noClassesShouldThatRuleStart.areNotProtected()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -271,9 +261,9 @@ public void areNotProtected(ClassesThat noClassesShoul ClassAccessingPackagePrivateClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void arePackagePrivate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void arePackagePrivate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(noClassesShouldThatRuleStart.arePackagePrivate()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -281,9 +271,9 @@ public void arePackagePrivate(ClassesThat noClassesSho assertThatTypes(classes).matchInAnyOrder(ClassAccessingPackagePrivateClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotPackagePrivate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotPackagePrivate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(noClassesShouldThatRuleStart.areNotPackagePrivate()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -292,9 +282,9 @@ public void areNotPackagePrivate(ClassesThat noClasses ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingProtectedClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void arePrivate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void arePrivate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(noClassesShouldThatRuleStart.arePrivate()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -302,9 +292,9 @@ public void arePrivate(ClassesThat noClassesShouldThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingPrivateClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotPrivate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotPrivate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(noClassesShouldThatRuleStart.areNotPrivate()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -313,9 +303,9 @@ public void areNotPrivate(ClassesThat noClassesShouldT ClassAccessingPublicClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void haveModifier(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void haveModifier(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(noClassesShouldThatRuleStart.haveModifier(PRIVATE)) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -323,9 +313,9 @@ public void haveModifier(ClassesThat noClassesShouldTh assertThatTypes(classes).matchInAnyOrder(ClassAccessingPrivateClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void doNotHaveModifier(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void doNotHaveModifier(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(noClassesShouldThatRuleStart.doNotHaveModifier(PRIVATE)) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -334,9 +324,9 @@ public void doNotHaveModifier(ClassesThat noClassesSho ClassAccessingPublicClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areAnnotatedWith_type(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areAnnotatedWith_type(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areAnnotatedWith(SomeAnnotation.class)) .on(ClassAccessingAnnotatedClass.class, ClassAccessingSimpleClass.class); @@ -386,9 +376,9 @@ void bMethod() { } } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void containAnyMembersThat(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void containAnyMembersThat(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(noClassesShouldThatRuleStart.containAnyMembersThat(have(name("aField")))) .on(Data_of_containAnyMembersThat.OkayOrigin.class, Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.OkayTarget.class, Data_of_containAnyMembersThat.ViolatingTarget.class); @@ -396,9 +386,9 @@ public void containAnyMembersThat(ClassesThat noClasse assertThatTypes(classes).matchInAnyOrder(Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.ViolatingTarget.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void containAnyFieldsThat(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void containAnyFieldsThat(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(noClassesShouldThatRuleStart.containAnyFieldsThat(have(name("aField")))) .on(Data_of_containAnyMembersThat.OkayOrigin.class, Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.OkayTarget.class, Data_of_containAnyMembersThat.ViolatingTarget.class); @@ -406,9 +396,9 @@ public void containAnyFieldsThat(ClassesThat noClasses assertThatTypes(classes).matchInAnyOrder(Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.ViolatingTarget.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void containAnyCodeUnitsThat(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void containAnyCodeUnitsThat(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(noClassesShouldThatRuleStart.containAnyCodeUnitsThat(have(name("aMethod")))) .on(Data_of_containAnyMembersThat.OkayOrigin.class, Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.OkayTarget.class, Data_of_containAnyMembersThat.ViolatingTarget.class); @@ -416,9 +406,9 @@ public void containAnyCodeUnitsThat(ClassesThat noClas assertThatTypes(classes).matchInAnyOrder(Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.ViolatingTarget.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void containAnyMethodsThat(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void containAnyMethodsThat(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(noClassesShouldThatRuleStart.containAnyMethodsThat(have(name("aMethod")))) .on(Data_of_containAnyMembersThat.OkayOrigin.class, Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.OkayTarget.class, Data_of_containAnyMembersThat.ViolatingTarget.class); @@ -426,9 +416,9 @@ public void containAnyMethodsThat(ClassesThat noClasse assertThatTypes(classes).matchInAnyOrder(Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.ViolatingTarget.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void containAnyConstructorsThat(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void containAnyConstructorsThat(ClassesThat noClassesShouldThatRuleStart) { ArchRule rule = noClassesShouldThatRuleStart.containAnyConstructorsThat(have(fullNameMatching(".*" + quote(Object.class.getName()) + ".*"))); Set classes = filterClassesAppearingInFailureReport(rule) .on(Data_of_containAnyMembersThat.OkayOrigin.class, Data_of_containAnyMembersThat.ViolatingOrigin.class, @@ -437,9 +427,9 @@ public void containAnyConstructorsThat(ClassesThat noC assertThatTypes(classes).matchInAnyOrder(Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.ViolatingTarget.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void containAnyStaticInitializersThat(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void containAnyStaticInitializersThat(ClassesThat noClassesShouldThatRuleStart) { ArchRule rule = noClassesShouldThatRuleStart.containAnyStaticInitializersThat( have(fullNameMatching(quote(Data_of_containAnyMembersThat.ViolatingTarget.class.getName()) + ".*"))); Set classes = filterClassesAppearingInFailureReport(rule) @@ -449,9 +439,9 @@ public void containAnyStaticInitializersThat(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotAnnotatedWith_type(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotAnnotatedWith(SomeAnnotation.class)) .on(ClassAccessingAnnotatedClass.class, ClassAccessingSimpleClass.class); @@ -459,9 +449,9 @@ public void areNotAnnotatedWith_type(ClassesThat noCla assertThatType(getOnlyElement(classes)).matches(ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areAnnotatedWith_typeName(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areAnnotatedWith_typeName(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areAnnotatedWith(SomeAnnotation.class.getName())) .on(ClassAccessingAnnotatedClass.class, ClassAccessingSimpleClass.class); @@ -469,9 +459,9 @@ public void areAnnotatedWith_typeName(ClassesThat noCl assertThatType(getOnlyElement(classes)).matches(ClassAccessingAnnotatedClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotAnnotatedWith_typeName(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotAnnotatedWith_typeName(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotAnnotatedWith(SomeAnnotation.class.getName())) .on(ClassAccessingAnnotatedClass.class, ClassAccessingSimpleClass.class); @@ -479,9 +469,9 @@ public void areNotAnnotatedWith_typeName(ClassesThat n assertThatType(getOnlyElement(classes)).matches(ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areAnnotatedWith_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areAnnotatedWith_predicate(ClassesThat noClassesShouldThatRuleStart) { DescribedPredicate hasNamePredicate = GET_RAW_TYPE.is(classWithNameOf(SomeAnnotation.class)); Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areAnnotatedWith(hasNamePredicate)) @@ -490,9 +480,9 @@ public void areAnnotatedWith_predicate(ClassesThat noC assertThatType(getOnlyElement(classes)).matches(ClassAccessingAnnotatedClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotAnnotatedWith_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotAnnotatedWith_predicate(ClassesThat noClassesShouldThatRuleStart) { DescribedPredicate hasNamePredicate = GET_RAW_TYPE.is(classWithNameOf(SomeAnnotation.class)); Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotAnnotatedWith(hasNamePredicate)) @@ -501,9 +491,9 @@ public void areNotAnnotatedWith_predicate(ClassesThat assertThatType(getOnlyElement(classes)).matches(ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areMetaAnnotatedWith_type(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areMetaAnnotatedWith_type(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areMetaAnnotatedWith(SomeAnnotation.class)) .on(ClassAccessingMetaAnnotatedClass.class, ClassAccessingAnnotatedClass.class, ClassAccessingSimpleClass.class, @@ -532,9 +522,9 @@ public void areNotMetaAnnotatedWith_type_dependency() { assertThatTypes(classes).matchInAnyOrder(ClassAccessingSimpleClass.class, MetaAnnotatedAnnotation.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areMetaAnnotatedWith_typeName(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areMetaAnnotatedWith_typeName(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areMetaAnnotatedWith(SomeAnnotation.class.getName())) .on(ClassAccessingMetaAnnotatedClass.class, ClassAccessingAnnotatedClass.class, ClassAccessingSimpleClass.class, @@ -563,9 +553,9 @@ public void areNotMetaAnnotatedWith_typeName_dependency() { assertThatTypes(classes).matchInAnyOrder(ClassAccessingSimpleClass.class, MetaAnnotatedAnnotation.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areMetaAnnotatedWith_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areMetaAnnotatedWith_predicate(ClassesThat noClassesShouldThatRuleStart) { DescribedPredicate hasNamePredicate = GET_RAW_TYPE.is(classWithNameOf(SomeAnnotation.class)); Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areMetaAnnotatedWith(hasNamePredicate)) @@ -597,9 +587,9 @@ public void areNotMetaAnnotatedWith_predicate_dependency() { assertThatTypes(classes).matchInAnyOrder(ClassAccessingSimpleClass.class, MetaAnnotatedAnnotation.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void implement_type(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void implement_type(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.implement(Collection.class)) .on(ClassAccessingArrayList.class, ClassAccessingList.class, ClassAccessingIterable.class); @@ -607,9 +597,9 @@ public void implement_type(ClassesThat noClassesShould assertThatType(getOnlyElement(classes)).matches(ClassAccessingArrayList.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void doNotImplement_type(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void doNotImplement_type(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.doNotImplement(Collection.class)) .on(ClassAccessingArrayList.class, ClassAccessingList.class, ClassAccessingIterable.class); @@ -617,9 +607,9 @@ public void doNotImplement_type(ClassesThat noClassesS assertThatTypes(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void implement_typeName(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void implement_typeName(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.implement(Collection.class.getName())) .on(ClassAccessingArrayList.class, ClassAccessingList.class, ClassAccessingIterable.class); @@ -627,9 +617,9 @@ public void implement_typeName(ClassesThat noClassesSh assertThatType(getOnlyElement(classes)).matches(ClassAccessingArrayList.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void doNotImplement_typeName(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void doNotImplement_typeName(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.doNotImplement(Collection.class.getName())) .on(ClassAccessingArrayList.class, ClassAccessingList.class, ClassAccessingIterable.class); @@ -637,9 +627,9 @@ public void doNotImplement_typeName(ClassesThat noClas assertThatTypes(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void implement_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void implement_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.implement(classWithNameOf(Collection.class))) .on(ClassAccessingArrayList.class, ClassAccessingList.class, ClassAccessingIterable.class); @@ -647,9 +637,9 @@ public void implement_predicate(ClassesThat noClassesS assertThatType(getOnlyElement(classes)).matches(ClassAccessingArrayList.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void doNotImplement_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void doNotImplement_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.doNotImplement(classWithNameOf(Collection.class))) .on(ClassAccessingArrayList.class, ClassAccessingList.class, ClassAccessingIterable.class); @@ -657,9 +647,9 @@ public void doNotImplement_predicate(ClassesThat noCla assertThatTypes(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areAssignableTo_type(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areAssignableTo_type(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areAssignableTo(Collection.class)) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -667,9 +657,9 @@ public void areAssignableTo_type(ClassesThat noClasses assertThatType(getOnlyElement(classes)).matches(ClassAccessingList.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotAssignableTo_type(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotAssignableTo_type(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotAssignableTo(Collection.class)) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -677,9 +667,9 @@ public void areNotAssignableTo_type(ClassesThat noClas assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areAssignableTo_typeName(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areAssignableTo_typeName(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areAssignableTo(Collection.class.getName())) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -687,9 +677,9 @@ public void areAssignableTo_typeName(ClassesThat noCla assertThatType(getOnlyElement(classes)).matches(ClassAccessingList.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotAssignableTo_typeName(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotAssignableTo_typeName(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotAssignableTo(Collection.class.getName())) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -697,9 +687,9 @@ public void areNotAssignableTo_typeName(ClassesThat no assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areAssignableTo_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areAssignableTo_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areAssignableTo(classWithNameOf(Collection.class))) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -707,9 +697,9 @@ public void areAssignableTo_predicate(ClassesThat noCl assertThatType(getOnlyElement(classes)).matches(ClassAccessingList.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotAssignableTo_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotAssignableTo_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotAssignableTo(classWithNameOf(Collection.class))) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -717,9 +707,9 @@ public void areNotAssignableTo_predicate(ClassesThat n assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areAssignableFrom_type(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areAssignableFrom_type(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areAssignableFrom(Collection.class)) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -728,9 +718,9 @@ public void areAssignableFrom_type(ClassesThat noClass assertThatTypes(classes).matchInAnyOrder(ClassAccessingCollection.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotAssignableFrom_type(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotAssignableFrom_type(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotAssignableFrom(Collection.class)) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -739,9 +729,9 @@ public void areNotAssignableFrom_type(ClassesThat noCl assertThatTypes(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingString.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areAssignableFrom_typeName(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areAssignableFrom_typeName(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areAssignableFrom(Collection.class.getName())) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -750,9 +740,9 @@ public void areAssignableFrom_typeName(ClassesThat noC assertThatTypes(classes).matchInAnyOrder(ClassAccessingCollection.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotAssignableFrom_typeName(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotAssignableFrom_typeName(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotAssignableFrom(Collection.class.getName())) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -761,9 +751,9 @@ public void areNotAssignableFrom_typeName(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingString.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areAssignableFrom_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areAssignableFrom_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areAssignableFrom(classWithNameOf(Collection.class))) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -772,9 +762,9 @@ public void areAssignableFrom_predicate(ClassesThat no assertThatTypes(classes).matchInAnyOrder(ClassAccessingCollection.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotAssignableFrom_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotAssignableFrom_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotAssignableFrom(classWithNameOf(Collection.class))) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -783,9 +773,9 @@ public void areNotAssignableFrom_predicate(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingString.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areInterfaces_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areInterfaces_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areInterfaces()) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -794,9 +784,9 @@ public void areInterfaces_predicate(ClassesThat noClas assertThatTypes(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingCollection.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotInterfaces_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotInterfaces_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotInterfaces()) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -805,9 +795,9 @@ public void areNotInterfaces_predicate(ClassesThat noC assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areEnums_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areEnums_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areEnums()) .on(ClassAccessingEnum.class, ClassAccessingString.class); @@ -815,9 +805,9 @@ public void areEnums_predicate(ClassesThat noClassesSh assertThatTypes(classes).matchInAnyOrder(ClassAccessingEnum.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotEnums_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotEnums_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotEnums()) .on(ClassAccessingEnum.class, ClassAccessingString.class); @@ -825,9 +815,9 @@ public void areNotEnums_predicate(ClassesThat noClasse assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areAnnotations_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areAnnotations_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areAnnotations()) .on(ClassAccessingAnnotation.class, ClassAccessingString.class); @@ -835,9 +825,9 @@ public void areAnnotations_predicate(ClassesThat noCla assertThatTypes(classes).matchInAnyOrder(ClassAccessingAnnotation.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotAnnotations_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotAnnotations_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotAnnotations()) .on(ClassAccessingAnnotation.class, ClassAccessingString.class); @@ -857,9 +847,9 @@ public void areNotRecords_predicate() { noClasses().should().accessClassesThat().areNotRecords(); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areTopLevelClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areTopLevelClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areTopLevelClasses()) .on(ClassAccessingTopLevelClass.class, ClassAccessingStaticNestedClass.class); @@ -867,9 +857,9 @@ public void areTopLevelClasses_predicate(ClassesThat n assertThatTypes(classes).matchInAnyOrder(ClassAccessingTopLevelClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotTopLevelClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotTopLevelClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotTopLevelClasses()) .on(ClassAccessingTopLevelClass.class, ClassAccessingStaticNestedClass.class); @@ -877,9 +867,9 @@ public void areNotTopLevelClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNestedClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNestedClasses()) .on(ClassAccessingStaticNestedClass.class, ClassAccessingTopLevelClass.class); @@ -887,9 +877,9 @@ public void areNestedClasses_predicate(ClassesThat noC assertThatTypes(classes).matchInAnyOrder(ClassAccessingStaticNestedClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotNestedClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotNestedClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotNestedClasses()) .on(ClassAccessingStaticNestedClass.class, ClassAccessingTopLevelClass.class); @@ -897,9 +887,9 @@ public void areNotNestedClasses_predicate(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingTopLevelClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areMemberClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areMemberClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areMemberClasses()) .on(ClassAccessingStaticNestedClass.class, ClassAccessingTopLevelClass.class); @@ -907,9 +897,9 @@ public void areMemberClasses_predicate(ClassesThat noC assertThatTypes(classes).matchInAnyOrder(ClassAccessingStaticNestedClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotMemberClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotMemberClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotMemberClasses()) .on(ClassAccessingStaticNestedClass.class, ClassAccessingTopLevelClass.class); @@ -917,9 +907,9 @@ public void areNotMemberClasses_predicate(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingTopLevelClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areInnerClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areInnerClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areInnerClasses()) .on(ClassAccessingInnerMemberClass.class, ClassAccessingTopLevelClass.class); @@ -927,9 +917,9 @@ public void areInnerClasses_predicate(ClassesThat noCl assertThatTypes(classes).matchInAnyOrder(ClassAccessingInnerMemberClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotInnerClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotInnerClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotInnerClasses()) .on(ClassAccessingInnerMemberClass.class, ClassAccessingTopLevelClass.class); @@ -937,9 +927,9 @@ public void areNotInnerClasses_predicate(ClassesThat n assertThatTypes(classes).matchInAnyOrder(ClassAccessingTopLevelClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areAnonymousClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areAnonymousClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areAnonymousClasses()) .on(ClassAccessingAnonymousClass.class, ClassAccessingTopLevelClass.class); @@ -947,9 +937,9 @@ public void areAnonymousClasses_predicate(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingAnonymousClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotAnonymousClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotAnonymousClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotAnonymousClasses()) .on(ClassAccessingAnonymousClass.class, ClassAccessingTopLevelClass.class); @@ -957,9 +947,9 @@ public void areNotAnonymousClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areLocalClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areLocalClasses()) .on(ClassAccessingLocalClass.class, ClassAccessingTopLevelClass.class); @@ -967,9 +957,9 @@ public void areLocalClasses_predicate(ClassesThat noCl assertThatTypes(classes).matchInAnyOrder(ClassAccessingLocalClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void areNotLocalClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void areNotLocalClasses_predicate(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.areNotLocalClasses()) .on(ClassAccessingLocalClass.class, ClassAccessingTopLevelClass.class); @@ -977,9 +967,9 @@ public void areNotLocalClasses_predicate(ClassesThat n assertThatTypes(classes).matchInAnyOrder(ClassAccessingTopLevelClass.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void belongToAnyOf(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void belongToAnyOf(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.belongToAnyOf(ClassWithInnerClasses.class, String.class)) .on(ClassAccessingNestedInnerClass.class, ClassWithInnerClasses.class, ClassWithInnerClasses.InnerClass.class, @@ -990,9 +980,9 @@ public void belongToAnyOf(ClassesThat noClassesShouldT ClassAccessingString.class); } - @Test - @UseDataProvider("no_classes_should_that_rule_starts") - public void doNotBelongToAnyOf(ClassesThat noClassesShouldThatRuleStart) { + @ParameterizedTest + @MethodSource("no_classes_should_that_rule_starts") + void doNotBelongToAnyOf(ClassesThat noClassesShouldThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( noClassesShouldThatRuleStart.doNotBelongToAnyOf(ClassWithInnerClasses.class, String.class)) .on(ClassAccessingNestedInnerClass.class, ClassWithInnerClasses.class, ClassWithInnerClasses.InnerClass.class, @@ -1001,9 +991,9 @@ public void doNotBelongToAnyOf(ClassesThat noClassesSh assertThatTypes(classes).matchInAnyOrder(ClassAccessingIterable.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_haveFullyQualifiedName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_haveFullyQualifiedName(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.haveFullyQualifiedName(List.class.getName())) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1011,9 +1001,9 @@ public void only_haveFullyQualifiedName(ClassesThat cl assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_doNotHaveFullyQualifiedName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_doNotHaveFullyQualifiedName(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.doNotHaveFullyQualifiedName(List.class.getName())) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1021,9 +1011,9 @@ public void only_doNotHaveFullyQualifiedName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_haveSimpleName(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.haveSimpleName(List.class.getSimpleName())) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1031,9 +1021,9 @@ public void only_haveSimpleName(ClassesThat classesSho assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_doNotHaveSimpleName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_doNotHaveSimpleName(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.doNotHaveSimpleName(List.class.getSimpleName())) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1041,9 +1031,9 @@ public void only_doNotHaveSimpleName(ClassesThat class assertThatType(getOnlyElement(classes)).matches(ClassAccessingList.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_haveNameMatching(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_haveNameMatching(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.haveNameMatching(".*\\.List")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1051,9 +1041,9 @@ public void only_haveNameMatching(ClassesThat classesS assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_haveNameNotMatching(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_haveNameNotMatching(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.haveNameNotMatching(".*\\.List")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1061,9 +1051,9 @@ public void only_haveNameNotMatching(ClassesThat class assertThatType(getOnlyElement(classes)).matches(ClassAccessingList.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_haveSimpleNameStartingWith(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_haveSimpleNameStartingWith(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.haveSimpleNameStartingWith("Lis")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1071,9 +1061,9 @@ public void only_haveSimpleNameStartingWith(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_haveSimpleNameNotStartingWith(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.haveSimpleNameNotStartingWith("Lis")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1081,9 +1071,9 @@ public void only_haveSimpleNameNotStartingWith(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_haveSimpleNameContaining(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.haveSimpleNameContaining("is")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1091,9 +1081,9 @@ public void only_haveSimpleNameContaining(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_haveSimpleNameNotContaining(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_haveSimpleNameNotContaining(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.haveSimpleNameNotContaining("is")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1101,9 +1091,9 @@ public void only_haveSimpleNameNotContaining(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_haveSimpleNameEndingWith(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.haveSimpleNameEndingWith("ist")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1111,9 +1101,9 @@ public void only_haveSimpleNameEndingWith(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_haveSimpleNameNotEndingWith(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_haveSimpleNameNotEndingWith(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.haveSimpleNameNotEndingWith("ist")) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1121,9 +1111,9 @@ public void only_haveSimpleNameNotEndingWith(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_resideInAPackage(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.resideInAPackage("..tngtech..")) .on(ClassAccessingPublicClass.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1131,9 +1121,9 @@ public void only_resideInAPackage(ClassesThat classesS assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_resideOutsideOfPackage(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_resideOutsideOfPackage(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.resideOutsideOfPackage("..tngtech..")) .on(ClassAccessingPublicClass.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1141,9 +1131,9 @@ public void only_resideOutsideOfPackage(ClassesThat cl assertThatTypes(classes).matchInAnyOrder(ClassAccessingPublicClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_resideInAnyPackage(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_resideInAnyPackage(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.resideInAnyPackage("..tngtech..", "java.lang.reflect")) .on(ClassAccessingPublicClass.class, ClassAccessingString.class, ClassAccessingConstructor.class); @@ -1151,9 +1141,9 @@ public void only_resideInAnyPackage(ClassesThat classe assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_resideOutsideOfPackages(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_resideOutsideOfPackages(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.resideOutsideOfPackages("..tngtech..", "java.lang.reflect") ).on(ClassAccessingPublicClass.class, ClassAccessingString.class, ClassAccessingConstructor.class); @@ -1161,9 +1151,9 @@ public void only_resideOutsideOfPackages(ClassesThat c assertThatTypes(classes).matchInAnyOrder(ClassAccessingPublicClass.class, ClassAccessingConstructor.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_arePublic(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_arePublic(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyThatRuleStart.arePublic()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -1172,9 +1162,9 @@ public void only_arePublic(ClassesThat classesShouldOn ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areNotPublic(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotPublic(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyThatRuleStart.areNotPublic()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -1182,9 +1172,9 @@ public void only_areNotPublic(ClassesThat classesShoul assertThatTypes(classes).matchInAnyOrder(ClassAccessingPublicClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areProtected(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areProtected(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyThatRuleStart.areProtected()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -1193,9 +1183,9 @@ public void only_areProtected(ClassesThat classesShoul ClassAccessingPackagePrivateClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areNotProtected(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotProtected(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyThatRuleStart.areNotProtected()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -1203,9 +1193,9 @@ public void only_areNotProtected(ClassesThat classesSh assertThatTypes(classes).matchInAnyOrder(ClassAccessingProtectedClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_arePackagePrivate(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_arePackagePrivate(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyThatRuleStart.arePackagePrivate()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -1214,9 +1204,9 @@ public void only_arePackagePrivate(ClassesThat classes ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingProtectedClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areNotPackagePrivate(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotPackagePrivate(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyThatRuleStart.areNotPackagePrivate()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -1224,9 +1214,9 @@ public void only_areNotPackagePrivate(ClassesThat clas assertThatTypes(classes).matchInAnyOrder(ClassAccessingPackagePrivateClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_arePrivate(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_arePrivate(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyThatRuleStart.arePrivate()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -1235,9 +1225,9 @@ public void only_arePrivate(ClassesThat classesShouldO ClassAccessingPublicClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areNotPrivate(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotPrivate(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyThatRuleStart.areNotPrivate()) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -1245,9 +1235,9 @@ public void only_areNotPrivate(ClassesThat classesShou assertThatTypes(classes).matchInAnyOrder(ClassAccessingPrivateClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_haveModifier(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_haveModifier(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyThatRuleStart.haveModifier(PRIVATE)) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -1256,9 +1246,9 @@ public void only_haveModifier(ClassesThat classesShoul ClassAccessingPublicClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_doNotHaveModifier(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_doNotHaveModifier(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyThatRuleStart.doNotHaveModifier(PRIVATE)) .on(ClassAccessingPublicClass.class, ClassAccessingPrivateClass.class, ClassAccessingPackagePrivateClass.class, ClassAccessingProtectedClass.class); @@ -1266,9 +1256,9 @@ public void only_doNotHaveModifier(ClassesThat classes assertThatTypes(classes).matchInAnyOrder(ClassAccessingPrivateClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areAnnotatedWith_type(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areAnnotatedWith_type(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areAnnotatedWith(SomeAnnotation.class)) .on(ClassAccessingAnnotatedClass.class, ClassAccessingSimpleClass.class); @@ -1276,9 +1266,9 @@ public void only_areAnnotatedWith_type(ClassesThat cla assertThatType(getOnlyElement(classes)).matches(ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areNotAnnotatedWith_type(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotAnnotatedWith_type(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areNotAnnotatedWith(SomeAnnotation.class)) .on(ClassAccessingAnnotatedClass.class, ClassAccessingSimpleClass.class); @@ -1286,9 +1276,9 @@ public void only_areNotAnnotatedWith_type(ClassesThat assertThatType(getOnlyElement(classes)).matches(ClassAccessingAnnotatedClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areAnnotatedWith_typeName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areAnnotatedWith_typeName(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areAnnotatedWith(SomeAnnotation.class.getName())) .on(ClassAccessingAnnotatedClass.class, ClassAccessingSimpleClass.class); @@ -1296,9 +1286,9 @@ public void only_areAnnotatedWith_typeName(ClassesThat assertThatType(getOnlyElement(classes)).matches(ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areNotAnnotatedWith_typeName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotAnnotatedWith_typeName(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areNotAnnotatedWith(SomeAnnotation.class.getName())) .on(ClassAccessingAnnotatedClass.class, ClassAccessingSimpleClass.class); @@ -1306,9 +1296,9 @@ public void only_areNotAnnotatedWith_typeName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areAnnotatedWith_predicate(ClassesThat classesShouldOnlyThatRuleStart) { DescribedPredicate hasNamePredicate = GET_RAW_TYPE.is(classWithNameOf(SomeAnnotation.class)); Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areAnnotatedWith(hasNamePredicate)) @@ -1317,9 +1307,9 @@ public void only_areAnnotatedWith_predicate(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotAnnotatedWith_predicate(ClassesThat classesShouldOnlyThatRuleStart) { DescribedPredicate hasNamePredicate = GET_RAW_TYPE.is(classWithNameOf(SomeAnnotation.class)); Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areNotAnnotatedWith(hasNamePredicate)) @@ -1348,9 +1338,9 @@ public void only_areMetaAnnotatedWith_type_dependency() { assertThatTypes(classes).matchInAnyOrder(ClassAccessingSimpleClass.class, MetaAnnotatedAnnotation.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areNotMetaAnnotatedWith_type(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotMetaAnnotatedWith_type(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areNotMetaAnnotatedWith(SomeAnnotation.class)) .on(ClassAccessingMetaAnnotatedClass.class, ClassAccessingAnnotatedClass.class, ClassAccessingSimpleClass.class, @@ -1379,9 +1369,9 @@ public void only_areMetaAnnotatedWith_typeName_dependency() { assertThatTypes(classes).matchInAnyOrder(ClassAccessingSimpleClass.class, MetaAnnotatedAnnotation.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areNotMetaAnnotatedWith_typeName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotMetaAnnotatedWith_typeName(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areNotMetaAnnotatedWith(SomeAnnotation.class.getName())) .on(ClassAccessingMetaAnnotatedClass.class, ClassAccessingAnnotatedClass.class, ClassAccessingSimpleClass.class, @@ -1412,9 +1402,9 @@ public void only_areMetaAnnotatedWith_predicate_dependency() { assertThatTypes(classes).matchInAnyOrder(ClassAccessingSimpleClass.class, MetaAnnotatedAnnotation.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areNotMetaAnnotatedWith_predicate(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotMetaAnnotatedWith_predicate(ClassesThat classesShouldOnlyThatRuleStart) { DescribedPredicate hasNamePredicate = GET_RAW_TYPE.is(classWithNameOf(SomeAnnotation.class)); Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areNotMetaAnnotatedWith(hasNamePredicate)) @@ -1424,9 +1414,9 @@ public void only_areNotMetaAnnotatedWith_predicate(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_implement_type(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.implement(Collection.class)) .on(ClassAccessingArrayList.class, ClassAccessingList.class, ClassAccessingIterable.class); @@ -1434,9 +1424,9 @@ public void only_implement_type(ClassesThat classesSho assertThatTypes(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_doNotImplement_type(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_doNotImplement_type(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.doNotImplement(Collection.class)) .on(ClassAccessingArrayList.class, ClassAccessingList.class, ClassAccessingIterable.class); @@ -1444,9 +1434,9 @@ public void only_doNotImplement_type(ClassesThat class assertThatType(getOnlyElement(classes)).matches(ClassAccessingArrayList.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_implement_typeName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_implement_typeName(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.implement(Collection.class.getName())) .on(ClassAccessingArrayList.class, ClassAccessingList.class, ClassAccessingIterable.class); @@ -1454,9 +1444,9 @@ public void only_implement_typeName(ClassesThat classe assertThatTypes(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_doNotImplement_typeName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_doNotImplement_typeName(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.doNotImplement(Collection.class.getName())) .on(ClassAccessingArrayList.class, ClassAccessingList.class, ClassAccessingIterable.class); @@ -1464,9 +1454,9 @@ public void only_doNotImplement_typeName(ClassesThat c assertThatType(getOnlyElement(classes)).matches(ClassAccessingArrayList.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_implement_predicate(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_implement_predicate(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.implement(classWithNameOf(Collection.class))) .on(ClassAccessingArrayList.class, ClassAccessingList.class, ClassAccessingIterable.class); @@ -1474,9 +1464,9 @@ public void only_implement_predicate(ClassesThat class assertThatTypes(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_doNotImplement_predicate(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_doNotImplement_predicate(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.doNotImplement(classWithNameOf(Collection.class))) .on(ClassAccessingArrayList.class, ClassAccessingList.class, ClassAccessingIterable.class); @@ -1484,9 +1474,9 @@ public void only_doNotImplement_predicate(ClassesThat assertThatType(getOnlyElement(classes)).matches(ClassAccessingArrayList.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areAssignableTo_type(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areAssignableTo_type(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areAssignableTo(Collection.class)) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1494,9 +1484,9 @@ public void only_areAssignableTo_type(ClassesThat clas assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areNotAssignableTo_type(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotAssignableTo_type(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areNotAssignableTo(Collection.class)) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1504,9 +1494,9 @@ public void only_areNotAssignableTo_type(ClassesThat c assertThatType(getOnlyElement(classes)).matches(ClassAccessingList.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areAssignableTo_typeName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areAssignableTo_typeName(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areAssignableTo(Collection.class.getName())) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1514,9 +1504,9 @@ public void only_areAssignableTo_typeName(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areNotAssignableTo_typeName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotAssignableTo_typeName(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areNotAssignableTo(Collection.class.getName())) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1524,9 +1514,9 @@ public void only_areNotAssignableTo_typeName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areAssignableTo_predicate(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areAssignableTo(classWithNameOf(Collection.class))) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1534,9 +1524,9 @@ public void only_areAssignableTo_predicate(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areNotAssignableTo_predicate(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotAssignableTo_predicate(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areNotAssignableTo(classWithNameOf(Collection.class))) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingIterable.class); @@ -1544,9 +1534,9 @@ public void only_areNotAssignableTo_predicate(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areAssignableFrom_type(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areAssignableFrom(Collection.class)) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -1555,9 +1545,9 @@ public void only_areAssignableFrom_type(ClassesThat cl assertThatTypes(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingString.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areNotAssignableFrom_type(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotAssignableFrom_type(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areNotAssignableFrom(Collection.class)) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -1566,9 +1556,9 @@ public void only_areNotAssignableFrom_type(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingCollection.class, ClassAccessingIterable.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areAssignableFrom_typeName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areAssignableFrom_typeName(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areAssignableFrom(Collection.class.getName())) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -1577,9 +1567,9 @@ public void only_areAssignableFrom_typeName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotAssignableFrom_typeName(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areNotAssignableFrom(Collection.class.getName())) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -1588,9 +1578,9 @@ public void only_areNotAssignableFrom_typeName(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areAssignableFrom_predicate(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areAssignableFrom(classWithNameOf(Collection.class))) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -1599,9 +1589,9 @@ public void only_areAssignableFrom_predicate(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotAssignableFrom_predicate(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areNotAssignableFrom(classWithNameOf(Collection.class))) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -1610,9 +1600,9 @@ public void only_areNotAssignableFrom_predicate(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areInterfaces_predicate(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areInterfaces()) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -1621,9 +1611,9 @@ public void only_areInterfaces_predicate(ClassesThat c assertThatTypes(classes).matchInAnyOrder(ClassAccessingString.class, ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("classes_should_only_that_rule_starts") - public void only_areNotInterfaces_predicate(ClassesThat classesShouldOnlyThatRuleStart) { + @ParameterizedTest + @MethodSource("classes_should_only_that_rule_starts") + void only_areNotInterfaces_predicate(ClassesThat classesShouldOnlyThatRuleStart) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyThatRuleStart.areNotInterfaces()) .on(ClassAccessingList.class, ClassAccessingString.class, @@ -1632,17 +1622,16 @@ public void only_areNotInterfaces_predicate(ClassesThat no_classes_should_predicate_rule_starts() { + return Stream.of( noClasses().should().accessClassesThat(are(not(assignableFrom(classWithNameOf(Collection.class))))), noClasses().should().dependOnClassesThat(are(not(assignableFrom(classWithNameOf(Collection.class))))) ); } - @Test - @UseDataProvider("no_classes_should_predicate_rule_starts") - public void shouldThat_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("no_classes_should_predicate_rule_starts") + void shouldThat_predicate(ArchRule rule) { Set classes = filterClassesAppearingInFailureReport(rule) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingCollection.class, ClassAccessingIterable.class); @@ -1650,17 +1639,16 @@ public void shouldThat_predicate(ArchRule rule) { assertThatTypes(classes).matchInAnyOrder(ClassAccessingList.class, ClassAccessingString.class); } - @DataProvider - public static Object[][] classes_should_only_predicate_rule_starts() { - return testForEach( + static Stream classes_should_only_predicate_rule_starts() { + return Stream.of( classes().should().onlyAccessClassesThat(are(assignableFrom(classWithNameOf(Collection.class)))), classes().should().onlyDependOnClassesThat(are(assignableFrom(classWithNameOf(Collection.class)))) ); } - @Test - @UseDataProvider("classes_should_only_predicate_rule_starts") - public void shouldThatOnly_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("classes_should_only_predicate_rule_starts") + void shouldThatOnly_predicate(ArchRule rule) { Set classes = filterClassesAppearingInFailureReport(rule) .on(ClassAccessingList.class, ClassAccessingString.class, ClassAccessingCollection.class, ClassAccessingIterable.class); @@ -1747,9 +1735,9 @@ static class Level2TransitivelyDependentClass2 { } } - @Test - @DataProvider(value = {"true", "false"}) - public void transitivelyDependOnClassesThat_reports_all_transitive_dependencies(boolean viaPredicate) { + @ParameterizedTest + @ValueSource(booleans = {true, false}) + void transitivelyDependOnClassesThat_reports_all_transitive_dependencies(boolean viaPredicate) { Class testClass1 = TransitivelyDependOnClassesThatTestCases.TestClass.class; Class testClass2 = TransitivelyDependOnClassesThatTestCases.TestClassNotViolatingBecauseOnlyDependingOnOtherSelectedClass.class; Class directlyDependentClass1 = TransitivelyDependOnClassesThatTestCases.DirectlyDependentClass1.class; diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ShouldOnlyByClassesThatTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ShouldOnlyByClassesThatTest.java index e9e952f610..d4ce15aced 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ShouldOnlyByClassesThatTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ShouldOnlyByClassesThatTest.java @@ -4,6 +4,7 @@ import java.lang.annotation.RetentionPolicy; import java.util.Set; import java.util.function.Function; +import java.util.stream.Stream; import com.tngtech.archunit.base.DescribedPredicate; import com.tngtech.archunit.core.domain.JavaClass; @@ -16,14 +17,9 @@ import com.tngtech.archunit.lang.syntax.elements.testclasses.innerclassaccess.ClassWithInnerClasses.ClassAccessingInnerMemberClass; import com.tngtech.archunit.lang.syntax.elements.testclasses.innerclassaccess.ClassWithInnerClasses.InnerMemberClassBeingAccessed; import com.tngtech.archunit.lang.syntax.elements.testclasses.otheraccess.ClassAlsoAccessingOtherClass; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.base.DescribedPredicate.equalTo; import static com.tngtech.archunit.base.DescribedPredicate.not; @@ -40,27 +36,21 @@ import static com.tngtech.archunit.lang.syntax.elements.ClassesShouldEvaluator.filterClassesAppearingInFailureReport; import static com.tngtech.archunit.lang.syntax.elements.ClassesShouldEvaluator.filterViolationCausesInFailureReport; import static com.tngtech.archunit.testutil.Assertions.assertThatTypes; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; import static java.util.regex.Pattern.quote; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class ShouldOnlyByClassesThatTest { - @Rule - public final MockitoRule rule = MockitoJUnit.rule(); - - @DataProvider - public static Object[][] should_only_be_by_rule_starts() { - return testForEach( + static Stream> should_only_be_by_rule_starts() { + return Stream.of( classes().should().onlyBeAccessed().byClassesThat(), classes().should().onlyHaveDependentClassesThat() ); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void haveFullyQualifiedName(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void haveFullyQualifiedName(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.haveFullyQualifiedName(Foo.class.getName())) .on(ClassAccessedByFoo.class, Foo.class, @@ -72,9 +62,9 @@ public void haveFullyQualifiedName(ClassesThat classes ClassAccessedByBaz.class, Baz.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void doNotHaveFullyQualifiedName(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void doNotHaveFullyQualifiedName(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.doNotHaveFullyQualifiedName(Foo.class.getName())) .on(ClassAccessedByFoo.class, Foo.class, @@ -84,9 +74,9 @@ public void doNotHaveFullyQualifiedName(ClassesThat cl assertThatTypes(classes).matchInAnyOrder(ClassAccessedByFoo.class, Foo.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void haveSimpleName(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void haveSimpleName(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.haveSimpleName(Foo.class.getSimpleName())) .on(ClassAccessedByFoo.class, Foo.class, @@ -98,9 +88,9 @@ public void haveSimpleName(ClassesThat classesShouldOn ClassAccessedByBaz.class, Baz.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void doNotHaveSimpleName(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void doNotHaveSimpleName(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.doNotHaveSimpleName(Foo.class.getSimpleName())) .on(ClassAccessedByFoo.class, Foo.class, @@ -110,9 +100,9 @@ public void doNotHaveSimpleName(ClassesThat classesSho assertThatTypes(classes).matchInAnyOrder(ClassAccessedByFoo.class, Foo.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void haveNameMatching(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void haveNameMatching(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.haveNameMatching(".*\\$Foo")) .on(ClassAccessedByFoo.class, Foo.class, @@ -124,9 +114,9 @@ public void haveNameMatching(ClassesThat classesShould ClassAccessedByBaz.class, Baz.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void haveNameNotMatching(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void haveNameNotMatching(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.haveNameNotMatching(".*\\$Foo")) .on(ClassAccessedByFoo.class, Foo.class, @@ -136,9 +126,9 @@ public void haveNameNotMatching(ClassesThat classesSho assertThatTypes(classes).matchInAnyOrder(ClassAccessedByFoo.class, Foo.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void haveSimpleNameStartingWith(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void haveSimpleNameStartingWith(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.haveSimpleNameStartingWith("Fo")) .on(ClassAccessedByFoo.class, Foo.class, @@ -150,9 +140,9 @@ public void haveSimpleNameStartingWith(ClassesThat cla ClassAccessedByBaz.class, Baz.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void haveSimpleNameNotStartingWith(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void haveSimpleNameNotStartingWith(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.haveSimpleNameNotStartingWith("Fo")) .on(ClassAccessedByFoo.class, Foo.class, @@ -163,9 +153,9 @@ public void haveSimpleNameNotStartingWith(ClassesThat ClassAccessedByFoo.class, Foo.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void haveSimpleNameContaining(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void haveSimpleNameContaining(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.haveSimpleNameContaining("o")) .on(ClassAccessedByFoo.class, Foo.class, @@ -177,9 +167,9 @@ public void haveSimpleNameContaining(ClassesThat class ClassAccessedByBaz.class, Baz.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void haveSimpleNameNotContaining(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void haveSimpleNameNotContaining(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.haveSimpleNameNotContaining("o")) .on(ClassAccessedByFoo.class, Foo.class, @@ -190,9 +180,9 @@ public void haveSimpleNameNotContaining(ClassesThat cl ClassAccessedByFoo.class, Foo.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void haveSimpleNameEndingWith(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void haveSimpleNameEndingWith(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.haveSimpleNameEndingWith("oo")) .on(ClassAccessedByFoo.class, Foo.class, @@ -204,9 +194,9 @@ public void haveSimpleNameEndingWith(ClassesThat class ClassAccessedByBaz.class, Baz.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void haveSimpleNameNotEndingWith(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void haveSimpleNameNotEndingWith(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.haveSimpleNameNotEndingWith("oo")) .on(ClassAccessedByFoo.class, Foo.class, @@ -217,9 +207,9 @@ public void haveSimpleNameNotEndingWith(ClassesThat cl ClassAccessedByFoo.class, Foo.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void resideInAPackage(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void resideInAPackage(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.resideInAPackage("..access..")) .on(ClassAccessingOtherClass.class, ClassAlsoAccessingOtherClass.class, ClassBeingAccessedByOtherClass.class); @@ -227,9 +217,9 @@ public void resideInAPackage(ClassesThat classesShould assertThatTypes(classes).matchInAnyOrder(ClassAlsoAccessingOtherClass.class, ClassBeingAccessedByOtherClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void resideOutsideOfPackage(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void resideOutsideOfPackage(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.resideOutsideOfPackage("..access..")) .on(ClassAccessingOtherClass.class, ClassAlsoAccessingOtherClass.class, ClassBeingAccessedByOtherClass.class); @@ -237,9 +227,9 @@ public void resideOutsideOfPackage(ClassesThat classes assertThatTypes(classes).matchInAnyOrder(ClassAccessingOtherClass.class, ClassBeingAccessedByOtherClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void resideInAnyPackage(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void resideInAnyPackage(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.resideInAnyPackage("..access..", "..otheraccess..")) .on(ClassAccessingOtherClass.class, ClassAlsoAccessingOtherClass.class, @@ -248,9 +238,9 @@ public void resideInAnyPackage(ClassesThat classesShou assertThatTypes(classes).matchInAnyOrder(YetAnotherClassAccessingOtherClass.class, ClassBeingAccessedByOtherClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void resideOutsideOfPackages(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void resideOutsideOfPackages(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.resideOutsideOfPackages("..access..", "..otheraccess..") ).on(ClassAccessingOtherClass.class, ClassAlsoAccessingOtherClass.class, @@ -260,9 +250,9 @@ public void resideOutsideOfPackages(ClassesThat classe ClassAccessingOtherClass.class, ClassAlsoAccessingOtherClass.class, ClassBeingAccessedByOtherClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void arePublic(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void arePublic(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyBeBy.arePublic()) .on(ClassAccessedByPublicClass.class, ClassAccessedByPrivateClass.class, ClassAccessedByPackagePrivateClass.class, ClassAccessedByProtectedClass.class, @@ -275,9 +265,9 @@ public void arePublic(ClassesThat classesShouldOnlyBeB PackagePrivateClass.class, ProtectedClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotPublic(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotPublic(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyBeBy.areNotPublic()) .on(ClassAccessedByPublicClass.class, ClassAccessedByPrivateClass.class, ClassAccessedByPackagePrivateClass.class, ClassAccessedByProtectedClass.class, @@ -288,9 +278,9 @@ public void areNotPublic(ClassesThat classesShouldOnly ClassAccessedByPublicClass.class, PublicClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areProtected(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areProtected(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyBeBy.areProtected()) .on(ClassAccessedByPublicClass.class, ClassAccessedByPrivateClass.class, ClassAccessedByPackagePrivateClass.class, ClassAccessedByProtectedClass.class, @@ -303,9 +293,9 @@ public void areProtected(ClassesThat classesShouldOnly PrivateClass.class, PackagePrivateClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotProtected(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotProtected(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyBeBy.areNotProtected()) .on(ClassAccessedByPublicClass.class, ClassAccessedByPrivateClass.class, ClassAccessedByPackagePrivateClass.class, ClassAccessedByProtectedClass.class, @@ -316,9 +306,9 @@ public void areNotProtected(ClassesThat classesShouldO ClassAccessedByProtectedClass.class, ProtectedClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void arePackagePrivate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void arePackagePrivate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyBeBy.arePackagePrivate()) .on(ClassAccessedByPublicClass.class, ClassAccessedByPrivateClass.class, ClassAccessedByPackagePrivateClass.class, ClassAccessedByProtectedClass.class, @@ -331,9 +321,9 @@ public void arePackagePrivate(ClassesThat classesShoul PrivateClass.class, ProtectedClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotPackagePrivate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotPackagePrivate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyBeBy.areNotPackagePrivate()) .on(ClassAccessedByPublicClass.class, ClassAccessedByPrivateClass.class, ClassAccessedByPackagePrivateClass.class, ClassAccessedByProtectedClass.class, @@ -344,9 +334,9 @@ public void areNotPackagePrivate(ClassesThat classesSh ClassAccessedByPackagePrivateClass.class, PackagePrivateClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void arePrivate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void arePrivate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyBeBy.arePrivate()) .on(ClassAccessedByPublicClass.class, ClassAccessedByPrivateClass.class, ClassAccessedByPackagePrivateClass.class, ClassAccessedByProtectedClass.class, @@ -359,9 +349,9 @@ public void arePrivate(ClassesThat classesShouldOnlyBe PackagePrivateClass.class, ProtectedClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotPrivate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotPrivate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyBeBy.areNotPrivate()) .on(ClassAccessedByPublicClass.class, ClassAccessedByPrivateClass.class, ClassAccessedByPackagePrivateClass.class, ClassAccessedByProtectedClass.class, @@ -372,9 +362,9 @@ public void areNotPrivate(ClassesThat classesShouldOnl ClassAccessedByPrivateClass.class, PrivateClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void haveModifier(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void haveModifier(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyBeBy.haveModifier(PRIVATE)) .on(ClassAccessedByPublicClass.class, ClassAccessedByPrivateClass.class, ClassAccessedByPackagePrivateClass.class, ClassAccessedByProtectedClass.class, @@ -387,9 +377,9 @@ public void haveModifier(ClassesThat classesShouldOnly PackagePrivateClass.class, ProtectedClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void doNotHaveModifier(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void doNotHaveModifier(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyBeBy.doNotHaveModifier(PRIVATE)) .on(ClassAccessedByPublicClass.class, ClassAccessedByPrivateClass.class, ClassAccessedByPackagePrivateClass.class, ClassAccessedByProtectedClass.class, @@ -400,9 +390,9 @@ public void doNotHaveModifier(ClassesThat classesShoul ClassAccessedByPrivateClass.class, PrivateClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areAnnotatedWith_type(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areAnnotatedWith_type(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areAnnotatedWith(SomeAnnotation.class)) .on(ClassBeingAccessedByAnnotatedClass.class, AnnotatedClass.class, @@ -411,9 +401,9 @@ public void areAnnotatedWith_type(ClassesThat classesS assertThatTypes(classes).matchInAnyOrder(SimpleClass.class, ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotAnnotatedWith_type(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotAnnotatedWith_type(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotAnnotatedWith(SomeAnnotation.class)) .on(ClassBeingAccessedByAnnotatedClass.class, AnnotatedClass.class, @@ -422,9 +412,9 @@ public void areNotAnnotatedWith_type(ClassesThat class assertThatTypes(classes).matchInAnyOrder(ClassBeingAccessedByAnnotatedClass.class, AnnotatedClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areAnnotatedWith_typeName(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areAnnotatedWith_typeName(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areAnnotatedWith(SomeAnnotation.class.getName())) .on(ClassBeingAccessedByAnnotatedClass.class, AnnotatedClass.class, @@ -433,9 +423,9 @@ public void areAnnotatedWith_typeName(ClassesThat clas assertThatTypes(classes).matchInAnyOrder(SimpleClass.class, ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotAnnotatedWith_typeName(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotAnnotatedWith_typeName(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotAnnotatedWith(SomeAnnotation.class.getName())) .on(ClassBeingAccessedByAnnotatedClass.class, AnnotatedClass.class, @@ -444,9 +434,9 @@ public void areNotAnnotatedWith_typeName(ClassesThat c assertThatTypes(classes).matchInAnyOrder(ClassBeingAccessedByAnnotatedClass.class, AnnotatedClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areAnnotatedWith_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areAnnotatedWith_predicate(ClassesThat classesShouldOnlyBeBy) { DescribedPredicate hasNamePredicate = GET_RAW_TYPE.is(classWithNameOf(SomeAnnotation.class)); Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areAnnotatedWith(hasNamePredicate)) @@ -456,9 +446,9 @@ public void areAnnotatedWith_predicate(ClassesThat cla assertThatTypes(classes).matchInAnyOrder(SimpleClass.class, ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotAnnotatedWith_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotAnnotatedWith_predicate(ClassesThat classesShouldOnlyBeBy) { DescribedPredicate hasNamePredicate = GET_RAW_TYPE.is(classWithNameOf(SomeAnnotation.class)); Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotAnnotatedWith(hasNamePredicate)) @@ -468,9 +458,9 @@ public void areNotAnnotatedWith_predicate(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassBeingAccessedByAnnotatedClass.class, AnnotatedClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areMetaAnnotatedWith_type(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areMetaAnnotatedWith_type(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areMetaAnnotatedWith(SomeAnnotation.class)) .on(ClassBeingAccessedByMetaAnnotatedClass.class, MetaAnnotatedClass.class, @@ -509,9 +499,9 @@ public void areNotMetaAnnotatedWith_type_dependency() { ClassBeingAccessedByAnnotatedClass.class, AnnotatedClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areMetaAnnotatedWith_typeName(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areMetaAnnotatedWith_typeName(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areMetaAnnotatedWith(SomeAnnotation.class.getName())) .on(ClassBeingAccessedByMetaAnnotatedClass.class, MetaAnnotatedClass.class, @@ -550,9 +540,9 @@ public void areNotMetaAnnotatedWith_typeName_dependency() { ClassBeingAccessedByAnnotatedClass.class, AnnotatedClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areMetaAnnotatedWith_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areMetaAnnotatedWith_predicate(ClassesThat classesShouldOnlyBeBy) { DescribedPredicate hasNamePredicate = GET_RAW_TYPE.is(classWithNameOf(SomeAnnotation.class)); Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areMetaAnnotatedWith(hasNamePredicate)) @@ -594,9 +584,9 @@ public void areNotMetaAnnotatedWith_predicate_dependency() { ClassBeingAccessedByAnnotatedClass.class, AnnotatedClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void implement_type(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void implement_type(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.implement(SomeInterface.class)) .on(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class, @@ -605,9 +595,9 @@ public void implement_type(ClassesThat classesShouldOn assertThatTypes(classes).matchInAnyOrder(SimpleClass.class, ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void doNotImplement_type(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void doNotImplement_type(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.doNotImplement(SomeInterface.class)) .on(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class, @@ -616,9 +606,9 @@ public void doNotImplement_type(ClassesThat classesSho assertThatTypes(classes).matchInAnyOrder(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void implement_typeName(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void implement_typeName(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.implement(SomeInterface.class.getName())) .on(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class, @@ -627,9 +617,9 @@ public void implement_typeName(ClassesThat classesShou assertThatTypes(classes).matchInAnyOrder(SimpleClass.class, ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void doNotImplement_typeName(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void doNotImplement_typeName(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.doNotImplement(SomeInterface.class.getName())) .on(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class, @@ -638,9 +628,9 @@ public void doNotImplement_typeName(ClassesThat classe assertThatTypes(classes).matchInAnyOrder(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void implement_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void implement_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.implement(classWithNameOf(SomeInterface.class))) .on(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class, @@ -649,9 +639,9 @@ public void implement_predicate(ClassesThat classesSho assertThatTypes(classes).matchInAnyOrder(SimpleClass.class, ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void doNotImplement_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void doNotImplement_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.doNotImplement(classWithNameOf(SomeInterface.class))) .on(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class, @@ -660,9 +650,9 @@ public void doNotImplement_predicate(ClassesThat class assertThatTypes(classes).matchInAnyOrder(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areAssignableTo_type(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areAssignableTo_type(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areAssignableTo(SomeInterface.class)) .on(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class, @@ -671,9 +661,9 @@ public void areAssignableTo_type(ClassesThat classesSh assertThatTypes(classes).matchInAnyOrder(SimpleClass.class, ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotAssignableTo_type(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotAssignableTo_type(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotAssignableTo(SomeInterface.class)) .on(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class, @@ -682,9 +672,9 @@ public void areNotAssignableTo_type(ClassesThat classe assertThatTypes(classes).matchInAnyOrder(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areAssignableTo_typeName(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areAssignableTo_typeName(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areAssignableTo(SomeInterface.class.getName())) .on(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class, @@ -693,9 +683,9 @@ public void areAssignableTo_typeName(ClassesThat class assertThatTypes(classes).matchInAnyOrder(SimpleClass.class, ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotAssignableTo_typeName(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotAssignableTo_typeName(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotAssignableTo(SomeInterface.class.getName())) .on(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class, @@ -704,9 +694,9 @@ public void areNotAssignableTo_typeName(ClassesThat cl assertThatTypes(classes).matchInAnyOrder(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areAssignableTo_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areAssignableTo_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areAssignableTo(classWithNameOf(SomeInterface.class))) .on(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class, @@ -715,9 +705,9 @@ public void areAssignableTo_predicate(ClassesThat clas assertThatTypes(classes).matchInAnyOrder(SimpleClass.class, ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotAssignableTo_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotAssignableTo_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotAssignableTo(classWithNameOf(SomeInterface.class))) .on(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class, @@ -726,9 +716,9 @@ public void areNotAssignableTo_predicate(ClassesThat c assertThatTypes(classes).matchInAnyOrder(ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areAssignableFrom_type(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areAssignableFrom_type(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areAssignableFrom(ClassExtendingClass.class)) .on(ClassExtendingClass.class, ClassImplementingSomeInterface.class, @@ -737,9 +727,9 @@ public void areAssignableFrom_type(ClassesThat classes assertThatTypes(classes).matchInAnyOrder(SimpleClass.class, ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotAssignableFrom_type(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotAssignableFrom_type(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotAssignableFrom(ClassExtendingClass.class)) .on(ClassExtendingClass.class, ClassImplementingSomeInterface.class, @@ -749,9 +739,9 @@ public void areNotAssignableFrom_type(ClassesThat clas ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areAssignableFrom_typeName(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areAssignableFrom_typeName(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areAssignableFrom(ClassExtendingClass.class.getName())) .on(ClassExtendingClass.class, ClassImplementingSomeInterface.class, @@ -760,9 +750,9 @@ public void areAssignableFrom_typeName(ClassesThat cla assertThatTypes(classes).matchInAnyOrder(SimpleClass.class, ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotAssignableFrom_typeName(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotAssignableFrom_typeName(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotAssignableFrom(ClassExtendingClass.class.getName())) .on(ClassExtendingClass.class, ClassImplementingSomeInterface.class, @@ -772,9 +762,9 @@ public void areNotAssignableFrom_typeName(ClassesThat ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areAssignableFrom_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areAssignableFrom_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areAssignableFrom(classWithNameOf(ClassExtendingClass.class))) .on(ClassExtendingClass.class, ClassImplementingSomeInterface.class, @@ -783,9 +773,9 @@ public void areAssignableFrom_predicate(ClassesThat cl assertThatTypes(classes).matchInAnyOrder(SimpleClass.class, ClassAccessingSimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotAssignableFrom_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotAssignableFrom_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotAssignableFrom(classWithNameOf(ClassExtendingClass.class))) .on(ClassExtendingClass.class, ClassImplementingSomeInterface.class, @@ -795,9 +785,9 @@ public void areNotAssignableFrom_predicate(ClassesThat ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areInterfaces_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areInterfaces_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areInterfaces()) .on(ClassAccessingSimpleClass.class, SimpleClass.class, ClassBeingAccessedByInterface.class, InterfaceAccessingAClass.class); @@ -805,9 +795,9 @@ public void areInterfaces_predicate(ClassesThat classe assertThatTypes(classes).matchInAnyOrder(ClassAccessingSimpleClass.class, SimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotInterfaces_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotInterfaces_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotInterfaces()) .on(ClassAccessingSimpleClass.class, SimpleClass.class, ClassBeingAccessedByInterface.class, InterfaceAccessingAClass.class); @@ -815,9 +805,9 @@ public void areNotInterfaces_predicate(ClassesThat cla assertThatTypes(classes).matchInAnyOrder(ClassBeingAccessedByInterface.class, InterfaceAccessingAClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areEnums_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areEnums_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areEnums()) .on(ClassAccessingSimpleClass.class, SimpleClass.class, ClassBeingAccessedByEnum.class, EnumAccessingAClass.class); @@ -825,9 +815,9 @@ public void areEnums_predicate(ClassesThat classesShou assertThatTypes(classes).matchInAnyOrder(ClassAccessingSimpleClass.class, SimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotEnums_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotEnums_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotEnums()) .on(ClassAccessingSimpleClass.class, SimpleClass.class, ClassBeingAccessedByEnum.class, EnumAccessingAClass.class); @@ -835,9 +825,9 @@ public void areNotEnums_predicate(ClassesThat classesS assertThatTypes(classes).matchInAnyOrder(ClassBeingAccessedByEnum.class, EnumAccessingAClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areAnnotations_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areAnnotations_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areAnnotations()) .on(ClassAccessingSimpleClass.class, SimpleClass.class, ClassBeingAccessedByAnnotation.class, AnnotationAccessingAClass.class); @@ -845,9 +835,9 @@ public void areAnnotations_predicate(ClassesThat class assertThatTypes(classes).matchInAnyOrder(ClassAccessingSimpleClass.class, SimpleClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotAnnotations_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotAnnotations_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotAnnotations()) .on(ClassAccessingSimpleClass.class, SimpleClass.class, ClassBeingAccessedByAnnotation.class, AnnotationAccessingAClass.class); @@ -867,9 +857,9 @@ public void areNotRecords_predicate() { classes().should().onlyBeAccessed().byClassesThat().areNotRecords(); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areTopLevelClasses_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areTopLevelClasses_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areTopLevelClasses()) .on(ClassAccessingOtherClass.class, ClassBeingAccessedByOtherClass.class, @@ -878,9 +868,9 @@ public void areTopLevelClasses_predicate(ClassesThat c assertThatTypes(classes).matchInAnyOrder(ClassAccessingStaticNestedClass.class, StaticNestedClassBeingAccessed.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotTopLevelClasses_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotTopLevelClasses_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotTopLevelClasses()) .on(ClassAccessingOtherClass.class, ClassBeingAccessedByOtherClass.class, @@ -889,9 +879,9 @@ public void areNotTopLevelClasses_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNestedClasses_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNestedClasses()) .on(ClassAccessingStaticNestedClass.class, StaticNestedClassBeingAccessed.class, @@ -900,9 +890,9 @@ public void areNestedClasses_predicate(ClassesThat cla assertThatTypes(classes).matchInAnyOrder(ClassAccessingOtherClass.class, ClassBeingAccessedByOtherClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotNestedClasses_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotNestedClasses_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotNestedClasses()) .on(ClassAccessingStaticNestedClass.class, StaticNestedClassBeingAccessed.class, @@ -911,9 +901,9 @@ public void areNotNestedClasses_predicate(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingStaticNestedClass.class, StaticNestedClassBeingAccessed.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areMemberClasses_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areMemberClasses_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areMemberClasses()) .on(ClassAccessingStaticNestedClass.class, StaticNestedClassBeingAccessed.class, @@ -922,9 +912,9 @@ public void areMemberClasses_predicate(ClassesThat cla assertThatTypes(classes).matchInAnyOrder(ClassAccessingOtherClass.class, ClassBeingAccessedByOtherClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotMemberClasses_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotMemberClasses_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotMemberClasses()) .on(ClassAccessingStaticNestedClass.class, StaticNestedClassBeingAccessed.class, @@ -933,9 +923,9 @@ public void areNotMemberClasses_predicate(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingStaticNestedClass.class, StaticNestedClassBeingAccessed.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areInnerClasses_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areInnerClasses_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areInnerClasses()) .on(ClassAccessingInnerMemberClass.class, InnerMemberClassBeingAccessed.class, @@ -944,9 +934,9 @@ public void areInnerClasses_predicate(ClassesThat clas assertThatTypes(classes).matchInAnyOrder(ClassAccessingOtherClass.class, ClassBeingAccessedByOtherClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotInnerClasses_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotInnerClasses_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotInnerClasses()) .on(ClassAccessingInnerMemberClass.class, InnerMemberClassBeingAccessed.class, @@ -956,9 +946,9 @@ public void areNotInnerClasses_predicate(ClassesThat c ClassAccessingInnerMemberClass.class, InnerMemberClassBeingAccessed.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areAnonymousClasses_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areAnonymousClasses_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areAnonymousClasses()) .on(ClassAccessingAnonymousClass_Reference, anonymousClassBeingAccessed.getClass(), @@ -967,9 +957,9 @@ public void areAnonymousClasses_predicate(ClassesThat assertThatTypes(classes).matchInAnyOrder(ClassAccessingOtherClass.class, ClassBeingAccessedByOtherClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotAnonymousClasses_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotAnonymousClasses_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotAnonymousClasses()) .on(ClassAccessingAnonymousClass_Reference, anonymousClassBeingAccessed.getClass(), @@ -978,9 +968,9 @@ public void areNotAnonymousClasses_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areLocalClasses_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areLocalClasses()) .on(ClassAccessingLocalClass_Reference, ClassBeingAccessedByLocalClass.getLocalClass(), @@ -989,9 +979,9 @@ public void areLocalClasses_predicate(ClassesThat clas assertThatTypes(classes).matchInAnyOrder(ClassAccessingOtherClass.class, ClassBeingAccessedByOtherClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void areNotLocalClasses_predicate(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void areNotLocalClasses_predicate(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport( classesShouldOnlyBeBy.areNotLocalClasses()) .on(ClassAccessingLocalClass_Reference, ClassBeingAccessedByLocalClass.getLocalClass(), @@ -1000,9 +990,9 @@ public void areNotLocalClasses_predicate(ClassesThat c assertThatTypes(classes).matchInAnyOrder(ClassAccessingLocalClass_Reference, ClassBeingAccessedByLocalClass.getLocalClass()); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void belongToAnyOf(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void belongToAnyOf(ClassesThat classesShouldOnlyBeBy) { Set classes = filterViolationCausesInFailureReport( classesShouldOnlyBeBy.belongToAnyOf(ClassWithInnerClasses.class)) .on(ClassWithInnerClasses.class, ClassWithInnerClasses.InnerClass.class, @@ -1014,9 +1004,9 @@ public void belongToAnyOf(ClassesThat classesShouldOnl assertThatTypes(classes).matchInAnyOrder(AnotherClassWithInnerClasses.InnerClass.EvenMoreInnerClass.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void doNotBelongToAnyOf(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void doNotBelongToAnyOf(ClassesThat classesShouldOnlyBeBy) { Set classes = filterViolationCausesInFailureReport( classesShouldOnlyBeBy.doNotBelongToAnyOf(ClassWithInnerClasses.class)) .on(ClassWithInnerClasses.class, ClassWithInnerClasses.InnerClass.class, @@ -1061,45 +1051,45 @@ static class Target { } } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void containAnyMembersThat(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void containAnyMembersThat(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyBeBy.containAnyMembersThat(have(name("aField")))) .on(Data_of_containAnyMembersThat.OkayOrigin.class, Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.Target.class); assertThatTypes(classes).matchInAnyOrder(Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.Target.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void containAnyFieldsThat(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void containAnyFieldsThat(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyBeBy.containAnyFieldsThat(have(name("aField")))) .on(Data_of_containAnyMembersThat.OkayOrigin.class, Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.Target.class); assertThatTypes(classes).matchInAnyOrder(Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.Target.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void containAnyCodeUnitsThat(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void containAnyCodeUnitsThat(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyBeBy.containAnyCodeUnitsThat(have(name("aMethod")))) .on(Data_of_containAnyMembersThat.OkayOrigin.class, Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.Target.class); assertThatTypes(classes).matchInAnyOrder(Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.Target.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void containAnyMethodsThat(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void containAnyMethodsThat(ClassesThat classesShouldOnlyBeBy) { Set classes = filterClassesAppearingInFailureReport(classesShouldOnlyBeBy.containAnyMethodsThat(have(name("aMethod")))) .on(Data_of_containAnyMembersThat.OkayOrigin.class, Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.Target.class); assertThatTypes(classes).matchInAnyOrder(Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.Target.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void containAnyConstructorsThat(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void containAnyConstructorsThat(ClassesThat classesShouldOnlyBeBy) { ArchRule rule = classesShouldOnlyBeBy.containAnyConstructorsThat(have(fullNameMatching(".*" + quote(Object.class.getName()) + ".*"))); Set classes = filterClassesAppearingInFailureReport(rule) .on(Data_of_containAnyMembersThat.OkayOrigin.class, Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.Target.class); @@ -1107,9 +1097,9 @@ public void containAnyConstructorsThat(ClassesThat cla assertThatTypes(classes).matchInAnyOrder(Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.Target.class); } - @Test - @UseDataProvider("should_only_be_by_rule_starts") - public void containAnyStaticInitializersThat(ClassesThat classesShouldOnlyBeBy) { + @ParameterizedTest + @MethodSource("should_only_be_by_rule_starts") + void containAnyStaticInitializersThat(ClassesThat classesShouldOnlyBeBy) { ArchRule rule = classesShouldOnlyBeBy.containAnyStaticInitializersThat(have(fullNameMatching(quote(Data_of_containAnyMembersThat.OkayOrigin.class.getName()) + ".*"))); Set classes = filterClassesAppearingInFailureReport(rule) .on(Data_of_containAnyMembersThat.OkayOrigin.class, Data_of_containAnyMembersThat.ViolatingOrigin.class, Data_of_containAnyMembersThat.Target.class); @@ -1117,16 +1107,15 @@ public void containAnyStaticInitializersThat(ClassesThat byClassesThat_predicate_rules() { + return Stream.of( classes().should().onlyBeAccessed().byClassesThat(are(not(assignableFrom(classWithNameOf(ClassExtendingClass.class))))), classes().should().onlyHaveDependentClassesThat(are(not(assignableFrom(classWithNameOf(ClassExtendingClass.class)))))); } - @Test - @UseDataProvider("byClassesThat_predicate_rules") - public void classesThat_predicate(ArchRule rule) { + @ParameterizedTest + @MethodSource("byClassesThat_predicate_rules") + void classesThat_predicate(ArchRule rule) { Set classes = filterClassesAppearingInFailureReport(rule) .on(ClassExtendingClass.class, ClassImplementingSomeInterface.class, ClassBeingAccessedByClassImplementingSomeInterface.class, SimpleClass.class, ClassAccessingSimpleClass.class); diff --git a/archunit/src/test/java/com/tngtech/archunit/library/LayeredArchitectureTest.java b/archunit/src/test/java/com/tngtech/archunit/library/LayeredArchitectureTest.java index f60adc3014..a3c3b0e7d0 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/LayeredArchitectureTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/LayeredArchitectureTest.java @@ -5,6 +5,7 @@ import java.util.Iterator; import java.util.List; import java.util.Set; +import java.util.stream.Stream; import com.google.common.base.Joiner; import com.google.common.collect.ImmutableSet; @@ -29,13 +30,9 @@ import com.tngtech.archunit.library.testclasses.second.three.any.SecondThreeAnyClass; import com.tngtech.archunit.library.testclasses.some.pkg.SomePkgClass; import com.tngtech.archunit.library.testclasses.some.pkg.sub.SomePkgSubclass; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.DataProviders; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Assert; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.api.Test; import static com.tngtech.archunit.core.domain.JavaClass.Predicates.resideInAnyPackage; import static com.tngtech.archunit.core.domain.JavaClass.Predicates.simpleName; @@ -44,19 +41,17 @@ import static com.tngtech.archunit.library.Architectures.layeredArchitecture; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; import static com.tngtech.archunit.testutil.TestUtils.union; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; import static java.lang.System.lineSeparator; import static java.util.regex.Pattern.quote; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.fail; -@RunWith(DataProviderRunner.class) public class LayeredArchitectureTest { private static final String NEW_LINE_REPLACE = "###"; - @DataProvider - public static Object[][] layeredArchitectureDefinitions() { - return testForEach( + static Stream layeredArchitectureDefinitions() { + return Stream.of( layeredArchitecture() .consideringAllDependencies() .layer("One").definedBy("..library.testclasses.some.pkg..") @@ -81,9 +76,9 @@ public static Object[][] layeredArchitectureDefinitions() { .whereLayer("Three").mayOnlyBeAccessedByLayers("One", "Two")); } - @Test - @UseDataProvider("layeredArchitectureDefinitions") - public void layered_architecture_description(LayeredArchitecture architecture) { + @ParameterizedTest + @MethodSource("layeredArchitectureDefinitions") + void layered_architecture_description(LayeredArchitecture architecture) { assertThat(architecture.getDescription()).isEqualTo( "Layered architecture considering all dependencies, consisting of" + lineSeparator() + "layer 'One' ('..library.testclasses.some.pkg..')" + lineSeparator() + @@ -199,9 +194,9 @@ public void layered_architecture_allows_individual_empty_optionalLayer() { assertThat(result.getFailureReport().isEmpty()).as("failure report").isTrue(); } - @Test - @UseDataProvider("layeredArchitectureDefinitions") - public void layered_architecture_gathers_all_layer_violations(LayeredArchitecture architecture) { + @ParameterizedTest + @MethodSource("layeredArchitectureDefinitions") + void layered_architecture_gathers_all_layer_violations(LayeredArchitecture architecture) { JavaClasses classes = new ClassFileImporter().importPackages(absolute("")); EvaluationResult result = architecture.evaluate(classes); @@ -216,14 +211,13 @@ public void layered_architecture_gathers_all_layer_violations(LayeredArchitectur expectedFieldTypePattern(SecondThreeAnyClass.class, "illegalTarget", SomePkgClass.class))); } - @DataProvider - public static Object[][] toIgnore() { + static Stream toIgnore() { LayeredArchitecture layeredArchitecture = layeredArchitecture() .consideringAllDependencies() .layer("One").definedBy(absolute("some.pkg..")) .whereLayer("One").mayNotBeAccessedByAnyLayer(); - return DataProviders.testForEach( + return Stream.of( new RuleWithIgnore( layeredArchitecture.ignoreDependency(FirstAnyPkgClass.class, SomePkgSubclass.class), "rule with ignore specified as class objects"), @@ -235,9 +229,9 @@ public static Object[][] toIgnore() { "rule with ignore specified as predicates")); } - @Test - @UseDataProvider("toIgnore") - public void layered_architecture_ignores_specified_violations(RuleWithIgnore layeredArchitectureWithIgnore) { + @ParameterizedTest + @MethodSource("toIgnore") + void layered_architecture_ignores_specified_violations(RuleWithIgnore layeredArchitectureWithIgnore) { JavaClasses classes = new ClassFileImporter().importClasses( FirstAnyPkgClass.class, SomePkgSubclass.class, SecondThreeAnyClass.class, SomePkgClass.class); @@ -271,9 +265,8 @@ public void layered_architecture_combines_multiple_ignores() { assertThat(layeredArchitecture.evaluate(classes).hasViolation()).as("result has violation").isFalse(); } - @DataProvider - public static Object[][] layeredArchitectureMayOnlyAccessLayersDefinitions() { - return testForEach( + static Stream layeredArchitectureMayOnlyAccessLayersDefinitions() { + return Stream.of( layeredArchitecture() .consideringAllDependencies() .layer("Allowed").definedBy("..library.testclasses.mayonlyaccesslayers.allowed..") @@ -296,9 +289,9 @@ public static Object[][] layeredArchitectureMayOnlyAccessLayersDefinitions() { .whereLayer("Forbidden").mayNotAccessAnyLayer()); } - @Test - @UseDataProvider("layeredArchitectureMayOnlyAccessLayersDefinitions") - public void layered_architecture_may_only_access_layers_description(LayeredArchitecture architecture) { + @ParameterizedTest + @MethodSource("layeredArchitectureMayOnlyAccessLayersDefinitions") + void layered_architecture_may_only_access_layers_description(LayeredArchitecture architecture) { assertThat(architecture.getDescription()).isEqualTo( "Layered architecture considering all dependencies, consisting of" + lineSeparator() + "layer 'Allowed' ('..library.testclasses.mayonlyaccesslayers.allowed..')" + lineSeparator() + @@ -308,9 +301,9 @@ public void layered_architecture_may_only_access_layers_description(LayeredArchi "where layer 'Forbidden' may not access any layer"); } - @Test - @UseDataProvider("layeredArchitectureMayOnlyAccessLayersDefinitions") - public void layered_architecture_gathers_may_only_access_layers_violations(LayeredArchitecture architecture) { + @ParameterizedTest + @MethodSource("layeredArchitectureMayOnlyAccessLayersDefinitions") + void layered_architecture_gathers_may_only_access_layers_violations(LayeredArchitecture architecture) { JavaClasses classes = new ClassFileImporter().importPackages(absolute("mayonlyaccesslayers")); EvaluationResult result = architecture.evaluate(classes); @@ -327,9 +320,9 @@ public void layered_architecture_gathers_may_only_access_layers_violations(Layer expectedFieldTypePattern(MayOnlyAccessLayersOriginClass.class, "illegalTarget", MayOnlyAccessLayersForbiddenClass.class))); } - @Test - @UseDataProvider("layeredArchitectureMayOnlyAccessLayersDefinitions") - public void layered_architecture_can_ignore_may_only_access_layers_violations(LayeredArchitecture architecture) { + @ParameterizedTest + @MethodSource("layeredArchitectureMayOnlyAccessLayersDefinitions") + void layered_architecture_can_ignore_may_only_access_layers_violations(LayeredArchitecture architecture) { JavaClasses classes = new ClassFileImporter().importPackages(absolute("mayonlyaccesslayers")); architecture = architecture.ignoreDependency(MayOnlyAccessLayersOriginClass.class, MayOnlyAccessLayersForbiddenClass.class) @@ -498,7 +491,7 @@ static void assertPatternMatches(List input, Set expectedRegexes Set toMatch = new HashSet<>(expectedRegexes); for (String line : input) { if (!matchIteratorAndRemove(toMatch, line)) { - Assert.fail("Line '" + line + "' didn't match any pattern in " + expectedRegexes); + fail("Line '" + line + "' didn't match any pattern in " + expectedRegexes); } } assertThat(toMatch).as("Unmatched Patterns").isEmpty(); diff --git a/archunit/src/test/java/com/tngtech/archunit/library/OnionArchitectureTest.java b/archunit/src/test/java/com/tngtech/archunit/library/OnionArchitectureTest.java index ceb391c8b7..252e025fbe 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/OnionArchitectureTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/OnionArchitectureTest.java @@ -1,7 +1,6 @@ package com.tngtech.archunit.library; import java.util.HashSet; -import java.util.List; import java.util.Set; import java.util.function.Function; import java.util.stream.Stream; @@ -21,11 +20,9 @@ import com.tngtech.archunit.library.testclasses.onionarchitecture.application.ApplicationLayerClass; import com.tngtech.archunit.library.testclasses.onionarchitecture.domain.model.DomainModelLayerClass; import com.tngtech.archunit.library.testclasses.onionarchitecture.domain.service.DomainServiceLayerClass; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.base.DescribedPredicate.alwaysTrue; import static com.tngtech.archunit.core.domain.JavaClass.Predicates.equivalentTo; @@ -40,19 +37,15 @@ import static com.tngtech.archunit.library.LayeredArchitectureTest.expectedEmptyLayerPattern; import static com.tngtech.archunit.library.LayeredArchitectureTest.expectedFieldTypePattern; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; import static java.beans.Introspector.decapitalize; import static java.lang.System.lineSeparator; -import static java.util.stream.Collectors.toList; import static java.util.stream.Collectors.toSet; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class OnionArchitectureTest { - @DataProvider - public static Object[][] data_onion_architecture_description() { - return testForEach( + static Stream onion_architecture_description() { + return Stream.of( onionArchitecture() .domainModels("onionarchitecture.domain.model..") .domainServices("onionarchitecture.domain.service..") @@ -70,9 +63,9 @@ public static Object[][] data_onion_architecture_description() { ); } - @Test - @UseDataProvider - public void test_onion_architecture_description(OnionArchitecture architecture) { + @ParameterizedTest + @MethodSource + void onion_architecture_description(OnionArchitecture architecture) { assertThat(architecture.getDescription()).isEqualTo( "Onion architecture consisting of" + lineSeparator() + "domain models ('onionarchitecture.domain.model..')" + lineSeparator() + @@ -120,9 +113,8 @@ public void onion_architecture_because_clause() { assertThat(architecture.getDescription()).isEqualTo("overridden, because some reason"); } - @DataProvider - public static Object[][] data_onion_architecture_gathers_all_violations() { - return testForEach( + static Stream onion_architecture_gathers_all_violations() { + return Stream.of( getTestOnionArchitecture(), onionArchitecture() .domainModels(resideInAnyPackage(absolute("onionarchitecture.domain.model"))) @@ -134,9 +126,9 @@ public static Object[][] data_onion_architecture_gathers_all_violations() { ); } - @Test - @UseDataProvider - public void test_onion_architecture_gathers_all_violations(OnionArchitecture architecture) { + @ParameterizedTest + @MethodSource + void onion_architecture_gathers_all_violations(OnionArchitecture architecture) { JavaClasses classes = new ClassFileImporter().importPackages(absolute("onionarchitecture")); EvaluationResult result = architecture.evaluate(classes); @@ -182,8 +174,7 @@ public void onion_architecture_rejects_empty_layers_by_default() { assertFailureOnionArchitectureWithEmptyLayers(result); } - @DataProvider - public static List ruleTextModifications() { + static Stream> ruleTextModifications() { return Stream.>of( Function.identity(), onionArchitecture -> onionArchitecture @@ -193,12 +184,12 @@ public static List ruleTextModifications() { onionArchitecture -> onionArchitecture .as("Onion architecture consisting of (optional) changed") .because("changed") - ).collect(toList()); + ); } - @Test - @UseDataProvider("ruleTextModifications") - public void onion_architecture_allows_empty_layers_if_all_layers_are_optional(Function modifyRule) { + @ParameterizedTest + @MethodSource("ruleTextModifications") + void onion_architecture_allows_empty_layers_if_all_layers_are_optional(Function modifyRule) { OnionArchitecture architecture = modifyRule.apply(anOnionArchitectureWithEmptyLayers().withOptionalLayers(true)); assertThat(architecture.getDescription()).startsWith("Onion architecture consisting of (optional)"); @@ -219,9 +210,9 @@ public void onion_architecture_rejects_empty_layers_if_layers_are_explicitly_not assertFailureOnionArchitectureWithEmptyLayers(result); } - @Test - @UseDataProvider("ruleTextModifications") - public void onion_architecture_ensure_all_classes_are_contained_in_architecture(Function modifyRule) { + @ParameterizedTest + @MethodSource("ruleTextModifications") + void onion_architecture_ensure_all_classes_are_contained_in_architecture(Function modifyRule) { JavaClasses classes = new ClassFileImporter().importClasses(First.class, Second.class); OnionArchitecture architectureNotCoveringAllClasses = modifyRule.apply(onionArchitecture().withOptionalLayers(true) diff --git a/archunit/src/test/java/com/tngtech/archunit/library/ProxyRulesTest.java b/archunit/src/test/java/com/tngtech/archunit/library/ProxyRulesTest.java index e82deef1f3..1b4c65aa06 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/ProxyRulesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/ProxyRulesTest.java @@ -1,12 +1,12 @@ package com.tngtech.archunit.library; +import java.util.stream.Stream; + import com.tngtech.archunit.core.importer.ClassFileImporter; import com.tngtech.archunit.lang.ArchRule; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.core.domain.properties.HasName.Predicates.name; import static com.tngtech.archunit.lang.conditions.ArchPredicates.have; @@ -16,16 +16,13 @@ import static com.tngtech.archunit.library.ProxyRules.no_classes_should_directly_call_other_methods_declared_in_the_same_class_that; import static com.tngtech.archunit.library.ProxyRules.no_classes_should_directly_call_other_methods_declared_in_the_same_class_that_are_annotated_with; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.regex.Pattern.quote; -@RunWith(DataProviderRunner.class) public class ProxyRulesTest { - @DataProvider - public static Object[][] call_own_method_with_specific_annotation_rules() { - return $$( + static Stream call_own_method_with_specific_annotation_rules() { + return Stream.of( $(no_classes_should_directly_call_other_methods_declared_in_the_same_class_that_are_annotated_with(ProxyAnnotation.class), String.format( "no classes should directly call other methods declared in the same class that are annotated with @%s, because it bypasses the proxy mechanism", ProxyAnnotation.class.getSimpleName())), @@ -39,9 +36,9 @@ public static Object[][] call_own_method_with_specific_annotation_rules() { ); } - @Test - @UseDataProvider("call_own_method_with_specific_annotation_rules") - public void detects_direct_self_call_to_method_annotated_with_specific_annotation(ArchRule rule, String expectedDescription) { + @ParameterizedTest + @MethodSource("call_own_method_with_specific_annotation_rules") + void detects_direct_self_call_to_method_annotated_with_specific_annotation(ArchRule rule, String expectedDescription) { class OtherClass { @ProxyAnnotation void otherProxied() { @@ -73,9 +70,9 @@ void selfProxied() { quoteMethod(SomeClass.class, "evil"), quoteMethod(SomeClass.class, "selfProxied"))); } - @Test - @UseDataProvider("call_own_method_with_specific_annotation_rules") - public void ignores_synthetic_bridge_method_calling_other_method_declared_in_the_same_class(ArchRule rule, String expectedDescription) { + @ParameterizedTest + @MethodSource("call_own_method_with_specific_annotation_rules") + void ignores_synthetic_bridge_method_calling_other_method_declared_in_the_same_class(ArchRule rule, String expectedDescription) { abstract class GenericBaseClass { @SuppressWarnings("unused") abstract void selfProxied(T value); diff --git a/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SlicesShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SlicesShouldTest.java index 5e5709120d..f1f733c6a5 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SlicesShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SlicesShouldTest.java @@ -2,6 +2,7 @@ import java.util.List; import java.util.regex.Pattern; +import java.util.stream.Stream; import com.tngtech.archunit.base.DescribedPredicate; import com.tngtech.archunit.core.domain.JavaClass; @@ -14,34 +15,28 @@ import com.tngtech.archunit.library.testclasses.second.three.any.SecondThreeAnyClass; import com.tngtech.archunit.library.testclasses.some.pkg.SomePkgClass; import com.tngtech.archunit.library.testclasses.some.pkg.sub.SomePkgSubclass; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Assert; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.base.DescribedPredicate.alwaysTrue; import static com.tngtech.archunit.library.dependencies.GivenSlicesTest.TEST_CLASSES_PACKAGE; import static com.tngtech.archunit.library.dependencies.SlicesRuleDefinition.slices; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; +import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.regex.Pattern.quote; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.fail; -@RunWith(DataProviderRunner.class) public class SlicesShouldTest { - @DataProvider - public static Object[][] rules() { - return testForEach( + static Stream rules() { + return Stream.of( slices().matching(TEST_CLASSES_PACKAGE + ".(*)..").should().notDependOnEachOther(), slices().matching(TEST_CLASSES_PACKAGE + ".(*)..").should().beFreeOfCycles()); } - @Test - @UseDataProvider("rules") - public void slice_rules_should_ignore_configured_dependencies(SliceRule rule) { + @ParameterizedTest + @MethodSource("rules") + void slice_rules_should_ignore_configured_dependencies(SliceRule rule) { JavaClasses classes = new ClassFileImporter().importPackages(TEST_CLASSES_PACKAGE); assertViolations(classes, rule) @@ -79,18 +74,17 @@ public void slice_rules_should_ignore_configured_dependencies(SliceRule rule) { .doNotContain(SecondThreeAnyClass.class, SomePkgClass.class); } - @DataProvider - public static Object[][] rules_with_expected_base_description() { - return $$( + static Stream rules_with_expected_base_description() { + return Stream.of( $(slices().matching("foo.(*)..").should().notDependOnEachOther(), "slices matching 'foo.(*)..' should not depend on each other"), $(slices().matching("foo.(*)..").should().beFreeOfCycles(), "slices matching 'foo.(*)..' should be free of cycles")); } - @Test - @UseDataProvider("rules_with_expected_base_description") - public void chaining_messages(SliceRule rule, String baseDescription) { + @ParameterizedTest + @MethodSource("rules_with_expected_base_description") + void chaining_messages(SliceRule rule, String baseDescription) { assertThat(rule.getDescription()).isEqualTo(baseDescription); rule = rule.because("reason one"); @@ -128,14 +122,14 @@ private static class ViolationsAssertion { ViolationsAssertion contain(Class from, Class to) { if (!containsMessage(from, to)) { - Assert.fail(String.format("Expected a message to report a dependency from %s to %s", from.getName(), to.getName())); + fail(String.format("Expected a message to report a dependency from %s to %s", from.getName(), to.getName())); } return this; } ViolationsAssertion doNotContain(Class from, Class to) { if (containsMessage(from, to)) { - Assert.fail(String.format("Expected no message to reports a dependency from %s to %s", from.getName(), to.getName())); + fail(String.format("Expected no message to reports a dependency from %s to %s", from.getName(), to.getName())); } return this; } diff --git a/archunit/src/test/java/com/tngtech/archunit/library/metrics/LakosMetricsTest.java b/archunit/src/test/java/com/tngtech/archunit/library/metrics/LakosMetricsTest.java index cd66d2254a..39fc1d1f0d 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/metrics/LakosMetricsTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/metrics/LakosMetricsTest.java @@ -1,6 +1,7 @@ package com.tngtech.archunit.library.metrics; import java.util.Set; +import java.util.stream.Stream; import com.google.common.collect.ImmutableSet; import com.tngtech.archunit.core.domain.JavaClasses; @@ -8,20 +9,17 @@ import com.tngtech.archunit.core.importer.ClassFileImporter; import com.tngtech.archunit.library.metrics.testobjects.lakos.pkg1.SomeTestClass1; import com.tngtech.archunit.library.metrics.testobjects.lakos.pkg2.SomeTestClass2; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.library.metrics.TestElement.GET_DEPENDENCIES; import static com.tngtech.archunit.library.metrics.TestMetricsComponentDependencyGraph.fromNode; import static com.tngtech.archunit.library.metrics.TestMetricsComponentDependencyGraph.graph; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class LakosMetricsTest { @Test @@ -33,9 +31,8 @@ public void lakos_metrics_of_a_single_component() { assertMetrics(metrics, ExpectedMetrics.ccd(1).acd(1.0).racd(1.0).nccd(1.0)); } - @DataProvider - public static Object[][] dependency_graphs_with_expected_metrics() { - return $$( + static Stream dependency_graphs_with_expected_metrics() { + return Stream.of( $( graph(fromNode("A").toNodes("B")), ExpectedMetrics.ccd(3).acd(1.5).racd(0.75).nccd(1) @@ -131,9 +128,9 @@ public static Object[][] dependency_graphs_with_expected_metrics() { ); } - @Test - @UseDataProvider("dependency_graphs_with_expected_metrics") - public void lakos_metrics_are_calculated_correctly(TestMetricsComponentDependencyGraph graph, ExpectedMetrics expectedMetrics) { + @ParameterizedTest + @MethodSource("dependency_graphs_with_expected_metrics") + void lakos_metrics_are_calculated_correctly(TestMetricsComponentDependencyGraph graph, ExpectedMetrics expectedMetrics) { LakosMetrics metrics = ArchitectureMetrics.lakosMetrics(graph.toComponents(), GET_DEPENDENCIES); assertMetrics(metrics, " of " + graph, expectedMetrics); diff --git a/archunit/src/test/java/com/tngtech/archunit/library/modules/ArchModuleTest.java b/archunit/src/test/java/com/tngtech/archunit/library/modules/ArchModuleTest.java index 7c00239d7b..5a2af6660c 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/modules/ArchModuleTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/modules/ArchModuleTest.java @@ -1,17 +1,16 @@ package com.tngtech.archunit.library.modules; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; - -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import java.util.stream.Stream; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -@RunWith(DataProviderRunner.class) public class ArchModuleTest { @Test @@ -36,17 +35,16 @@ public void identifier_parts() { assertThat(identifier.getPart(3)).isEqualTo("three"); } - @DataProvider - public static Object[][] illegal_indices() { - return $$( + static Stream illegal_indices() { + return Stream.of( $(ArchModule.Identifier.from("one"), 0), $(ArchModule.Identifier.from("one"), 2) ); } - @Test - @UseDataProvider("illegal_indices") - public void rejects_index_out_of_range(ArchModule.Identifier identifier, int illegalIndex) { + @ParameterizedTest + @MethodSource("illegal_indices") + void rejects_index_out_of_range(ArchModule.Identifier identifier, int illegalIndex) { assertThatThrownBy(() -> identifier.getPart(illegalIndex)) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining(String.valueOf(illegalIndex)) diff --git a/archunit/src/test/java/com/tngtech/archunit/library/modules/syntax/ModuleRuleTest.java b/archunit/src/test/java/com/tngtech/archunit/library/modules/syntax/ModuleRuleTest.java index 8dd279187e..dad5f585a6 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/modules/syntax/ModuleRuleTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/modules/syntax/ModuleRuleTest.java @@ -4,6 +4,7 @@ import java.util.HashSet; import java.util.Set; import java.util.function.Function; +import java.util.stream.Stream; import com.tngtech.archunit.base.DescribedFunction; import com.tngtech.archunit.core.domain.Dependency; @@ -19,11 +20,9 @@ import com.tngtech.archunit.library.modules.syntax.testexamples.test_modules.one.one.ClassOneOne; import com.tngtech.archunit.library.modules.syntax.testexamples.test_modules.two.ClassTwo; import com.tngtech.archunit.library.modules.syntax.testexamples.test_modules.two.one.ClassTwoOne; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.base.DescribedPredicate.alwaysFalse; import static com.tngtech.archunit.base.DescribedPredicate.alwaysTrue; @@ -32,9 +31,7 @@ import static com.tngtech.archunit.library.modules.syntax.ModuleRuleDefinition.modules; import static com.tngtech.archunit.testutil.Assertions.assertThatDependencies; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; -@RunWith(DataProviderRunner.class) public class ModuleRuleTest { @Test @@ -136,16 +133,15 @@ public void ignoring_dependencies_can_be_applied_before_other_methods() { .hasNoViolation(); } - @DataProvider - public static Object[][] rules() { - return testForEach( + static Stream> rules() { + return Stream.of( modules().definedByPackages("..test_modules.(*).(*)..").should().respectTheirAllowedDependencies(alwaysFalse(), consideringOnlyDependenciesBetweenModules()), modules().definedByPackages("..test_modules.(*).(*)..").should().beFreeOfCycles()); } - @Test - @UseDataProvider("rules") - public void handles_violations_as_dependencies(ModulesRule rule) { + @ParameterizedTest + @MethodSource("rules") + void handles_violations_as_dependencies(ModulesRule rule) { JavaClasses classes = new ClassFileImporter().importPackagesOf(ClassOne.class, ClassTwo.class); Set reportedDependencies = new HashSet<>(); diff --git a/archunit/src/test/java/com/tngtech/archunit/library/modules/syntax/ModulesShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/library/modules/syntax/ModulesShouldTest.java index 93e6ce1887..d9882b8e57 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/modules/syntax/ModulesShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/modules/syntax/ModulesShouldTest.java @@ -1,6 +1,7 @@ package com.tngtech.archunit.library.modules.syntax; import java.util.function.Function; +import java.util.stream.Stream; import com.tngtech.archunit.base.DescribedPredicate; import com.tngtech.archunit.core.importer.ClassFileImporter; @@ -14,11 +15,9 @@ import com.tngtech.archunit.library.modules.testexamples.default_annotation.module2.InternalClassInModule2; import com.tngtech.archunit.library.modules.testexamples.default_annotation.module2.api.ApiClassInModule2; import com.tngtech.archunit.library.modules.testexamples.default_annotation.module3.ClassInModule3; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.base.DescribedPredicate.alwaysFalse; import static com.tngtech.archunit.base.DescribedPredicate.describe; @@ -32,11 +31,9 @@ import static com.tngtech.archunit.library.modules.syntax.ModuleDependencyScope.consideringOnlyDependenciesInAnyPackage; import static com.tngtech.archunit.library.modules.syntax.ModuleRuleDefinition.modules; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; import static java.util.regex.Pattern.quote; import static org.assertj.core.api.Assertions.assertThatThrownBy; -@RunWith(DataProviderRunner.class) public class ModulesShouldTest { @Test @@ -140,19 +137,18 @@ public void onlyDependOnEachOtherThroughPackagesDeclaredIn_rejects_property_of_w .hasMessageContaining(String.format("Property @%s.name() must be of type %s", TestModule.class.getSimpleName(), String[].class.getSimpleName())); } - @DataProvider - public static Object[][] ruleModificationsToIgnoreViolationsFromModuleTwoToArchRule() { - return testForEach( - (Function, ModulesRule>) modulesRule -> modulesRule.ignoreDependency(ModuleTwo.class, ArchRule.class), - (Function, ModulesRule>) modulesRule -> modulesRule.ignoreDependency(ModuleTwo.class.getName(), ArchRule.class.getName()), - (Function, ModulesRule>) modulesRule -> modulesRule.ignoreDependency(equivalentTo(ModuleTwo.class), equivalentTo(ArchRule.class)), - (Function, ModulesRule>) modulesRule -> modulesRule.ignoreDependency(dependency(ModuleTwo.class, ArchRule.class)) + static Stream, ModulesRule>> ruleModificationsToIgnoreViolationsFromModuleTwoToArchRule() { + return Stream.of( + modulesRule -> modulesRule.ignoreDependency(ModuleTwo.class, ArchRule.class), + modulesRule -> modulesRule.ignoreDependency(ModuleTwo.class.getName(), ArchRule.class.getName()), + modulesRule -> modulesRule.ignoreDependency(equivalentTo(ModuleTwo.class), equivalentTo(ArchRule.class)), + modulesRule -> modulesRule.ignoreDependency(dependency(ModuleTwo.class, ArchRule.class)) ); } - @Test - @UseDataProvider("ruleModificationsToIgnoreViolationsFromModuleTwoToArchRule") - public void respectTheirAllowedDependencies_ignores_dependencies(Function, ModulesRule> modifyRuleToIgnoreViolationsFromModuleTwoToArchRule) { + @ParameterizedTest + @MethodSource("ruleModificationsToIgnoreViolationsFromModuleTwoToArchRule") + void respectTheirAllowedDependencies_ignores_dependencies(Function, ModulesRule> modifyRuleToIgnoreViolationsFromModuleTwoToArchRule) { ModulesRule rule = modulesByClassName().should().respectTheirAllowedDependencies(alwaysFalse(), consideringAllDependencies()); rule = modifyRuleToIgnoreViolationsFromModuleTwoToArchRule.apply(rule); @@ -175,17 +171,16 @@ public void respectTheirAllowedDependencies_filtered_by_that_ignores_dependencie .hasNoViolationContaining(ArchRule.class.getName()); } - @DataProvider - public static Object[][] data_onlyDependOnEachOtherThroughClassesThat_ignores_dependencies() { - return testForEach( + static Stream> onlyDependOnEachOtherThroughClassesThat_ignores_dependencies() { + return Stream.of( modulesByClassName().should().onlyDependOnEachOtherThroughClassesThat(have(simpleName(ModuleTwo.class.getSimpleName()))), modulesByClassName().should().onlyDependOnEachOtherThroughClassesThat().haveSimpleName(ModuleTwo.class.getSimpleName()) ); } - @Test - @UseDataProvider - public void test_onlyDependOnEachOtherThroughClassesThat_ignores_dependencies(ModulesRule rule) { + @ParameterizedTest + @MethodSource + void onlyDependOnEachOtherThroughClassesThat_ignores_dependencies(ModulesRule rule) { rule = rule .ignoreDependency(d -> d.getDescription().contains("cyclicDependencyOne")); diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/DataProviders.java b/archunit/src/test/java/com/tngtech/archunit/testutil/DataProviders.java new file mode 100644 index 0000000000..87d508cfba --- /dev/null +++ b/archunit/src/test/java/com/tngtech/archunit/testutil/DataProviders.java @@ -0,0 +1,9 @@ +package com.tngtech.archunit.testutil; + +import org.junit.jupiter.params.provider.Arguments; + +public class DataProviders { + public static Arguments $(Object... arguments) { + return Arguments.of(arguments); + } +} diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/syntax/MethodCallChainTest.java b/archunit/src/test/java/com/tngtech/archunit/testutil/syntax/MethodCallChainTest.java index eb92d50c14..2001a92774 100644 --- a/archunit/src/test/java/com/tngtech/archunit/testutil/syntax/MethodCallChainTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/testutil/syntax/MethodCallChainTest.java @@ -1,5 +1,7 @@ package com.tngtech.archunit.testutil.syntax; +import java.util.stream.Stream; + import com.tngtech.archunit.testutil.syntax.callchainexamples.fivestepswithgenericshierarchy.FiveStepsHierarchyImplementationStep1; import com.tngtech.archunit.testutil.syntax.callchainexamples.fivestepswithgenericshierarchy.FiveStepsHierarchyImplementationStep2; import com.tngtech.archunit.testutil.syntax.callchainexamples.fivestepswithgenericshierarchy.FiveStepsHierarchyImplementationStep3; @@ -28,22 +30,16 @@ import com.tngtech.archunit.testutil.syntax.callchainexamples.threestepswithgenerics.ThreeStepsInterfaceStep1; import com.tngtech.archunit.testutil.syntax.callchainexamples.threestepswithgenerics.ThreeStepsInterfaceStep2; import com.tngtech.archunit.testutil.syntax.callchainexamples.threestepswithgenerics.ThreeStepsInterfaceStep3; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.testutil.syntax.MethodChoiceStrategy.chooseAllArchUnitSyntaxMethods; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; import static java.util.Collections.emptyList; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class MethodCallChainTest { - @DataProvider - public static Object[][] callChainTestCases() { - return testForEach( + static Stream> callChainTestCases() { + return Stream.of( CallChainTestCase .start(ThreeStepsInterfaceStep1.class, new ThreeStepsImplementationStep1()) .numberOfInvocations(1) @@ -91,9 +87,9 @@ public static Object[][] callChainTestCases() { ); } - @Test - @UseDataProvider("callChainTestCases") - public void run_test_cases(CallChainTestCase testCase) { + @ParameterizedTest + @MethodSource("callChainTestCases") + void run_test_cases(CallChainTestCase testCase) { MethodCallChain callChain = createCallChainStart(testCase.startInterface, testCase.startImplementation); for (int i = 0; i < testCase.numberOfInvocations; i++) { From 59cf193d588c3bdcddc104ab47dfde8872d12016 Mon Sep 17 00:00:00 2001 From: Manfred Hanke Date: Tue, 29 Apr 2025 09:12:18 +0200 Subject: [PATCH 05/11] migrate junit-dataprovider tests involving TemporaryFolderRule to junit-jupiter-params Signed-off-by: Manfred Hanke --- .../core/importer/ClassFileSourceTest.java | 48 +++---- .../core/importer/ImportOptionsTest.java | 130 ++++++++---------- .../rules/PlantUmlArchConditionTest.java | 37 +++-- .../plantuml/rules/PlantUmlParserTest.java | 76 +++++----- .../library/plantuml/rules/TestDiagram.java | 12 +- 5 files changed, 139 insertions(+), 164 deletions(-) diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileSourceTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileSourceTest.java index 7d4cd85159..d8371038d3 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileSourceTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileSourceTest.java @@ -9,33 +9,29 @@ import java.util.Comparator; import java.util.Set; import java.util.jar.JarFile; +import java.util.stream.Stream; import com.google.common.collect.ImmutableSet; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TemporaryFolder; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkState; import static com.google.common.collect.Iterables.getOnlyElement; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class ClassFileSourceTest { static final String MODULE_INFO_FILE_NAME = "module-info.class"; - @Rule - public final TemporaryFolder tempDir = new TemporaryFolder(); + @TempDir + File tempDir; - @DataProvider - public static Object[][] expected_classes() { - return $$( + static Stream expected_classes() { + return Stream.of( $(ImmutableSet.of("/one/Foo.class", "/one/Bar.class", "/two/Bar.class"), new ImportOptions(), ImmutableSet.of("/one/Foo.class", "/one/Bar.class", "/two/Bar.class")), @@ -57,9 +53,9 @@ public static Object[][] expected_classes() { ImmutableSet.of())); } - @Test - @UseDataProvider("expected_classes") - public void classes_in_JAR_are_filtered(Set givenEntries, ImportOptions importOptions, Set expectedIncluded) { + @ParameterizedTest + @MethodSource("expected_classes") + void classes_in_JAR_are_filtered(Set givenEntries, ImportOptions importOptions, Set expectedIncluded) { TestJarFile testJarFile = new TestJarFile(); for (String entry : givenEntries) { testJarFile.withEntry(entry); @@ -71,12 +67,12 @@ public void classes_in_JAR_are_filtered(Set givenEntries, ImportOptions assertSourceMatches(source, expectedIncluded); } - @Test - @UseDataProvider("expected_classes") - public void classes_from_file_path_are_filtered( + @ParameterizedTest + @MethodSource("expected_classes") + void classes_from_file_path_are_filtered( Set givenFiles, ImportOptions importOptions, Set expectedIncluded) throws IOException { - File dir = tempDir.newFolder(); + File dir = tempDir; for (String file : givenFiles) { File newFile = new File(dir, file); File dirOfFile = newFile.getParentFile(); @@ -103,8 +99,8 @@ public void filters_out_module_infos_in_Jar_location() { } @Test - public void filters_out_module_infos_in_file_location() throws IOException { - File dir = tempDir.newFolder(); + void filters_out_module_infos_in_file_location() throws IOException { + File dir = tempDir; createDummyModuleInfoIn(dir); File classFile = createDummyclassFileIn(dir); @@ -114,8 +110,8 @@ public void filters_out_module_infos_in_file_location() throws IOException { } @Test - public void resolves_class_files_with_whitespace() throws IOException { - File file = tempDir.newFile("path with spaces like kotlin does.class"); + void resolves_class_files_with_whitespace() throws IOException { + File file = new File(tempDir, "path with spaces like kotlin does.class"); ClassFileSource classFileSource = new ClassFileSource.FromFilePath(file.toPath(), new ImportOptions()); diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ImportOptionsTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ImportOptionsTest.java index 5fe9cad65b..fc8a954f6d 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ImportOptionsTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ImportOptionsTest.java @@ -1,29 +1,27 @@ package com.tngtech.archunit.core.importer; -import java.io.File; import java.io.IOException; import java.net.URI; -import java.nio.file.Files; +import java.nio.file.Path; import java.util.ArrayList; import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; import com.google.common.collect.ImmutableList; +import com.google.common.collect.Lists; import com.tngtech.archunit.core.importer.ImportOption.DoNotIncludeArchives; +import com.tngtech.archunit.core.importer.ImportOption.DoNotIncludeGradleTestFixtures; import com.tngtech.archunit.core.importer.ImportOption.DoNotIncludeJars; import com.tngtech.archunit.core.importer.ImportOption.DoNotIncludePackageInfos; -import com.tngtech.archunit.core.importer.ImportOption.DoNotIncludeGradleTestFixtures; import com.tngtech.archunit.core.importer.ImportOption.DoNotIncludeTests; import com.tngtech.archunit.core.importer.ImportOption.OnlyIncludeTests; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TemporaryFolder; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.io.TempDir; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; -import static com.google.common.collect.ImmutableList.copyOf; -import static com.google.common.collect.Iterables.concat; import static com.google.common.collect.Iterables.getLast; import static com.tngtech.archunit.core.importer.ImportOption.Predefined.DO_NOT_INCLUDE_ARCHIVES; import static com.tngtech.archunit.core.importer.ImportOption.Predefined.DO_NOT_INCLUDE_JARS; @@ -31,26 +29,22 @@ import static com.tngtech.archunit.core.importer.ImportOption.Predefined.DO_NOT_INCLUDE_TESTS; import static com.tngtech.archunit.core.importer.ImportOption.Predefined.DO_NOT_INCLUDE_TEST_FIXTURES; import static com.tngtech.archunit.core.importer.ImportOption.Predefined.ONLY_INCLUDE_TESTS; +import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.TestUtils.relativeResourceUri; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.crossProduct; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; -import static java.util.Arrays.asList; +import static java.util.Arrays.stream; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class ImportOptionsTest { - @Rule - public final TemporaryFolder temporaryFolder = new TemporaryFolder(); + @TempDir + Path temporaryPath; - @DataProvider - public static Object[][] do_not_include_tests() { - return testForEach(new DoNotIncludeTests(), DO_NOT_INCLUDE_TESTS); + static Stream do_not_include_tests() { + return Stream.of(new DoNotIncludeTests(), DO_NOT_INCLUDE_TESTS); } - @Test - @UseDataProvider("do_not_include_tests") - public void excludes_test_class(ImportOption doNotIncludeTests) { + @ParameterizedTest + @MethodSource("do_not_include_tests") + void excludes_test_class(ImportOption doNotIncludeTests) { assertThat(doNotIncludeTests.includes(locationOf(DoNotIncludeTests.class))) .as("includes production location").isTrue(); @@ -58,14 +52,13 @@ public void excludes_test_class(ImportOption doNotIncludeTests) { .as("includes test location").isFalse(); } - @DataProvider - public static Object[][] only_include_tests() { - return testForEach(new OnlyIncludeTests(), ONLY_INCLUDE_TESTS); + static Stream only_include_tests() { + return Stream.of(new OnlyIncludeTests(), ONLY_INCLUDE_TESTS); } - @Test - @UseDataProvider("only_include_tests") - public void excludes_main_class(ImportOption onlyIncludeTests) { + @ParameterizedTest + @MethodSource("only_include_tests") + void excludes_main_class(ImportOption onlyIncludeTests) { assertThat(onlyIncludeTests.includes(locationOf(OnlyIncludeTests.class))) .as("includes production location").isFalse(); @@ -98,42 +91,44 @@ private static List getFolderPatterns() { ); } - @DataProvider - public static Object[][] test_location_predicates_and_expected_folder_patterns() { - List includeMainFolderInput = new ArrayList<>(); - List includeTestFolderInput = new ArrayList<>(); + static Stream test_location_predicates_and_expected_folder_patterns() { + List includeMainFolderInput = new ArrayList<>(); + List includeTestFolderInput = new ArrayList<>(); for (FolderPattern folderPattern : getFolderPatterns()) { includeMainFolderInput.add($(folderPattern.folders, folderPattern.isMainFolder)); includeTestFolderInput.add($(folderPattern.folders, !folderPattern.isMainFolder)); } - Object[][] doNotIncludeTestsDataPoints = crossProduct(do_not_include_tests(), includeMainFolderInput.toArray(new Object[0][])); - Object[][] onlyIncludeTestsDataPoints = crossProduct(only_include_tests(), includeTestFolderInput.toArray(new Object[0][])); + Stream doNotIncludeTestsDataPoints = crossProduct(do_not_include_tests(), includeMainFolderInput); + Stream onlyIncludeTestsDataPoints = crossProduct(only_include_tests(), includeTestFolderInput); + + return Stream.concat(doNotIncludeTestsDataPoints, onlyIncludeTestsDataPoints); + } - return copyOf(concat(asList(doNotIncludeTestsDataPoints), asList(onlyIncludeTestsDataPoints))).toArray(new Object[0][]); + private static Stream crossProduct(Stream importOptionStream, List includeMainFolderInput) { + List importOptions = importOptionStream.map(Arguments::of).collect(Collectors.toList()); + return Lists.cartesianProduct(importOptions, includeMainFolderInput).stream() + .map(args -> Arguments.of(Stream.concat(stream(args.get(0).get()), stream(args.get(1).get())).toArray())); } - @Test - @UseDataProvider("test_location_predicates_and_expected_folder_patterns") - public void correctly_detects_all_output_folder_structures( + @ParameterizedTest + @MethodSource("test_location_predicates_and_expected_folder_patterns") + void correctly_detects_all_output_folder_structures( ImportOption doNotIncludeTests, String[] folderName, boolean expectedInclude) throws IOException { - File folder = temporaryFolder.newFolder(folderName); - File targetFile = new File(folder, getClass().getSimpleName() + ".class"); - Files.copy(locationOf(getClass()).asURI().toURL().openStream(), targetFile.toPath()); + Path path = temporaryPath.resolve(String.join("/", folderName)).resolve("c.class"); - assertThat(doNotIncludeTests.includes(Location.of(targetFile.toPath()))) - .as("includes location %s", targetFile.getAbsolutePath()).isEqualTo(expectedInclude); + assertThat(doNotIncludeTests.includes(Location.of(path))) + .as("includes location %s", path).isEqualTo(expectedInclude); } - @DataProvider - public static Object[][] data_excludes_test_fixtures() { - return testForEach(new DoNotIncludeGradleTestFixtures(), DO_NOT_INCLUDE_TEST_FIXTURES); + static Stream excludes_test_fixtures() { + return Stream.of(new DoNotIncludeGradleTestFixtures(), DO_NOT_INCLUDE_TEST_FIXTURES); } - @Test - @UseDataProvider - public void test_excludes_test_fixtures(ImportOption doNotIncludeTestFixtures) { + @ParameterizedTest + @MethodSource + void excludes_test_fixtures(ImportOption doNotIncludeTestFixtures) { assertThat(doNotIncludeTestFixtures.includes(Location.of(URI.create("file:///any/build/classes/java/test/com/SomeTest.class")))) .as("includes test class from file path").isTrue(); assertThat(doNotIncludeTestFixtures.includes(Location.of(URI.create("jar:file:///any/build/libs/some-test.jar!/com/SomeTest")))) @@ -145,14 +140,13 @@ public void test_excludes_test_fixtures(ImportOption doNotIncludeTestFixtures) { .as("excludes test fixture from JAR path").isFalse(); } - @DataProvider - public static Object[][] do_not_include_jars() { - return testForEach(new DoNotIncludeJars(), DO_NOT_INCLUDE_JARS); + static Stream do_not_include_jars() { + return Stream.of(new DoNotIncludeJars(), DO_NOT_INCLUDE_JARS); } - @Test - @UseDataProvider("do_not_include_jars") - public void detects_Jars_correctly(ImportOption doNotIncludeJars) { + @ParameterizedTest + @MethodSource("do_not_include_jars") + void detects_Jars_correctly(ImportOption doNotIncludeJars) { assertThat(doNotIncludeJars.includes(locationOf(getClass()))) .as("includes file location") .isTrue(); @@ -164,14 +158,13 @@ public void detects_Jars_correctly(ImportOption doNotIncludeJars) { .isEqualTo(!comesFromJarArchive(Object.class)); } - @DataProvider - public static Object[][] do_not_include_archives() { - return testForEach(new DoNotIncludeArchives(), DO_NOT_INCLUDE_ARCHIVES); + static Stream do_not_include_archives() { + return Stream.of(new DoNotIncludeArchives(), DO_NOT_INCLUDE_ARCHIVES); } - @Test - @UseDataProvider("do_not_include_archives") - public void detects_archives_correctly(ImportOption doNotIncludeArchives) { + @ParameterizedTest + @MethodSource("do_not_include_archives") + void detects_archives_correctly(ImportOption doNotIncludeArchives) { assertThat(doNotIncludeArchives.includes(locationOf(getClass()))) .as("includes file location") .isTrue(); @@ -183,14 +176,13 @@ public void detects_archives_correctly(ImportOption doNotIncludeArchives) { .isFalse(); } - @DataProvider - public static Object[][] do_not_include_package_info_classes() { - return testForEach(new DoNotIncludePackageInfos(), DO_NOT_INCLUDE_PACKAGE_INFOS); + static Stream do_not_include_package_info_classes() { + return Stream.of(new DoNotIncludePackageInfos(), DO_NOT_INCLUDE_PACKAGE_INFOS); } - @Test - @UseDataProvider("do_not_include_package_info_classes") - public void detect_package_info_class(ImportOption doNotIncludePackageInfoClasses) { + @ParameterizedTest + @MethodSource("do_not_include_package_info_classes") + void detect_package_info_class(ImportOption doNotIncludePackageInfoClasses) { Location packageInfoLocation = Location.of(relativeResourceUri(getClass(), "testexamples/package-info.class")); assertThat(doNotIncludePackageInfoClasses.includes(packageInfoLocation)) .as("doNotIncludePackageInfoClasses includes package-info.class") diff --git a/archunit/src/test/java/com/tngtech/archunit/library/plantuml/rules/PlantUmlArchConditionTest.java b/archunit/src/test/java/com/tngtech/archunit/library/plantuml/rules/PlantUmlArchConditionTest.java index 2e3bdbbacc..4fa8060f3f 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/plantuml/rules/PlantUmlArchConditionTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/plantuml/rules/PlantUmlArchConditionTest.java @@ -7,6 +7,7 @@ import java.nio.file.Files; import java.util.List; import java.util.UUID; +import java.util.stream.Stream; import com.tngtech.archunit.core.domain.JavaClasses; import com.tngtech.archunit.core.importer.ClassFileImporter; @@ -17,16 +18,12 @@ import com.tngtech.archunit.library.diagramtests.simpledependency.origin.SomeOriginClass; import com.tngtech.archunit.library.diagramtests.simpledependency.target.SomeTargetClass; import com.tngtech.archunit.library.plantuml.rules.PlantUmlArchCondition.Configuration; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.DataProviders; -import com.tngtech.java.junit.dataprovider.UseDataProvider; import org.assertj.core.api.Condition; import org.assertj.core.api.ListAssert; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TemporaryFolder; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.google.common.collect.Iterables.isEmpty; @@ -43,14 +40,12 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -@RunWith(DataProviderRunner.class) public class PlantUmlArchConditionTest { - @Rule - public final TemporaryFolder temporaryFolder = new TemporaryFolder(); + @TempDir + File temporaryFolder; - @DataProvider - public static Object[] possibleInputTypes() { - return DataProviders.testForEach( + static Stream possibleInputTypes() { + return Stream.of( new PlantUmlCreationTestCase("file") { @Override PlantUmlArchCondition createConditionFrom(File file) { @@ -75,9 +70,9 @@ PlantUmlArchCondition createConditionFrom(File file) { ); } - @Test - @UseDataProvider("possibleInputTypes") - public void can_handle_all_possible_user_inputs_without_violations(PlantUmlCreationTestCase testCase) { + @ParameterizedTest + @MethodSource("possibleInputTypes") + void can_handle_all_possible_user_inputs_without_violations(PlantUmlCreationTestCase testCase) { File file = TestDiagram.in(temporaryFolder) .component("SomeOrigin").withStereoTypes("..origin") .component("SomeTarget").withStereoTypes("..target") @@ -89,9 +84,9 @@ public void can_handle_all_possible_user_inputs_without_violations(PlantUmlCreat assertNoViolation(result); } - @Test - @UseDataProvider("possibleInputTypes") - public void can_handle_all_possible_user_inputs_with_violations(PlantUmlCreationTestCase testCase) { + @ParameterizedTest + @MethodSource("possibleInputTypes") + void can_handle_all_possible_user_inputs_with_violations(PlantUmlCreationTestCase testCase) { File file = TestDiagram.in(temporaryFolder) .component("SomeOrigin").withStereoTypes("..origin") .component("SomeTarget").withStereoTypes("..target") @@ -244,7 +239,7 @@ public void diagram_with_multiple_dependencies_that_ignores_violations() { @Test public void diagram_with_unparseable_content() throws IOException { - File file = temporaryFolder.newFile("plantuml_diagram_" + UUID.randomUUID() + ".puml"); + File file = new File(temporaryFolder, "plantuml_diagram_" + UUID.randomUUID() + ".puml"); Files.write(file.toPath(), "XXX-someUnparseableContent-XXX".getBytes(UTF_8)); assertThatThrownBy(() -> adhereToPlantUmlDiagram(file, consideringOnlyDependenciesInDiagram())) diff --git a/archunit/src/test/java/com/tngtech/archunit/library/plantuml/rules/PlantUmlParserTest.java b/archunit/src/test/java/com/tngtech/archunit/library/plantuml/rules/PlantUmlParserTest.java index 873d8dde45..a296bbb766 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/plantuml/rules/PlantUmlParserTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/plantuml/rules/PlantUmlParserTest.java @@ -6,33 +6,28 @@ import java.util.ArrayList; import java.util.List; import java.util.function.Function; +import java.util.stream.Stream; import com.google.common.collect.ImmutableList; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TemporaryFolder; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; import static com.google.common.base.Strings.repeat; import static com.google.common.collect.Iterables.getOnlyElement; import static com.google.common.collect.MoreCollectors.onlyElement; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; import static java.util.stream.Collectors.toList; import static java.util.stream.IntStream.rangeClosed; import static org.assertj.core.api.Assertions.assertThatThrownBy; -@RunWith(DataProviderRunner.class) public class PlantUmlParserTest { private static final PlantUmlParser parser = new PlantUmlParser(); - @Rule - public final TemporaryFolder temporaryFolder = new TemporaryFolder(); + @TempDir + public File temporaryFolder; @Test public void parses_correct_number_of_components() { @@ -68,9 +63,8 @@ public void parses_a_complex_component() { .isEqualTo(new Stereotype("..origin..")); } - @DataProvider - public static Object[][] simple_diagrams() { - return testForEach( + static Stream> simple_diagrams() { + return Stream.of( new Function() { @Override public TestDiagram apply(TestDiagram diagram) { @@ -96,9 +90,9 @@ public String toString() { ); } - @Test - @UseDataProvider("simple_diagrams") - public void parses_dependency_of_simple_component_diagram(Function testCase) { + @ParameterizedTest + @MethodSource("simple_diagrams") + void parses_dependency_of_simple_component_diagram(Function testCase) { TestDiagram initialDiagram = TestDiagram.in(temporaryFolder) .component("SomeOrigin").withStereoTypes("..origin..") .component("SomeTarget").withStereoTypes("..target.."); @@ -114,8 +108,7 @@ public void parses_dependency_of_simple_component_diagram(Function dependency_arrow_testcases() { List arrowCenters = rangeClosed(1, 10) .mapToObj(i -> repeat("-", i)) .collect(toList()); @@ -129,12 +122,12 @@ public static Object[][] dependency_arrow_testcases() { testCase.add("[SomeOrigin] " + arrowCenter + "> [SomeTarget]"); testCase.add("[SomeTarget] <" + arrowCenter + " [SomeOrigin]"); } - return testForEach(testCase); + return testCase; } - @Test - @UseDataProvider("dependency_arrow_testcases") - public void parses_various_types_of_dependency_arrows(String dependency) { + @ParameterizedTest + @MethodSource("dependency_arrow_testcases") + void parses_various_types_of_dependency_arrows(String dependency) { PlantUmlDiagram diagram = createDiagram(TestDiagram.in(temporaryFolder) .component("SomeOrigin").withStereoTypes("..origin..") .component("SomeTarget").withStereoTypes("..target..") @@ -148,25 +141,20 @@ public void parses_various_types_of_dependency_arrows(String dependency) { .isEqualTo(new ComponentName("SomeTarget")); } - @DataProvider - public static Object[][] color_testcases() { - return $$( - $("Chartreuse"), - $("dodgerblue"), - $("483D8b"), - $("F0808080"), - $("123"), - $("transparent"), - $("red|green"), - $("red/green"), - $("red\\green"), - $("red-green") - ); - } - - @Test - @UseDataProvider("color_testcases") - public void parses_various_colored_components(String color) { + @ParameterizedTest + @ValueSource(strings = { + "Chartreuse", + "dodgerblue", + "483D8b", + "F0808080", + "123", + "transparent", + "red|green", + "red/green", + "red\\green", + "red-green" + }) + void parses_various_colored_components(String color) { File diagramFile = TestDiagram.in(temporaryFolder) .component("SomeComponent").withColor(color).withStereoTypes("..stereotype..") .write(); diff --git a/archunit/src/test/java/com/tngtech/archunit/library/plantuml/rules/TestDiagram.java b/archunit/src/test/java/com/tngtech/archunit/library/plantuml/rules/TestDiagram.java index 3c3fe4a789..80a74d3c4c 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/plantuml/rules/TestDiagram.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/plantuml/rules/TestDiagram.java @@ -16,9 +16,9 @@ class TestDiagram { private final List lines = new ArrayList<>(); - private final TemporaryFolder temporaryFolder; + private final File temporaryFolder; - private TestDiagram(TemporaryFolder temporaryFolder) { + private TestDiagram(File temporaryFolder) { this.temporaryFolder = temporaryFolder; } @@ -69,14 +69,18 @@ File write() { } private File createTempFile() { + return new File(temporaryFolder, "plantuml_diagram_" + UUID.randomUUID() + ".puml"); + } + + static TestDiagram in(TemporaryFolder temporaryFolder) { try { - return temporaryFolder.newFile("plantuml_diagram_" + UUID.randomUUID() + ".puml"); + return new TestDiagram(temporaryFolder.newFolder()); } catch (IOException e) { throw new RuntimeException(e); } } - static TestDiagram in(TemporaryFolder temporaryFolder) { + static TestDiagram in(File temporaryFolder) { return new TestDiagram(temporaryFolder); } From 40a8e35652975e305f07cd598f46a85b3f9bf6f9 Mon Sep 17 00:00:00 2001 From: Manfred Hanke Date: Tue, 29 Apr 2025 01:12:02 +0200 Subject: [PATCH 06/11] migrate junit-dataprovider tests involving ArchConfigurationRule to junit-jupiter-params introducing `ArchConfigurationExtension` Signed-off-by: Manfred Hanke --- .../tngtech/archunit/lang/ArchRuleTest.java | 2 +- .../archunit/lang/CompositeArchRuleTest.java | 43 +- .../lang/syntax/RandomClassesSyntaxTest.java | 7 +- .../lang/syntax/RandomMembersSyntaxTest.java | 26 +- .../syntax/elements/ClassesShouldTest.java | 749 ++++++++---------- .../syntax/elements/GivenCodeUnitsTest.java | 57 +- .../syntax/elements/GivenMembersTest.java | 467 ++++++----- .../syntax/elements/MembersShouldTest.java | 510 ++++++------ .../dependencies/RandomSlicesSyntaxTest.java | 6 +- .../library/dependencies/SliceRuleTest.java | 49 +- .../library/freeze/FreezingArchRuleTest.java | 44 +- .../modules/RandomModulesSyntaxTest.java | 19 +- .../testutil/ArchConfigurationExtension.java | 49 ++ .../testutil/ArchConfigurationRule.java | 34 +- .../testutil/syntax/RandomSyntaxTestBase.java | 30 +- 15 files changed, 1008 insertions(+), 1084 deletions(-) create mode 100644 archunit/src/test/java/com/tngtech/archunit/testutil/ArchConfigurationExtension.java diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/ArchRuleTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/ArchRuleTest.java index 077e28a6ac..f10c4ee80a 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/ArchRuleTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/ArchRuleTest.java @@ -25,7 +25,7 @@ import static com.tngtech.archunit.lang.Priority.HIGH; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.all; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes; -import static com.tngtech.archunit.testutil.ArchConfigurationRule.FAIL_ON_EMPTY_SHOULD_PROPERTY_NAME; +import static com.tngtech.archunit.testutil.ArchConfigurationExtension.FAIL_ON_EMPTY_SHOULD_PROPERTY_NAME; import static java.util.stream.Collectors.toCollection; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/CompositeArchRuleTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/CompositeArchRuleTest.java index 21a9c18cb5..007afa71ee 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/CompositeArchRuleTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/CompositeArchRuleTest.java @@ -1,40 +1,37 @@ package com.tngtech.archunit.lang; import java.util.List; +import java.util.stream.Stream; import com.google.common.collect.ImmutableList; import com.tngtech.archunit.core.domain.JavaClass; import com.tngtech.archunit.core.domain.JavaClasses; import com.tngtech.archunit.core.importer.ClassFileImporter; -import com.tngtech.archunit.testutil.ArchConfigurationRule; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; +import com.tngtech.archunit.testutil.ArchConfigurationExtension; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.base.DescribedPredicate.alwaysFalse; import static com.tngtech.archunit.core.domain.TestUtils.importClasses; import static com.tngtech.archunit.lang.Priority.HIGH; import static com.tngtech.archunit.lang.Priority.MEDIUM; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -@RunWith(DataProviderRunner.class) public class CompositeArchRuleTest { private static final boolean SATISFIED = true; private static final boolean UNSATISFIED = false; - @Rule - public final ArchConfigurationRule archConfigurationRule = new ArchConfigurationRule(); + @RegisterExtension + ArchConfigurationExtension archConfiguration = new ArchConfigurationExtension(); - @DataProvider - public static Object[][] rules_to_AND() { - return $$( + static Stream rules_to_AND() { + return Stream.of( $(archRuleThatSucceeds(), archRuleThatSucceeds(), SATISFIED), $(archRuleThatSucceeds(), archRuleThatFails(), UNSATISFIED), $(archRuleThatFails(), archRuleThatSucceeds(), UNSATISFIED), @@ -42,18 +39,18 @@ public static Object[][] rules_to_AND() { ); } - @Test - @UseDataProvider("rules_to_AND") - public void rules_are_ANDed(ArchRule first, ArchRule second, boolean expectedSatisfied) { + @ParameterizedTest + @MethodSource("rules_to_AND") + void rules_are_ANDed(ArchRule first, ArchRule second, boolean expectedSatisfied) { EvaluationResult result = CompositeArchRule.of(first).and(second).evaluate(importClasses(getClass())); assertThat(result.hasViolation()).as("result has violation").isEqualTo(!expectedSatisfied); assertPriority(result.getFailureReport().toString(), MEDIUM); } - @Test - @UseDataProvider("rules_to_AND") - public void archRuleCollection(ArchRule first, ArchRule second, boolean expectedSatisfied) { + @ParameterizedTest + @MethodSource("rules_to_AND") + void archRuleCollection(ArchRule first, ArchRule second, boolean expectedSatisfied) { List ruleCollection = ImmutableList.of(first, second); EvaluationResult result = CompositeArchRule.of(ruleCollection).evaluate(importClasses(getClass())); @@ -100,14 +97,14 @@ public void fails_on_empty_should_by_default() { @Test public void should_allow_empty_should_if_configured() { - archConfigurationRule.setFailOnEmptyShould(false); + archConfiguration.setFailOnEmptyShould(false); compositeRuleWithPartialEmptyShould().check(new ClassFileImporter().importClasses(Object.class)); } @Test public void allows_empty_should_if_overridden_by_rule() { - archConfigurationRule.setFailOnEmptyShould(true); + archConfiguration.setFailOnEmptyShould(true); compositeRuleWithPartialEmptyShould().allowEmptyShould(true).check(new ClassFileImporter().importClasses(Object.class)); } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/RandomClassesSyntaxTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/RandomClassesSyntaxTest.java index 50e6c0561f..991173cd72 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/RandomClassesSyntaxTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/RandomClassesSyntaxTest.java @@ -1,15 +1,14 @@ package com.tngtech.archunit.lang.syntax; -import java.util.List; +import java.util.stream.Stream; import com.tngtech.archunit.lang.syntax.elements.GivenClasses; import com.tngtech.archunit.testutil.syntax.RandomSyntaxSeed; import com.tngtech.archunit.testutil.syntax.RandomSyntaxTestBase; -import com.tngtech.java.junit.dataprovider.DataProvider; +import org.junit.jupiter.params.provider.Arguments; public class RandomClassesSyntaxTest extends RandomSyntaxTestBase { - @DataProvider - public static List> random_rules() { + static Stream random_rules() { return RandomSyntaxTestBase.createRandomRules(givenClassesSeed(), new SingleStringReplacement("meta annotated", "meta-annotated")); } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/RandomMembersSyntaxTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/RandomMembersSyntaxTest.java index c2487ed6ce..7622fb93f8 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/RandomMembersSyntaxTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/RandomMembersSyntaxTest.java @@ -1,8 +1,7 @@ package com.tngtech.archunit.lang.syntax; -import java.util.List; +import java.util.stream.Stream; -import com.google.common.collect.FluentIterable; import com.tngtech.archunit.lang.syntax.elements.GivenCodeUnits; import com.tngtech.archunit.lang.syntax.elements.GivenConstructors; import com.tngtech.archunit.lang.syntax.elements.GivenFields; @@ -10,21 +9,22 @@ import com.tngtech.archunit.lang.syntax.elements.GivenMethods; import com.tngtech.archunit.testutil.syntax.RandomSyntaxSeed; import com.tngtech.archunit.testutil.syntax.RandomSyntaxTestBase; -import com.tngtech.java.junit.dataprovider.DataProvider; +import org.junit.jupiter.params.provider.Arguments; + +import static java.util.function.Function.identity; public class RandomMembersSyntaxTest extends RandomSyntaxTestBase { - @DataProvider - public static List> random_rules() { - return FluentIterable - .from(createRandomMemberRules(givenMembersSeed())) - .append(createRandomMemberRules(givenFieldsSeed())) - .append(createRandomMemberRules(givenCodeUnitsSeed())) - .append(createRandomMemberRules(givenMethodsSeed())) - .append(createRandomMemberRules(givenConstructorsSeed())) - .toList(); + static Stream random_rules() { + return Stream.of( + createRandomMemberRules(givenMembersSeed()), + createRandomMemberRules(givenFieldsSeed()), + createRandomMemberRules(givenCodeUnitsSeed()), + createRandomMemberRules(givenMethodsSeed()), + createRandomMemberRules(givenConstructorsSeed()) + ).flatMap(identity()); } - private static List> createRandomMemberRules(RandomSyntaxSeed givenMembersSeed) { + private static Stream createRandomMemberRules(RandomSyntaxSeed givenMembersSeed) { return createRandomRules(givenMembersSeed, new SingleStringReplacement("meta annotated", "meta-annotated")); } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldTest.java index db74bdfae1..a0887dc947 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldTest.java @@ -10,6 +10,7 @@ import java.util.List; import java.util.Set; import java.util.regex.Pattern; +import java.util.stream.Stream; import com.google.common.base.Joiner; import com.google.common.collect.ImmutableList; @@ -32,14 +33,13 @@ import com.tngtech.archunit.lang.conditions.ArchConditions; import com.tngtech.archunit.lang.syntax.elements.testclasses.SomeClass; import com.tngtech.archunit.lang.syntax.elements.testclasses.WrongNamedClass; -import com.tngtech.archunit.testutil.ArchConfigurationRule; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; +import com.tngtech.archunit.testutil.ArchConfigurationExtension; import org.assertj.core.api.ThrowableAssert.ThrowingCallable; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.base.DescribedPredicate.alwaysFalse; import static com.tngtech.archunit.base.DescribedPredicate.alwaysTrue; @@ -72,31 +72,27 @@ import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes; import static com.tngtech.archunit.testutil.Assertions.assertThat; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; +import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.Arrays.stream; import static java.util.regex.Pattern.quote; import static org.assertj.core.api.Assertions.assertThatThrownBy; -@RunWith(DataProviderRunner.class) public class ClassesShouldTest { static final String FAILURE_REPORT_NEWLINE_MARKER = "#"; - @Rule - public final ArchConfigurationRule configurationRule = new ArchConfigurationRule(); + @RegisterExtension + ArchConfigurationExtension archConfiguration = new ArchConfigurationExtension(); - @DataProvider - public static Object[][] haveFullyQualifiedName_rules() { - return $$( + static Stream haveFullyQualifiedName_rules() { + return Stream.of( $(classes().should().haveFullyQualifiedName(SomeClass.class.getName())), $(classes().should(ArchConditions.haveFullyQualifiedName(SomeClass.class.getName()))) ); } - @Test - @UseDataProvider("haveFullyQualifiedName_rules") - public void haveFullyQualifiedName(ArchRule rule) { + @ParameterizedTest + @MethodSource("haveFullyQualifiedName_rules") + void haveFullyQualifiedName(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses(SomeClass.class, WrongNamedClass.class)); assertThat(singleLineFailureReportOf(result)) @@ -108,17 +104,16 @@ public void haveFullyQualifiedName(ArchRule rule) { .doesNotMatch(String.format(".*<%s>.*name.*", quote(SomeClass.class.getName()))); } - @DataProvider - public static Object[][] notHaveFullyQualifiedName_rules() { - return $$( + static Stream notHaveFullyQualifiedName_rules() { + return Stream.of( $(classes().should().notHaveFullyQualifiedName(WrongNamedClass.class.getName())), $(classes().should(ArchConditions.notHaveFullyQualifiedName(WrongNamedClass.class.getName()))) ); } - @Test - @UseDataProvider("notHaveFullyQualifiedName_rules") - public void notHaveFullyQualifiedName(ArchRule rule) { + @ParameterizedTest + @MethodSource("notHaveFullyQualifiedName_rules") + void notHaveFullyQualifiedName(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses( SomeClass.class, WrongNamedClass.class)); @@ -128,17 +123,16 @@ public void notHaveFullyQualifiedName(ArchRule rule) { .doesNotContain(String.format("<%s>.*name", SomeClass.class.getName())); } - @DataProvider - public static Object[][] haveSimpleName_rules() { - return $$( + static Stream haveSimpleName_rules() { + return Stream.of( $(classes().should().haveSimpleName(SomeClass.class.getSimpleName())), $(classes().should(ArchConditions.haveSimpleName(SomeClass.class.getSimpleName()))) ); } - @Test - @UseDataProvider("haveSimpleName_rules") - public void haveSimpleName(ArchRule rule) { + @ParameterizedTest + @MethodSource("haveSimpleName_rules") + void haveSimpleName(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses( SomeClass.class, WrongNamedClass.class)); @@ -151,17 +145,16 @@ public void haveSimpleName(ArchRule rule) { .doesNotMatch(String.format(".*<%s>.*simple name.*", SomeClass.class.getSimpleName())); } - @DataProvider - public static Object[][] notHaveSimpleName_rules() { - return $$( + static Stream notHaveSimpleName_rules() { + return Stream.of( $(classes().should().notHaveSimpleName(WrongNamedClass.class.getSimpleName())), $(classes().should(ArchConditions.notHaveSimpleName(WrongNamedClass.class.getSimpleName()))) ); } - @Test - @UseDataProvider("notHaveSimpleName_rules") - public void notHaveSimpleName(ArchRule rule) { + @ParameterizedTest + @MethodSource("notHaveSimpleName_rules") + void notHaveSimpleName(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses( SomeClass.class, WrongNamedClass.class)); @@ -174,18 +167,17 @@ public void notHaveSimpleName(ArchRule rule) { .doesNotMatch(String.format(".*<%s>.*simple name.*", SomeClass.class.getSimpleName())); } - @DataProvider - public static Object[][] haveNameMatching_rules() { + static Stream haveNameMatching_rules() { String regex = containsPartOfRegex(SomeClass.class.getSimpleName()); - return $$( + return Stream.of( $(classes().should().haveNameMatching(regex), regex), $(classes().should(ArchConditions.haveNameMatching(regex)), regex) ); } - @Test - @UseDataProvider("haveNameMatching_rules") - public void haveNameMatching(ArchRule rule, String regex) { + @ParameterizedTest + @MethodSource("haveNameMatching_rules") + void haveNameMatching(ArchRule rule, String regex) { EvaluationResult result = rule.evaluate(importClasses( SomeClass.class, WrongNamedClass.class)); @@ -198,18 +190,17 @@ public void haveNameMatching(ArchRule rule, String regex) { .doesNotContain(String.format("%s", SomeClass.class.getSimpleName())); } - @DataProvider - public static Object[][] haveNameNotMatching_rules() { + static Stream haveNameNotMatching_rules() { String regex = containsPartOfRegex(WrongNamedClass.class.getSimpleName()); - return $$( + return Stream.of( $(classes().should().haveNameNotMatching(regex), regex), $(classes().should(ArchConditions.haveNameNotMatching(regex)), regex) ); } - @Test - @UseDataProvider("haveNameNotMatching_rules") - public void haveNameNotMatching(ArchRule rule, String regex) { + @ParameterizedTest + @MethodSource("haveNameNotMatching_rules") + void haveNameNotMatching(ArchRule rule, String regex) { EvaluationResult result = rule.evaluate(importClasses( SomeClass.class, WrongNamedClass.class)); @@ -222,19 +213,18 @@ public void haveNameNotMatching(ArchRule rule, String regex) { .doesNotContain(String.format("%s", SomeClass.class.getSimpleName())); } - @DataProvider - public static Object[][] haveSimpleNameStartingWith_rules() { + static Stream haveSimpleNameStartingWith_rules() { String simpleName = SomeClass.class.getSimpleName(); String prefix = simpleName.substring(0, simpleName.length() - 1); - return $$( + return Stream.of( $(classes().should().haveSimpleNameStartingWith(prefix), prefix), $(classes().should(ArchConditions.haveSimpleNameStartingWith(prefix)), prefix) ); } - @Test - @UseDataProvider("haveSimpleNameStartingWith_rules") - public void haveSimpleNameStartingWith(ArchRule rule, String prefix) { + @ParameterizedTest + @MethodSource("haveSimpleNameStartingWith_rules") + void haveSimpleNameStartingWith(ArchRule rule, String prefix) { EvaluationResult result = rule.evaluate(importClasses( SomeClass.class, WrongNamedClass.class)); @@ -247,19 +237,18 @@ public void haveSimpleNameStartingWith(ArchRule rule, String prefix) { .doesNotContain(SomeClass.class.getName()); } - @DataProvider - public static Object[][] haveSimpleNameNotStartingWith_rules() { + static Stream haveSimpleNameNotStartingWith_rules() { String simpleName = WrongNamedClass.class.getSimpleName(); String prefix = simpleName.substring(0, simpleName.length() - 1); - return $$( + return Stream.of( $(classes().should().haveSimpleNameNotStartingWith(prefix), prefix), $(classes().should(ArchConditions.haveSimpleNameNotStartingWith(prefix)), prefix) ); } - @Test - @UseDataProvider("haveSimpleNameNotStartingWith_rules") - public void haveSimpleNameNotStartingWith(ArchRule rule, String prefix) { + @ParameterizedTest + @MethodSource("haveSimpleNameNotStartingWith_rules") + void haveSimpleNameNotStartingWith(ArchRule rule, String prefix) { EvaluationResult result = rule.evaluate(importClasses( SomeClass.class, WrongNamedClass.class)); @@ -272,19 +261,18 @@ public void haveSimpleNameNotStartingWith(ArchRule rule, String prefix) { .doesNotContain(SomeClass.class.getName()); } - @DataProvider - public static Object[][] haveSimpleNameContaining_rules() { + static Stream haveSimpleNameContaining_rules() { String simpleName = SomeClass.class.getSimpleName(); String infix = simpleName.substring(1, simpleName.length() - 1); - return $$( + return Stream.of( $(classes().should().haveSimpleNameContaining(infix), infix), $(classes().should(ArchConditions.haveSimpleNameContaining(infix)), infix) ); } - @Test - @UseDataProvider("haveSimpleNameContaining_rules") - public void haveSimpleNameContaining(ArchRule rule, String infix) { + @ParameterizedTest + @MethodSource("haveSimpleNameContaining_rules") + void haveSimpleNameContaining(ArchRule rule, String infix) { EvaluationResult result = rule.evaluate(importClasses( SomeClass.class, WrongNamedClass.class)); @@ -297,19 +285,18 @@ public void haveSimpleNameContaining(ArchRule rule, String infix) { .doesNotContain(SomeClass.class.getName()); } - @DataProvider - public static Object[][] haveSimpleNameNotContaining_rules() { + static Stream haveSimpleNameNotContaining_rules() { String simpleName = WrongNamedClass.class.getSimpleName(); String infix = simpleName.substring(1, simpleName.length() - 1); - return $$( + return Stream.of( $(classes().should().haveSimpleNameNotContaining(infix), infix), $(classes().should(ArchConditions.haveSimpleNameNotContaining(infix)), infix) ); } - @Test - @UseDataProvider("haveSimpleNameNotContaining_rules") - public void haveSimpleNameNotContaining(ArchRule rule, String infix) { + @ParameterizedTest + @MethodSource("haveSimpleNameNotContaining_rules") + void haveSimpleNameNotContaining(ArchRule rule, String infix) { EvaluationResult result = rule.evaluate(importClasses( SomeClass.class, WrongNamedClass.class)); @@ -322,19 +309,18 @@ public void haveSimpleNameNotContaining(ArchRule rule, String infix) { .doesNotContain(SomeClass.class.getName()); } - @DataProvider - public static Object[][] haveSimpleNameEndingWith_rules() { + static Stream haveSimpleNameEndingWith_rules() { String simpleName = SomeClass.class.getSimpleName(); String suffix = simpleName.substring(1); - return $$( + return Stream.of( $(classes().should().haveSimpleNameEndingWith(suffix), suffix), $(classes().should(ArchConditions.haveSimpleNameEndingWith(suffix)), suffix) ); } - @Test - @UseDataProvider("haveSimpleNameEndingWith_rules") - public void haveSimpleNameEndingWith(ArchRule rule, String suffix) { + @ParameterizedTest + @MethodSource("haveSimpleNameEndingWith_rules") + void haveSimpleNameEndingWith(ArchRule rule, String suffix) { EvaluationResult result = rule.evaluate(importClasses( SomeClass.class, WrongNamedClass.class)); @@ -347,19 +333,18 @@ public void haveSimpleNameEndingWith(ArchRule rule, String suffix) { .doesNotContain(SomeClass.class.getName()); } - @DataProvider - public static Object[][] haveSimpleNameNotEndingWith_rules() { + static Stream haveSimpleNameNotEndingWith_rules() { String simpleName = WrongNamedClass.class.getSimpleName(); String suffix = simpleName.substring(1); - return $$( + return Stream.of( $(classes().should().haveSimpleNameNotEndingWith(suffix), suffix), $(classes().should(ArchConditions.haveSimpleNameNotEndingWith(suffix)), suffix) ); } - @Test - @UseDataProvider("haveSimpleNameNotEndingWith_rules") - public void haveSimpleNameNotEndingWith(ArchRule rule, String suffix) { + @ParameterizedTest + @MethodSource("haveSimpleNameNotEndingWith_rules") + void haveSimpleNameNotEndingWith(ArchRule rule, String suffix) { EvaluationResult result = rule.evaluate(importClasses( SomeClass.class, WrongNamedClass.class)); @@ -372,18 +357,17 @@ public void haveSimpleNameNotEndingWith(ArchRule rule, String suffix) { .doesNotContain(SomeClass.class.getName()); } - @DataProvider - public static Object[][] resideInAPackage_rules() { + static Stream resideInAPackage_rules() { String thePackage = ArchRule.class.getPackage().getName(); - return $$( + return Stream.of( $(classes().should().resideInAPackage(thePackage), thePackage), $(classes().should(ArchConditions.resideInAPackage(thePackage)), thePackage) ); } - @Test - @UseDataProvider("resideInAPackage_rules") - public void resideInAPackage(ArchRule rule, String packageIdentifier) { + @ParameterizedTest + @MethodSource("resideInAPackage_rules") + void resideInAPackage(ArchRule rule, String packageIdentifier) { checkTestStillValid(packageIdentifier, ImmutableSet.of(ArchRule.class, ArchCondition.class), ImmutableSet.of(ArchConfiguration.class), @@ -400,11 +384,10 @@ public void resideInAPackage(ArchRule rule, String packageIdentifier) { .doesNotContain(String.format("%s", ArchCondition.class.getSimpleName())); } - @DataProvider - public static Object[][] resideInAnyPackage_rules() { + static Stream resideInAnyPackage_rules() { String firstPackage = ArchRule.class.getPackage().getName(); String secondPackage = ArchConfiguration.class.getPackage().getName(); - return $$( + return Stream.of( $(classes().should().resideInAnyPackage(firstPackage, secondPackage), new String[]{firstPackage, secondPackage}), $(classes().should(ArchConditions.resideInAnyPackage(firstPackage, secondPackage)), @@ -412,9 +395,9 @@ public static Object[][] resideInAnyPackage_rules() { ); } - @Test - @UseDataProvider("resideInAnyPackage_rules") - public void resideInAnyPackage(ArchRule rule, String... packageIdentifiers) { + @ParameterizedTest + @MethodSource("resideInAnyPackage_rules") + void resideInAnyPackage(ArchRule rule, String... packageIdentifiers) { checkTestStillValid(packageIdentifiers, ImmutableSet.of(ArchRule.class, ArchConfiguration.class), ImmutableSet.of(GivenObjects.class)); @@ -429,18 +412,17 @@ public void resideInAnyPackage(ArchRule rule, String... packageIdentifiers) { .doesNotContain(String.format("%s", ArchConfiguration.class.getSimpleName())); } - @DataProvider - public static Object[][] resideOutsideOfPackage_rules() { + static Stream resideOutsideOfPackage_rules() { String thePackage = ArchRule.class.getPackage().getName(); - return $$( + return Stream.of( $(classes().should().resideOutsideOfPackage(thePackage), thePackage), $(classes().should(ArchConditions.resideOutsideOfPackage(thePackage)), thePackage) ); } - @Test - @UseDataProvider("resideOutsideOfPackage_rules") - public void resideOutsideOfPackage(ArchRule rule, String packageIdentifier) { + @ParameterizedTest + @MethodSource("resideOutsideOfPackage_rules") + void resideOutsideOfPackage(ArchRule rule, String packageIdentifier) { checkTestStillValid(packageIdentifier, ImmutableSet.of(ArchRule.class, ArchCondition.class), ImmutableSet.of(ArchConfiguration.class), @@ -457,11 +439,10 @@ public void resideOutsideOfPackage(ArchRule rule, String packageIdentifier) { .doesNotContain(String.format("%s", GivenObjects.class.getSimpleName())); } - @DataProvider - public static Object[][] resideOutsideOfPackages_rules() { + static Stream resideOutsideOfPackages_rules() { String firstPackage = ArchRule.class.getPackage().getName(); String secondPackage = ArchConfiguration.class.getPackage().getName(); - return $$( + return Stream.of( $(classes().should().resideOutsideOfPackages(firstPackage, secondPackage), new String[]{firstPackage, secondPackage}), $(classes().should(ArchConditions.resideOutsideOfPackages(firstPackage, secondPackage)), @@ -469,9 +450,9 @@ public static Object[][] resideOutsideOfPackages_rules() { ); } - @Test - @UseDataProvider("resideOutsideOfPackages_rules") - public void resideOutsideOfPackages(ArchRule rule, String... packageIdentifiers) { + @ParameterizedTest + @MethodSource("resideOutsideOfPackages_rules") + void resideOutsideOfPackages(ArchRule rule, String... packageIdentifiers) { checkTestStillValid(packageIdentifiers, ImmutableSet.of(ArchRule.class, ArchConfiguration.class), ImmutableSet.of(GivenObjects.class)); @@ -486,9 +467,8 @@ public void resideOutsideOfPackages(ArchRule rule, String... packageIdentifiers) .doesNotContain(String.format("%s", GivenObjects.class.getSimpleName())); } - @DataProvider - public static Object[][] visibility_rules() { - return $$( + static Stream visibility_rules() { + return Stream.of( $(classes().should().bePublic(), PUBLIC, PublicClass.class, PrivateClass.class), $(classes().should(bePublic()), PUBLIC, PublicClass.class, PrivateClass.class), $(classes().should().beProtected(), PROTECTED, ProtectedClass.class, PrivateClass.class), @@ -497,10 +477,9 @@ public static Object[][] visibility_rules() { $(classes().should(bePrivate()), PRIVATE, PrivateClass.class, PublicClass.class)); } - @Test - @UseDataProvider("visibility_rules") - public void visibility(ArchRule rule, JavaModifier modifier, - Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("visibility_rules") + void visibility(ArchRule rule, JavaModifier modifier, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -509,9 +488,8 @@ public void visibility(ArchRule rule, JavaModifier modifier, .doesNotMatch(String.format(".*<%s>.* modifier %s.*", quote(satisfied.getName()), modifier)); } - @DataProvider - public static Object[][] not_visibility_rules() { - return $$( + static Stream not_visibility_rules() { + return Stream.of( $(classes().should().notBePublic(), PUBLIC, PrivateClass.class, PublicClass.class), $(classes().should(notBePublic()), PUBLIC, PrivateClass.class, PublicClass.class), $(classes().should().notBeProtected(), PROTECTED, PrivateClass.class, ProtectedClass.class), @@ -520,10 +498,9 @@ public static Object[][] not_visibility_rules() { $(classes().should(notBePrivate()), PRIVATE, PublicClass.class, PrivateClass.class)); } - @Test - @UseDataProvider("not_visibility_rules") - public void notVisibility(ArchRule rule, JavaModifier modifier, - Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("not_visibility_rules") + void notVisibility(ArchRule rule, JavaModifier modifier, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -532,16 +509,15 @@ public void notVisibility(ArchRule rule, JavaModifier modifier, .doesNotMatch(String.format(".*<%s>.* modifier %s.*", quote(satisfied.getName()), modifier)); } - @DataProvider - public static Object[][] package_private_visibility_rules() { - return $$( + static Stream package_private_visibility_rules() { + return Stream.of( $(classes().should().bePackagePrivate(), "be package private"), $(classes().should(bePackagePrivate()), "be package private")); } - @Test - @UseDataProvider("package_private_visibility_rules") - public void package_private_visibility(ArchRule rule, String description) { + @ParameterizedTest + @MethodSource("package_private_visibility_rules") + void package_private_visibility(ArchRule rule, String description) { EvaluationResult result = rule.evaluate(importClasses(PackagePrivateClass.class, PrivateClass.class)); assertThat(singleLineFailureReportOf(result)) @@ -550,16 +526,15 @@ public void package_private_visibility(ArchRule rule, String description) { .doesNotMatch(String.format(".*<%s>.* modifier.*", quote(PackagePrivateClass.class.getName()))); } - @DataProvider - public static Object[][] non_package_private_visibility_rules() { - return $$( + static Stream non_package_private_visibility_rules() { + return Stream.of( $(classes().should().notBePackagePrivate(), "not be package private"), $(classes().should(notBePackagePrivate()), "not be package private")); } - @Test - @UseDataProvider("non_package_private_visibility_rules") - public void non_package_private_visibility(ArchRule rule, String description) { + @ParameterizedTest + @MethodSource("non_package_private_visibility_rules") + void non_package_private_visibility(ArchRule rule, String description) { EvaluationResult result = rule.evaluate(importClasses(PrivateClass.class, PackagePrivateClass.class)); assertThat(singleLineFailureReportOf(result)) @@ -571,9 +546,8 @@ public void non_package_private_visibility(ArchRule rule, String description) { .doesNotMatch(String.format(".*<%s>.* modifier.*", quote(PrivateClass.class.getName()))); } - @DataProvider - public static Object[][] modifiers_rules() { - return $$( + static Stream modifiers_rules() { + return Stream.of( $(classes().should().haveModifier(PUBLIC), "", PUBLIC, PublicClass.class, PrivateClass.class), $(classes().should(haveModifier(PUBLIC)), "", PUBLIC, @@ -584,10 +558,10 @@ public static Object[][] modifiers_rules() { PrivateClass.class, PublicClass.class)); } - @Test - @UseDataProvider("modifiers_rules") - public void modifiers(ArchRule rule, String havePrefix, JavaModifier modifier, - Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("modifiers_rules") + void modifiers(ArchRule rule, String havePrefix, JavaModifier modifier, + Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -597,9 +571,8 @@ public void modifiers(ArchRule rule, String havePrefix, JavaModifier modifier, .doesNotMatch(String.format(".*<%s>.* modifier %s.*", quote(satisfied.getName()), modifier)); } - @DataProvider - public static Object[][] annotated_rules() { - return $$( + static Stream annotated_rules() { + return Stream.of( $(classes().should().beAnnotatedWith(RuntimeRetentionAnnotation.class), SomeAnnotatedClass.class, String.class), $(classes().should(ArchConditions.beAnnotatedWith(RuntimeRetentionAnnotation.class)), @@ -614,9 +587,9 @@ public static Object[][] annotated_rules() { SomeAnnotatedClass.class, String.class)); } - @Test - @UseDataProvider("annotated_rules") - public void annotatedWith(ArchRule rule, Class correctClass, Class wrongClass) { + @ParameterizedTest + @MethodSource("annotated_rules") + void annotatedWith(ArchRule rule, Class correctClass, Class wrongClass) { EvaluationResult result = rule.evaluate(importClasses(correctClass, wrongClass)); assertThat(singleLineFailureReportOf(result)) @@ -640,9 +613,8 @@ public void beAnnotatedWith_Retention_Source_is_rejected() { expectInvalidSyntaxUsageForRetentionSource(() -> classes().should().beAnnotatedWith(SourceRetentionAnnotation.class)); } - @DataProvider - public static Object[][] notAnnotated_rules() { - return $$( + static Stream notAnnotated_rules() { + return Stream.of( $(classes().should().notBeAnnotatedWith(RuntimeRetentionAnnotation.class), String.class, SomeAnnotatedClass.class), $(classes().should(ArchConditions.notBeAnnotatedWith(RuntimeRetentionAnnotation.class)), @@ -657,9 +629,9 @@ public static Object[][] notAnnotated_rules() { String.class, SomeAnnotatedClass.class)); } - @Test - @UseDataProvider("notAnnotated_rules") - public void notAnnotatedWith(ArchRule rule, Class correctClass, Class wrongClass) { + @ParameterizedTest + @MethodSource("notAnnotated_rules") + void notAnnotatedWith(ArchRule rule, Class correctClass, Class wrongClass) { EvaluationResult result = rule.evaluate(importClasses(correctClass, wrongClass)); assertThat(singleLineFailureReportOf(result)) @@ -671,9 +643,8 @@ public void notAnnotatedWith(ArchRule rule, Class correctClass, Class wron .doesNotMatch(String.format(".*<%s>.*annotated.*", quote(correctClass.getName()))); } - @DataProvider - public static Object[][] metaAnnotated_rules() { - return $$( + static Stream metaAnnotated_rules() { + return Stream.of( $(classes().should().beMetaAnnotatedWith(SomeMetaAnnotation.class), SomeAnnotatedClass.class, String.class), $(classes().should(ArchConditions.beMetaAnnotatedWith(SomeMetaAnnotation.class)), @@ -688,9 +659,9 @@ public static Object[][] metaAnnotated_rules() { SomeAnnotatedClass.class, String.class)); } - @Test - @UseDataProvider("metaAnnotated_rules") - public void metaAnnotatedWith(ArchRule rule, Class correctClass, Class wrongClass) { + @ParameterizedTest + @MethodSource("metaAnnotated_rules") + void metaAnnotatedWith(ArchRule rule, Class correctClass, Class wrongClass) { EvaluationResult result = rule.evaluate(importClasses(correctClass, wrongClass)); assertThat(singleLineFailureReportOf(result)) @@ -702,9 +673,8 @@ public void metaAnnotatedWith(ArchRule rule, Class correctClass, Class wro .doesNotMatch(String.format(".*<%s>.*meta-annotated.*", quote(correctClass.getName()))); } - @DataProvider - public static Object[][] notMetaAnnotated_rules() { - return $$( + static Stream notMetaAnnotated_rules() { + return Stream.of( $(classes().should().notBeMetaAnnotatedWith(SomeMetaAnnotation.class), String.class, SomeAnnotatedClass.class), $(classes().should(ArchConditions.notBeMetaAnnotatedWith(SomeMetaAnnotation.class)), @@ -719,9 +689,9 @@ public static Object[][] notMetaAnnotated_rules() { String.class, SomeAnnotatedClass.class)); } - @Test - @UseDataProvider("notMetaAnnotated_rules") - public void notMetaAnnotatedWith(ArchRule rule, Class correctClass, Class wrongClass) { + @ParameterizedTest + @MethodSource("notMetaAnnotated_rules") + void notMetaAnnotatedWith(ArchRule rule, Class correctClass, Class wrongClass) { EvaluationResult result = rule.evaluate(importClasses(correctClass, wrongClass)); assertThat(singleLineFailureReportOf(result)) @@ -745,9 +715,8 @@ public void notBeAnnotatedWith_Retention_Source_is_rejected() { expectInvalidSyntaxUsageForRetentionSource(() -> classes().should().notBeAnnotatedWith(SourceRetentionAnnotation.class)); } - @DataProvider - public static Object[][] implement_satisfied_rules() { - return $$( + static Stream implement_satisfied_rules() { + return Stream.of( $(classes().should().implement(Collection.class), ArrayList.class), $(classes().should(ArchConditions.implement(Collection.class)), ArrayList.class), $(classes().should().implement(Collection.class.getName()), ArrayList.class), @@ -756,9 +725,9 @@ public static Object[][] implement_satisfied_rules() { $(classes().should(ArchConditions.implement(name(Collection.class.getName()).as(Collection.class.getName()))), ArrayList.class)); } - @Test - @UseDataProvider("implement_satisfied_rules") - public void implement_satisfied(ArchRule rule, Class satisfied) { + @ParameterizedTest + @MethodSource("implement_satisfied_rules") + void implement_satisfied(ArchRule rule, Class satisfied) { EvaluationResult result = rule.evaluate(importHierarchies(satisfied)); assertThat(singleLineFailureReportOf(result)) @@ -772,33 +741,32 @@ public void implement_rejects_non_interface_types() { expectInvalidSyntaxUsageForClassInsteadOfInterface(AbstractList.class, () -> classes().should().implement(AbstractList.class)); } - @DataProvider - public static List> implement_not_satisfied_rules() { - return ImmutableList.>builder() + static List implement_not_satisfied_rules() { + return ImmutableList.builder() .addAll(implementNotSatisfiedCases(Collection.class, List.class)) .addAll(implementNotSatisfiedCases(Set.class, ArrayList.class)) .build(); } - private static List> implementNotSatisfiedCases(Class classToCheckAgainst, Class violating) { + private static List implementNotSatisfiedCases(Class classToCheckAgainst, Class violating) { return ImmutableList.of( - ImmutableList.of(classes().should().implement(classToCheckAgainst), + $(classes().should().implement(classToCheckAgainst), classToCheckAgainst, violating), - ImmutableList.of(classes().should(ArchConditions.implement(classToCheckAgainst)), + $(classes().should(ArchConditions.implement(classToCheckAgainst)), classToCheckAgainst, violating), - ImmutableList.of(classes().should().implement(classToCheckAgainst.getName()), + $(classes().should().implement(classToCheckAgainst.getName()), classToCheckAgainst, violating), - ImmutableList.of(classes().should(ArchConditions.implement(classToCheckAgainst.getName())), + $(classes().should(ArchConditions.implement(classToCheckAgainst.getName())), classToCheckAgainst, violating), - ImmutableList.of(classes().should().implement(name(classToCheckAgainst.getName()).as(classToCheckAgainst.getName())), + $(classes().should().implement(name(classToCheckAgainst.getName()).as(classToCheckAgainst.getName())), classToCheckAgainst, violating), - ImmutableList.of(classes().should(ArchConditions.implement(name(classToCheckAgainst.getName()).as(classToCheckAgainst.getName()))), + $(classes().should(ArchConditions.implement(name(classToCheckAgainst.getName()).as(classToCheckAgainst.getName()))), classToCheckAgainst, violating)); } - @Test - @UseDataProvider("implement_not_satisfied_rules") - public void implement_not_satisfied(ArchRule rule, Class classToCheckAgainst, Class violating) { + @ParameterizedTest + @MethodSource("implement_not_satisfied_rules") + void implement_not_satisfied(ArchRule rule, Class classToCheckAgainst, Class violating) { EvaluationResult result = rule.evaluate(importHierarchies(violating)); assertThat(singleLineFailureReportOf(result)) @@ -809,9 +777,8 @@ public void implement_not_satisfied(ArchRule rule, Class classToCheckAgainst, locationPattern(violating))); } - @DataProvider - public static Object[][] notImplement_rules() { - return $$( + static Stream notImplement_rules() { + return Stream.of( $(classes().should().notImplement(Collection.class), List.class, ArrayList.class), $(classes().should(ArchConditions.notImplement(Collection.class)), List.class, ArrayList.class), $(classes().should().notImplement(Collection.class.getName()), List.class, ArrayList.class), @@ -821,9 +788,9 @@ public static Object[][] notImplement_rules() { List.class, ArrayList.class)); } - @Test - @UseDataProvider("notImplement_rules") - public void notImplement(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("notImplement_rules") + void notImplement(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -842,9 +809,8 @@ public void notImplement_rejects_non_interface_types() { expectInvalidSyntaxUsageForClassInsteadOfInterface(AbstractList.class, () -> classes().should().notImplement(AbstractList.class)); } - @DataProvider - public static Object[][] assignableTo_rules() { - return $$( + static Stream assignableTo_rules() { + return Stream.of( $(classes().should().beAssignableTo(Collection.class), List.class, String.class), $(classes().should(ArchConditions.beAssignableTo(Collection.class)), List.class, String.class), $(classes().should().beAssignableTo(Collection.class.getName()), List.class, String.class), @@ -854,9 +820,9 @@ public static Object[][] assignableTo_rules() { List.class, String.class)); } - @Test - @UseDataProvider("assignableTo_rules") - public void assignableTo(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("assignableTo_rules") + void assignableTo(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -868,9 +834,8 @@ public void assignableTo(ArchRule rule, Class satisfied, Class violated) { .doesNotMatch(String.format(".*%s.* assignable.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] notAssignableTo_rules() { - return $$( + static Stream notAssignableTo_rules() { + return Stream.of( $(classes().should().notBeAssignableTo(Collection.class), String.class, List.class), $(classes().should(ArchConditions.notBeAssignableTo(Collection.class)), String.class, List.class), $(classes().should().notBeAssignableTo(Collection.class.getName()), String.class, List.class), @@ -880,9 +845,9 @@ public static Object[][] notAssignableTo_rules() { String.class, List.class)); } - @Test - @UseDataProvider("notAssignableTo_rules") - public void notAssignableTo(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("notAssignableTo_rules") + void notAssignableTo(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -894,9 +859,8 @@ public void notAssignableTo(ArchRule rule, Class satisfied, Class violated .doesNotMatch(String.format(".*%s.* assignable.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] assignableFrom_rules() { - return $$( + static Stream assignableFrom_rules() { + return Stream.of( $(classes().should().beAssignableFrom(List.class), Collection.class, String.class), $(classes().should(ArchConditions.beAssignableFrom(List.class)), Collection.class, String.class), $(classes().should().beAssignableFrom(List.class.getName()), Collection.class, String.class), @@ -906,9 +870,9 @@ public static Object[][] assignableFrom_rules() { Collection.class, String.class)); } - @Test - @UseDataProvider("assignableFrom_rules") - public void assignableFrom(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("assignableFrom_rules") + void assignableFrom(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -920,9 +884,8 @@ public void assignableFrom(ArchRule rule, Class satisfied, Class violated) .doesNotMatch(String.format(".*%s.* assignable.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] notAssignableFrom_rules() { - return $$( + static Stream notAssignableFrom_rules() { + return Stream.of( $(classes().should().notBeAssignableFrom(List.class), String.class, Collection.class), $(classes().should(ArchConditions.notBeAssignableFrom(List.class)), String.class, Collection.class), $(classes().should().notBeAssignableFrom(List.class.getName()), String.class, Collection.class), @@ -932,9 +895,9 @@ public static Object[][] notAssignableFrom_rules() { String.class, Collection.class)); } - @Test - @UseDataProvider("notAssignableFrom_rules") - public void notAssignableFrom(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("notAssignableFrom_rules") + void notAssignableFrom(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -946,9 +909,8 @@ public void notAssignableFrom(ArchRule rule, Class satisfied, Class violat .doesNotMatch(String.format(".*%s.* assignable.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] accessField_rules() { - return $$( + static Stream accessField_rules() { + return Stream.of( $(classes().should().getField(ClassWithField.class, "field"), "get", "gets"), $(classes().should(ArchConditions.getField(ClassWithField.class, "field")), "get", "gets"), $(classes().should().getField(ClassWithField.class.getName(), "field"), "get", "gets"), @@ -964,9 +926,9 @@ public static Object[][] accessField_rules() { ); } - @Test - @UseDataProvider("accessField_rules") - public void accessField(ArchRule rule, String accessTypePlural, String accessTypeSingularRegex) { + @ParameterizedTest + @MethodSource("accessField_rules") + void accessField(ArchRule rule, String accessTypePlural, String accessTypeSingularRegex) { EvaluationResult result = rule.evaluate(importClasses( ClassWithField.class, ClassAccessingField.class, ClassAccessingWrongField.class)); @@ -981,9 +943,8 @@ public void accessField(ArchRule rule, String accessTypePlural, String accessTyp ClassWithField.class, "field")); } - @DataProvider - public static Object[][] accessFieldWhere_rules() { - return $$( + static Stream accessFieldWhere_rules() { + return Stream.of( $(classes().should().getFieldWhere(accessTargetIs(ClassWithField.class)), "get", "gets"), $(classes().should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class))), "get", "gets"), $(classes().should().setFieldWhere(accessTargetIs(ClassWithField.class)), "set", "sets"), @@ -993,9 +954,9 @@ public static Object[][] accessFieldWhere_rules() { ); } - @Test - @UseDataProvider("accessFieldWhere_rules") - public void accessFieldWhere(ArchRule rule, String accessTypePlural, String accessTypeSingularRegex) { + @ParameterizedTest + @MethodSource("accessFieldWhere_rules") + void accessFieldWhere(ArchRule rule, String accessTypePlural, String accessTypeSingularRegex) { EvaluationResult result = rule.evaluate(importClasses( ClassWithField.class, ClassAccessingField.class, ClassAccessingWrongField.class)); @@ -1010,17 +971,16 @@ public void accessFieldWhere(ArchRule rule, String accessTypePlural, String acce ClassWithField.class, "field")); } - @DataProvider - public static Object[][] onlyAccessFieldsThat_rules() { - return testForEach( + static Stream onlyAccessFieldsThat_rules() { + return Stream.of( classes().should().onlyAccessFieldsThat(are(declaredIn(ClassWithField.class))), classes().should(ArchConditions.onlyAccessFieldsThat(are(declaredIn(ClassWithField.class)))) ); } - @Test - @UseDataProvider("onlyAccessFieldsThat_rules") - public void onlyAccessFieldsThat(ArchRule rule) { + @ParameterizedTest + @MethodSource("onlyAccessFieldsThat_rules") + void onlyAccessFieldsThat(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses( ClassWithField.class, ClassAccessingField.class, ClassAccessingWrongField.class)); @@ -1040,9 +1000,8 @@ public void onlyAccessFieldsThat(ArchRule rule) { ClassWithField.class, "field")); } - @DataProvider - public static Object[][] callMethod_rules() { - return testForEach( + static Stream callMethod_rules() { + return Stream.of( classes().should().callMethod(ClassWithMethod.class, "method", String.class), classes().should(ArchConditions.callMethod(ClassWithMethod.class, "method", String.class)), classes().should().callMethod(ClassWithMethod.class.getName(), "method", String.class.getName()), @@ -1050,9 +1009,9 @@ public static Object[][] callMethod_rules() { ); } - @Test - @UseDataProvider("callMethod_rules") - public void callMethod(ArchRule rule) { + @ParameterizedTest + @MethodSource("callMethod_rules") + void callMethod(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses( ClassWithMethod.class, ClassCallingMethod.class, ClassCallingWrongMethod.class)); @@ -1067,17 +1026,16 @@ public void callMethod(ArchRule rule) { ClassWithMethod.class, "method", String.class)); } - @DataProvider - public static Object[][] callMethodWhere_rules() { - return $$( + static Stream callMethodWhere_rules() { + return Stream.of( $(classes().should().callMethodWhere(callTargetIs(ClassWithMethod.class))), $(classes().should(ArchConditions.callMethodWhere(callTargetIs(ClassWithMethod.class)))) ); } - @Test - @UseDataProvider("callMethodWhere_rules") - public void callMethodWhere(ArchRule rule) { + @ParameterizedTest + @MethodSource("callMethodWhere_rules") + void callMethodWhere(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses( ClassWithMethod.class, ClassCallingMethod.class, ClassCallingWrongMethod.class, ClassCallingSelf.class)); @@ -1095,17 +1053,16 @@ public void callMethodWhere(ArchRule rule) { ClassWithMethod.class, "method", String.class)); } - @DataProvider - public static Object[][] onlyCallMethodsThat_rules() { - return $$( + static Stream onlyCallMethodsThat_rules() { + return Stream.of( $(classes().should().onlyCallMethodsThat(are(declaredIn(ClassWithMethod.class)))), $(classes().should(ArchConditions.onlyCallMethodsThat(are(declaredIn(ClassWithMethod.class))))) ); } - @Test - @UseDataProvider("onlyCallMethodsThat_rules") - public void onlyCallMethodsThat(ArchRule rule) { + @ParameterizedTest + @MethodSource("onlyCallMethodsThat_rules") + void onlyCallMethodsThat(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses( ClassWithMethod.class, ClassCallingMethod.class, ClassCallingWrongMethod.class)); @@ -1123,9 +1080,8 @@ public void onlyCallMethodsThat(ArchRule rule) { ClassWithMethod.class, "method", String.class)); } - @DataProvider - public static Object[][] callConstructor_rules() { - return $$( + static Stream callConstructor_rules() { + return Stream.of( $(classes().should().callConstructor(ClassWithConstructor.class, String.class)), $(classes().should(ArchConditions.callConstructor(ClassWithConstructor.class, String.class))), $(classes().should().callConstructor(ClassWithConstructor.class.getName(), String.class.getName())), @@ -1133,9 +1089,9 @@ public static Object[][] callConstructor_rules() { ); } - @Test - @UseDataProvider("callConstructor_rules") - public void callConstructor(ArchRule rule) { + @ParameterizedTest + @MethodSource("callConstructor_rules") + void callConstructor(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses( ClassWithConstructor.class, ClassCallingConstructor.class, ClassCallingWrongConstructor.class)); @@ -1150,17 +1106,16 @@ public void callConstructor(ArchRule rule) { ClassWithConstructor.class, String.class)); } - @DataProvider - public static Object[][] callConstructorWhere_rules() { - return $$( + static Stream callConstructorWhere_rules() { + return Stream.of( $(classes().should().callConstructorWhere(callTargetIs(ClassWithConstructor.class))), $(classes().should(ArchConditions.callConstructorWhere(callTargetIs(ClassWithConstructor.class)))) ); } - @Test - @UseDataProvider("callConstructorWhere_rules") - public void callConstructorWhere(ArchRule rule) { + @ParameterizedTest + @MethodSource("callConstructorWhere_rules") + void callConstructorWhere(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses( ClassWithConstructor.class, ClassCallingConstructor.class, ClassCallingWrongConstructor.class)); @@ -1175,17 +1130,16 @@ public void callConstructorWhere(ArchRule rule) { ClassWithConstructor.class, String.class)); } - @DataProvider - public static Object[][] onlyCallConstructorsThat_rules() { - return $$( + static Stream onlyCallConstructorsThat_rules() { + return Stream.of( $(classes().should().onlyCallConstructorsThat(are(declaredIn(ClassWithConstructor.class)))), $(classes().should(ArchConditions.onlyCallConstructorsThat(are(declaredIn(ClassWithConstructor.class))))) ); } - @Test - @UseDataProvider("onlyCallConstructorsThat_rules") - public void onlyCallConstructorsThat(ArchRule rule) { + @ParameterizedTest + @MethodSource("onlyCallConstructorsThat_rules") + void onlyCallConstructorsThat(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses( ClassWithConstructor.class, ClassCallingConstructor.class, ClassCallingWrongConstructor.class)); @@ -1203,17 +1157,16 @@ public void onlyCallConstructorsThat(ArchRule rule) { ClassWithConstructor.class, String.class)); } - @DataProvider - public static Object[][] accessTargetWhere_rules() { - return $$( + static Stream accessTargetWhere_rules() { + return Stream.of( $(classes().should().accessTargetWhere(accessTargetIs(ClassWithFieldMethodAndConstructor.class))), $(classes().should(ArchConditions.accessTargetWhere(accessTargetIs(ClassWithFieldMethodAndConstructor.class)))) ); } - @Test - @UseDataProvider("accessTargetWhere_rules") - public void accessTargetWhere(ArchRule rule) { + @ParameterizedTest + @MethodSource("accessTargetWhere_rules") + void accessTargetWhere(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses( ClassWithFieldMethodAndConstructor.class, ClassAccessingFieldMethodAndConstructor.class, ClassAccessingWrongFieldMethodAndConstructor.class)); @@ -1235,17 +1188,16 @@ public void accessTargetWhere(ArchRule rule) { ClassWithFieldMethodAndConstructor.class, "")); } - @DataProvider - public static Object[][] callCodeUnitWhere_rules() { - return $$( + static Stream callCodeUnitWhere_rules() { + return Stream.of( $(classes().should().callCodeUnitWhere(accessTargetIs(ClassWithFieldMethodAndConstructor.class))), $(classes().should(ArchConditions.callCodeUnitWhere(accessTargetIs(ClassWithFieldMethodAndConstructor.class)))) ); } - @Test - @UseDataProvider("callCodeUnitWhere_rules") - public void callCodeUnitWhere(ArchRule rule) { + @ParameterizedTest + @MethodSource("callCodeUnitWhere_rules") + void callCodeUnitWhere(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses( ClassWithFieldMethodAndConstructor.class, ClassAccessingFieldMethodAndConstructor.class, ClassAccessingWrongFieldMethodAndConstructor.class)); @@ -1267,17 +1219,16 @@ public void callCodeUnitWhere(ArchRule rule) { ClassWithFieldMethodAndConstructor.class, "")); } - @DataProvider - public static Object[][] onlyCallCodeUnitsThat_rules() { - return $$( + static Stream onlyCallCodeUnitsThat_rules() { + return Stream.of( $(classes().should().onlyCallCodeUnitsThat(are(declaredIn(ClassWithFieldMethodAndConstructor.class)))), $(classes().should(ArchConditions.onlyCallCodeUnitsThat(are(declaredIn(ClassWithFieldMethodAndConstructor.class))))) ); } - @Test - @UseDataProvider("onlyCallCodeUnitsThat_rules") - public void onlyCallCodeUnitsThat(ArchRule rule) { + @ParameterizedTest + @MethodSource("onlyCallCodeUnitsThat_rules") + void onlyCallCodeUnitsThat(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses( ClassWithFieldMethodAndConstructor.class, ClassAccessingFieldMethodAndConstructor.class, ClassAccessingWrongFieldMethodAndConstructor.class)); @@ -1302,17 +1253,16 @@ public void onlyCallCodeUnitsThat(ArchRule rule) { ClassWithFieldMethodAndConstructor.class, "")); } - @DataProvider - public static Object[][] onlyAccessMembersThat_rules() { - return $$( + static Stream onlyAccessMembersThat_rules() { + return Stream.of( $(classes().should().onlyAccessMembersThat(are(declaredIn(ClassWithFieldMethodAndConstructor.class)))), $(classes().should(ArchConditions.onlyAccessMembersThat(are(declaredIn(ClassWithFieldMethodAndConstructor.class))))) ); } - @Test - @UseDataProvider("onlyAccessMembersThat_rules") - public void onlyAccessMembersThat(ArchRule rule) { + @ParameterizedTest + @MethodSource("onlyAccessMembersThat_rules") + void onlyAccessMembersThat(ArchRule rule) { EvaluationResult result = rule.evaluate(importClasses( ClassWithFieldMethodAndConstructor.class, ClassAccessingFieldMethodAndConstructor.class, ClassAccessingWrongFieldMethodAndConstructor.class)); @@ -1337,16 +1287,15 @@ public void onlyAccessMembersThat(ArchRule rule) { ClassWithFieldMethodAndConstructor.class, "")); } - @DataProvider - public static Object[][] beInterfaces_rules() { - return $$( + static Stream beInterfaces_rules() { + return Stream.of( $(classes().should().beInterfaces(), Collection.class, String.class), $(classes().should(ArchConditions.beInterfaces()), Collection.class, String.class)); } - @Test - @UseDataProvider("beInterfaces_rules") - public void beInterfaces(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("beInterfaces_rules") + void beInterfaces(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1357,16 +1306,15 @@ public void beInterfaces(ArchRule rule, Class satisfied, Class violated) { .doesNotMatch(String.format(".*%s.* interface.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] notBeInterfaces_rules() { - return $$( + static Stream notBeInterfaces_rules() { + return Stream.of( $(classes().should().notBeInterfaces(), String.class, Collection.class), $(classes().should(ArchConditions.notBeInterfaces()), String.class, Collection.class)); } - @Test - @UseDataProvider("notBeInterfaces_rules") - public void notBeInterfaces(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("notBeInterfaces_rules") + void notBeInterfaces(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1377,16 +1325,15 @@ public void notBeInterfaces(ArchRule rule, Class satisfied, Class violated .doesNotMatch(String.format(".*%s.* interface.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] beEnums_rules() { - return $$( + static Stream beEnums_rules() { + return Stream.of( $(classes().should().beEnums(), StandardCopyOption.class, String.class), $(classes().should(ArchConditions.beEnums()), StandardCopyOption.class, String.class)); } - @Test - @UseDataProvider("beEnums_rules") - public void beEnums(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("beEnums_rules") + void beEnums(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1397,16 +1344,15 @@ public void beEnums(ArchRule rule, Class satisfied, Class violated) { .doesNotMatch(String.format(".*%s.* enum.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] notBeEnums_rules() { - return $$( + static Stream notBeEnums_rules() { + return Stream.of( $(classes().should().notBeEnums(), String.class, StandardCopyOption.class), $(classes().should(ArchConditions.notBeEnums()), String.class, StandardCopyOption.class)); } - @Test - @UseDataProvider("notBeEnums_rules") - public void notBeEnums(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("notBeEnums_rules") + void notBeEnums(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1417,20 +1363,19 @@ public void notBeEnums(ArchRule rule, Class satisfied, Class violated) { .doesNotMatch(String.format(".*%s.* enum.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] beTopLevelClasses_rules() { + static Stream beTopLevelClasses_rules() { Class topLevelClass = List.class; Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; - return $$( + return Stream.of( $(classes().should().beTopLevelClasses(), topLevelClass, staticNestedClass), $(classes().should(ArchConditions.beTopLevelClasses()), topLevelClass, staticNestedClass) ); } - @Test - @UseDataProvider("beTopLevelClasses_rules") - public void beTopLevelClasses(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("beTopLevelClasses_rules") + void beTopLevelClasses(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1439,20 +1384,19 @@ public void beTopLevelClasses(ArchRule rule, Class satisfied, Class violat .doesNotMatch(String.format(".*%s.* top level class.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] notBeTopLevelClasses_rules() { + static Stream notBeTopLevelClasses_rules() { Class topLevelClass = List.class; Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; - return $$( + return Stream.of( $(classes().should().notBeTopLevelClasses(), staticNestedClass, topLevelClass), $(classes().should(ArchConditions.notBeTopLevelClasses()), staticNestedClass, topLevelClass) ); } - @Test - @UseDataProvider("notBeTopLevelClasses_rules") - public void notBeTopLevelClasses(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("notBeTopLevelClasses_rules") + void notBeTopLevelClasses(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1461,20 +1405,19 @@ public void notBeTopLevelClasses(ArchRule rule, Class satisfied, Class vio .doesNotMatch(String.format(".*%s.* top level class.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] beNestedClasses_rules() { + static Stream beNestedClasses_rules() { Class topLevelClass = List.class; Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; - return $$( + return Stream.of( $(classes().should().beNestedClasses(), staticNestedClass, topLevelClass), $(classes().should(ArchConditions.beNestedClasses()), staticNestedClass, topLevelClass) ); } - @Test - @UseDataProvider("beNestedClasses_rules") - public void beNestedClasses(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("beNestedClasses_rules") + void beNestedClasses(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1483,20 +1426,19 @@ public void beNestedClasses(ArchRule rule, Class satisfied, Class violated .doesNotMatch(String.format(".*%s.* nested class.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] notBeNestedClasses_rules() { + static Stream notBeNestedClasses_rules() { Class topLevelClass = List.class; Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; - return $$( + return Stream.of( $(classes().should().notBeNestedClasses(), topLevelClass, staticNestedClass), $(classes().should(ArchConditions.notBeNestedClasses()), topLevelClass, staticNestedClass) ); } - @Test - @UseDataProvider("notBeNestedClasses_rules") - public void notBeNestedClasses(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("notBeNestedClasses_rules") + void notBeNestedClasses(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1505,20 +1447,19 @@ public void notBeNestedClasses(ArchRule rule, Class satisfied, Class viola .doesNotMatch(String.format(".*%s.* nested class.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] beMemberClasses_rules() { + static Stream beMemberClasses_rules() { Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; Class anonymousClass = NestedClassWithSomeMoreClasses.getAnonymousClass(); - return $$( + return Stream.of( $(classes().should().beMemberClasses(), staticNestedClass, anonymousClass), $(classes().should(ArchConditions.beMemberClasses()), staticNestedClass, anonymousClass) ); } - @Test - @UseDataProvider("beMemberClasses_rules") - public void beMemberClasses(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("beMemberClasses_rules") + void beMemberClasses(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1527,20 +1468,19 @@ public void beMemberClasses(ArchRule rule, Class satisfied, Class violated .doesNotMatch(String.format(".*%s.* member class.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] notBeMemberClasses_rules() { + static Stream notBeMemberClasses_rules() { Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; Class anonymousClass = NestedClassWithSomeMoreClasses.getAnonymousClass(); - return $$( + return Stream.of( $(classes().should().notBeMemberClasses(), anonymousClass, staticNestedClass), $(classes().should(ArchConditions.notBeMemberClasses()), anonymousClass, staticNestedClass) ); } - @Test - @UseDataProvider("notBeMemberClasses_rules") - public void notBeMemberClasses(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("notBeMemberClasses_rules") + void notBeMemberClasses(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1549,20 +1489,19 @@ public void notBeMemberClasses(ArchRule rule, Class satisfied, Class viola .doesNotMatch(String.format(".*%s.* member class.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] beInnerClasses_rules() { + static Stream beInnerClasses_rules() { Class innerMemberClass = NestedClassWithSomeMoreClasses.InnerMemberClass.class; Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; - return $$( + return Stream.of( $(classes().should().beInnerClasses(), innerMemberClass, staticNestedClass), $(classes().should(ArchConditions.beInnerClasses()), innerMemberClass, staticNestedClass) ); } - @Test - @UseDataProvider("beInnerClasses_rules") - public void beInnerClasses(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("beInnerClasses_rules") + void beInnerClasses(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1571,20 +1510,19 @@ public void beInnerClasses(ArchRule rule, Class satisfied, Class violated) .doesNotMatch(String.format(".*%s.* inner class.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] notBeInnerClasses_rules() { + static Stream notBeInnerClasses_rules() { Class nonStaticNestedClass = NestedClassWithSomeMoreClasses.InnerMemberClass.class; Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; - return $$( + return Stream.of( $(classes().should().notBeInnerClasses(), staticNestedClass, nonStaticNestedClass), $(classes().should(ArchConditions.notBeInnerClasses()), staticNestedClass, nonStaticNestedClass) ); } - @Test - @UseDataProvider("notBeInnerClasses_rules") - public void notBeInnerClasses(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("notBeInnerClasses_rules") + void notBeInnerClasses(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1593,20 +1531,19 @@ public void notBeInnerClasses(ArchRule rule, Class satisfied, Class violat .doesNotMatch(String.format(".*%s.* inner class.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] beAnonymousClasses_rules() { + static Stream beAnonymousClasses_rules() { Class anonymousClass = NestedClassWithSomeMoreClasses.getAnonymousClass(); Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; - return $$( + return Stream.of( $(classes().should().beAnonymousClasses(), anonymousClass, staticNestedClass), $(classes().should(ArchConditions.beAnonymousClasses()), anonymousClass, staticNestedClass) ); } - @Test - @UseDataProvider("beAnonymousClasses_rules") - public void beAnonymousClasses(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("beAnonymousClasses_rules") + void beAnonymousClasses(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1615,20 +1552,19 @@ public void beAnonymousClasses(ArchRule rule, Class satisfied, Class viola .doesNotMatch(String.format(".*%s.* anonymous class.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] notBeAnonymousClasses_rules() { + static Stream notBeAnonymousClasses_rules() { Class anonymousClass = NestedClassWithSomeMoreClasses.getAnonymousClass(); Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; - return $$( + return Stream.of( $(classes().should().notBeAnonymousClasses(), staticNestedClass, anonymousClass), $(classes().should(ArchConditions.notBeAnonymousClasses()), staticNestedClass, anonymousClass) ); } - @Test - @UseDataProvider("notBeAnonymousClasses_rules") - public void notBeAnonymousClasses(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("notBeAnonymousClasses_rules") + void notBeAnonymousClasses(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1637,20 +1573,19 @@ public void notBeAnonymousClasses(ArchRule rule, Class satisfied, Class vi .doesNotMatch(String.format(".*%s.* anonymous class.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] beLocalClasses_rules() { + static Stream beLocalClasses_rules() { Class localClass = NestedClassWithSomeMoreClasses.getLocalClass(); Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; - return $$( + return Stream.of( $(classes().should().beLocalClasses(), localClass, staticNestedClass), $(classes().should(ArchConditions.beLocalClasses()), localClass, staticNestedClass) ); } - @Test - @UseDataProvider("beLocalClasses_rules") - public void beLocalClasses(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("beLocalClasses_rules") + void beLocalClasses(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1659,20 +1594,19 @@ public void beLocalClasses(ArchRule rule, Class satisfied, Class violated) .doesNotMatch(String.format(".*%s.* local class.*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] notBeLocalClasses_rules() { + static Stream notBeLocalClasses_rules() { Class localClass = NestedClassWithSomeMoreClasses.getLocalClass(); Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; - return $$( + return Stream.of( $(classes().should().notBeLocalClasses(), staticNestedClass, localClass), $(classes().should(ArchConditions.notBeLocalClasses()), staticNestedClass, localClass) ); } - @Test - @UseDataProvider("notBeLocalClasses_rules") - public void notBeLocalClasses(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("notBeLocalClasses_rules") + void notBeLocalClasses(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1695,18 +1629,17 @@ public void containNumberOfElements_fails_on_mismatching_predicate() { .hasOnlyViolations("there is/are 2 element(s) in [java.lang.Integer, java.lang.String]"); } - @DataProvider - public static Object[][] beClass_rules() { - return $$( + static Stream beClass_rules() { + return Stream.of( $(classes().should().be(String.class), String.class, Collection.class), $(classes().should().be(String.class.getName()), String.class, Collection.class), $(classes().should(ArchConditions.be(String.class)), String.class, Collection.class), $(classes().should(ArchConditions.be(String.class.getName())), String.class, Collection.class)); } - @Test - @UseDataProvider("beClass_rules") - public void beClass(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("beClass_rules") + void beClass(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1718,18 +1651,17 @@ public void beClass(ArchRule rule, Class satisfied, Class violated) { .doesNotMatch(String.format(".*<%s>.* is .*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] notBeClass_rules() { - return $$( + static Stream notBeClass_rules() { + return Stream.of( $(classes().should().notBe(Collection.class), String.class, Collection.class), $(classes().should().notBe(Collection.class.getName()), String.class, Collection.class), $(classes().should(ArchConditions.notBe(Collection.class)), String.class, Collection.class), $(classes().should(ArchConditions.notBe(Collection.class.getName())), String.class, Collection.class)); } - @Test - @UseDataProvider("notBeClass_rules") - public void notBeClass(ArchRule rule, Class satisfied, Class violated) { + @ParameterizedTest + @MethodSource("notBeClass_rules") + void notBeClass(ArchRule rule, Class satisfied, Class violated) { EvaluationResult result = rule.evaluate(importClasses(satisfied, violated)); assertThat(singleLineFailureReportOf(result)) @@ -1741,9 +1673,8 @@ public void notBeClass(ArchRule rule, Class satisfied, Class violated) { .doesNotMatch(String.format(".*%s.* is .*", quote(satisfied.getName()))); } - @DataProvider - public static Object[][] onlyAccessRules_rules() { - return $$( + static Stream onlyAccessRules_rules() { + return Stream.of( $(classes().should().onlyCallMethodsThat(are(not(declaredIn(ClassWithMethod.class)))), ClassCallingMethod.class), $(classes().should(ArchConditions.onlyCallMethodsThat(are(not(declaredIn(ClassWithMethod.class))))), ClassCallingMethod.class), $(classes().should().onlyCallConstructorsThat(are(not(declaredIn(ClassWithConstructor.class)))), ClassCallingConstructor.class), @@ -1756,9 +1687,9 @@ public static Object[][] onlyAccessRules_rules() { $(classes().should(ArchConditions.onlyAccessMembersThat(are(not(declaredIn(ClassWithField.class))))), ClassAccessingField.class)); } - @Test - @UseDataProvider("onlyAccessRules_rules") - public void onlyCall_should_report_success_if_targets_are_non_resolvable(ArchRule rule, Class classCallingUnresolvableTarget) { + @ParameterizedTest + @MethodSource("onlyAccessRules_rules") + void onlyCall_should_report_success_if_targets_are_non_resolvable(ArchRule rule, Class classCallingUnresolvableTarget) { ArchConfiguration.get().setResolveMissingDependenciesFromClassPath(false); assertThatRule(rule).checking(importClasses(classCallingUnresolvableTarget)).hasNoViolation(); @@ -1777,14 +1708,14 @@ public void call() { @Test public void should_allow_empty_should_if_configured() { - configurationRule.setFailOnEmptyShould(false); + archConfiguration.setFailOnEmptyShould(false); ruleWithEmptyShould().check(new ClassFileImporter().importClasses(getClass())); } @Test public void should_allow_empty_should_if_overridden_by_rule() { - configurationRule.setFailOnEmptyShould(true); + archConfiguration.setFailOnEmptyShould(true); ruleWithEmptyShould().allowEmptyShould(true).check(new ClassFileImporter().importClasses(getClass())); } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenCodeUnitsTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenCodeUnitsTest.java index 9475d8a12f..4945d56e72 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenCodeUnitsTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenCodeUnitsTest.java @@ -3,6 +3,7 @@ import java.util.Collection; import java.util.List; import java.util.Set; +import java.util.stream.Stream; import com.google.common.base.Joiner; import com.google.common.collect.ImmutableList; @@ -17,13 +18,12 @@ import com.tngtech.archunit.lang.EvaluationResult; import com.tngtech.archunit.lang.SimpleConditionEvent; import com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.DescribedRuleStart; -import com.tngtech.archunit.testutil.ArchConfigurationRule; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; +import com.tngtech.archunit.testutil.ArchConfigurationExtension; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.Sets.difference; import static com.google.common.collect.Sets.union; @@ -39,16 +39,14 @@ import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.beAnnotatedWith; import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.described; import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.everythingViolationPrintMemberName; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.Collections.emptySet; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class GivenCodeUnitsTest { - @Rule - public final ArchConfigurationRule archConfigurationRule = new ArchConfigurationRule(); + @RegisterExtension + ArchConfigurationExtension archConfiguration = new ArchConfigurationExtension(); @Test public void complex_code_unit_syntax() { @@ -123,9 +121,8 @@ public void check(JavaConstructor constructor, ConditionEvents events) { assertThat(Joiner.on(" ").join(result.getFailureReport().getDetails())).contains("expected violation"); } - @DataProvider - public static Object[][] restricted_parameter_types_rule_starts() { - return $$( + static Stream restricted_parameter_types_rule_starts() { + return Stream.of( $(described(codeUnits().that().haveRawParameterTypes(String.class)), ImmutableSet.of(METHOD_ONE_ARG, CONSTRUCTOR_ONE_ARG)), $(described(codeUnits().that().haveRawParameterTypes(String.class.getName())), @@ -170,18 +167,17 @@ public static Object[][] restricted_parameter_types_rule_starts() { ); } - @Test - @UseDataProvider("restricted_parameter_types_rule_starts") - public void parameter_types_predicates(DescribedRuleStart ruleStart, Collection expectedMembers) { + @ParameterizedTest + @MethodSource("restricted_parameter_types_rule_starts") + void parameter_types_predicates(DescribedRuleStart ruleStart, Collection expectedMembers) { EvaluationResult result = ruleStart.should(everythingViolationPrintMemberName()) .evaluate(importClasses(ClassWithVariousMembers.class)); assertThat(result.getFailureReport().getDetails()).hasSameElementsAs(expectedMembers); } - @DataProvider - public static Object[][] restricted_return_type_rule_starts() { - return $$( + static Stream restricted_return_type_rule_starts() { + return Stream.of( $(described(codeUnits().that().haveRawReturnType(String.class)), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), $(described(codeUnits().that().haveRawReturnType(String.class.getName())), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), $(described(codeUnits().that().haveRawReturnType(equivalentTo(String.class))), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), @@ -211,10 +207,10 @@ public static Object[][] restricted_return_type_rule_starts() { ); } - @Test - @UseDataProvider("restricted_return_type_rule_starts") - public void return_type_predicates(DescribedRuleStart ruleStart, Collection expectedMembers) { - archConfigurationRule.setFailOnEmptyShould(false); + @ParameterizedTest + @MethodSource("restricted_return_type_rule_starts") + void return_type_predicates(DescribedRuleStart ruleStart, Collection expectedMembers) { + archConfiguration.setFailOnEmptyShould(false); EvaluationResult result = ruleStart.should(everythingViolationPrintMemberName()) .evaluate(importClasses(ClassWithVariousMembers.class)); @@ -222,9 +218,8 @@ public void return_type_predicates(DescribedRuleStart ruleStart, Collection restricted_throwable_type_rule_starts() { + return Stream.of( $(described(codeUnits().that().declareThrowableOfType(FirstException.class)), ImmutableSet.of(METHOD_ONE_ARG, METHOD_THREE_ARGS, CONSTRUCTOR_ONE_ARG, CONSTRUCTOR_THREE_ARGS)), $(described(codeUnits().that().declareThrowableOfType(FirstException.class.getName())), @@ -269,9 +264,9 @@ public static Object[][] restricted_throwable_type_rule_starts() { ); } - @Test - @UseDataProvider("restricted_throwable_type_rule_starts") - public void throwable_type_predicates(DescribedRuleStart ruleStart, Collection expectedMembers) { + @ParameterizedTest + @MethodSource("restricted_throwable_type_rule_starts") + void throwable_type_predicates(DescribedRuleStart ruleStart, Collection expectedMembers) { EvaluationResult result = ruleStart.should(everythingViolationPrintMemberName()) .evaluate(importClasses(ClassWithVariousMembers.class)); diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMembersTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMembersTest.java index 0740081fc5..9d9dc5d4cb 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMembersTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMembersTest.java @@ -6,6 +6,7 @@ import java.util.Map; import java.util.Set; import java.util.function.Function; +import java.util.stream.Stream; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; @@ -19,13 +20,12 @@ import com.tngtech.archunit.lang.ConditionEvents; import com.tngtech.archunit.lang.EvaluationResult; import com.tngtech.archunit.lang.SimpleConditionEvent; -import com.tngtech.archunit.testutil.ArchConfigurationRule; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; +import com.tngtech.archunit.testutil.ArchConfigurationExtension; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.base.DescribedPredicate.not; import static com.tngtech.archunit.core.domain.JavaClass.Predicates.equivalentTo; @@ -49,23 +49,20 @@ import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noFields; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noMembers; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noMethods; +import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.TestUtils.union; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; import static java.util.Collections.emptySet; import static java.util.Collections.singleton; import static java.util.regex.Pattern.quote; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class GivenMembersTest { - @Rule - public final ArchConfigurationRule archConfigurationRule = new ArchConfigurationRule(); + @RegisterExtension + ArchConfigurationExtension archConfiguration = new ArchConfigurationExtension(); - @DataProvider - public static Object[][] member_syntax_testcases() { - return $$( + static Stream member_syntax_testcases() { + return Stream.of( $(members(), "members", never(beAnnotatedWith(C.class)), ImmutableList.of( String.format("Member '%s' is annotated with @C", FIELD_ANNOTATED_WITH_B_AND_C), @@ -115,9 +112,9 @@ public static Object[][] member_syntax_testcases() { ); } - @Test - @UseDataProvider("member_syntax_testcases") - public void test_members(GivenMembers members, String ruleStart, ArchCondition condition, + @ParameterizedTest + @MethodSource("member_syntax_testcases") + void test_members(GivenMembers members, String ruleStart, ArchCondition condition, List expectedViolationDetails) { ArchRule rule = members .that(have(modifier(PRIVATE))) @@ -151,204 +148,202 @@ public void complex_members_syntax() { String.format("Member '%s' is not annotated with @B", METHOD_C)); } - @DataProvider - public static Object[][] restricted_property_rule_starts() { + static List restricted_property_rule_starts() { String classNameDot = ClassWithVariousMembers.class.getName() + "."; - ImmutableList.Builder data = ImmutableList.builder().add( - $(described(members().that().haveName(FIELD_A)), ImmutableSet.of(FIELD_A)), - $(described(codeUnits().that().haveName(FIELD_A)), ImmutableSet.of()), - $(described(fields().that().haveName(FIELD_A)), ImmutableSet.of(FIELD_A)), - $(described(codeUnits().that().haveName("methodA")), ImmutableSet.of(METHOD_A)), - $(described(methods().that().haveName("methodA")), ImmutableSet.of(METHOD_A)), - $(described(codeUnits().that().haveName(CONSTRUCTOR_NAME)), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(constructors().that().haveName(CONSTRUCTOR_NAME)), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(members().that().doNotHaveName(FIELD_A)), union( - allFieldsExcept(FIELD_A), - ALL_CODE_UNIT_DESCRIPTIONS)), - $(described(codeUnits().that().doNotHaveName(FIELD_A)), ALL_CODE_UNIT_DESCRIPTIONS), - $(described(fields().that().doNotHaveName(FIELD_A)), allFieldsExcept(FIELD_A)), - $(described(codeUnits().that().doNotHaveName("methodA")), union( - allMethodsExcept(METHOD_A), - ALL_CONSTRUCTOR_DESCRIPTIONS)), - $(described(methods().that().doNotHaveName("methodA")), allMethodsExcept(METHOD_A)), - $(described(codeUnits().that().doNotHaveName(CONSTRUCTOR_NAME)), ALL_METHOD_DESCRIPTIONS), - $(described(constructors().that().doNotHaveName(CONSTRUCTOR_NAME)), ImmutableSet.of()), - - $(described(members().that().haveNameMatching("f.*A")), ImmutableSet.of(FIELD_A)), - $(described(codeUnits().that().haveNameMatching("f.*A")), ImmutableSet.of()), - $(described(fields().that().haveNameMatching("f.*A")), ImmutableSet.of(FIELD_A)), - $(described(codeUnits().that().haveNameMatching("m.*A")), ImmutableSet.of(METHOD_A)), - $(described(methods().that().haveNameMatching("m.*A")), ImmutableSet.of(METHOD_A)), - $(described(codeUnits().that().haveNameMatching(".*init.*")), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(constructors().that().haveNameMatching(".*init.*")), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(members().that().haveNameNotMatching("f.*A")), union( - allFieldsExcept(FIELD_A), - ALL_CODE_UNIT_DESCRIPTIONS)), - $(described(codeUnits().that().haveNameNotMatching("f.*A")), ALL_CODE_UNIT_DESCRIPTIONS), - $(described(fields().that().haveNameNotMatching("f.*A")), allFieldsExcept(FIELD_A)), - $(described(codeUnits().that().haveNameNotMatching("m.*A")), union( - allMethodsExcept(METHOD_A), - ALL_CONSTRUCTOR_DESCRIPTIONS)), - $(described(methods().that().haveNameNotMatching("m.*A")), allMethodsExcept(METHOD_A)), - $(described(codeUnits().that().haveNameNotMatching(".*init.*")), ALL_METHOD_DESCRIPTIONS), - $(described(constructors().that().haveNameNotMatching(".*init.*")), emptySet()), - - $(described(members().that().haveFullName(classNameDot + FIELD_A)), ImmutableSet.of(FIELD_A)), - $(described(codeUnits().that().haveFullName(classNameDot + METHOD_A)), ImmutableSet.of(METHOD_A)), - $(described(methods().that().haveFullName(classNameDot + METHOD_A)), ImmutableSet.of(METHOD_A)), - $(described(constructors().that().haveFullName(classNameDot + CONSTRUCTOR_ONE_ARG)), ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), - $(described(fields().that().haveFullName(classNameDot + FIELD_A)), ImmutableSet.of(FIELD_A)), - $(described(members().that().doNotHaveFullName(classNameDot + FIELD_A)), union(allFieldsExcept(FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS)), - $(described(codeUnits().that().doNotHaveFullName(classNameDot + METHOD_A)), allCodeUnitsExcept(METHOD_A)), - $(described(methods().that().doNotHaveFullName(classNameDot + METHOD_A)), allMethodsExcept(METHOD_A)), - $(described(constructors().that().doNotHaveFullName(classNameDot + CONSTRUCTOR_ONE_ARG)), allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), - $(described(fields().that().doNotHaveFullName(classNameDot + FIELD_A)), allFieldsExcept(FIELD_A)), - - $(described(members().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(FIELD_A, METHOD_A)), - $(described(codeUnits().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(METHOD_A)), - $(described(methods().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(METHOD_A)), - $(described(constructors().that().haveFullNameMatching(quote(classNameDot) + ".*init.*String\\)")), - ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), - $(described(fields().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(FIELD_A)), - $(described(members().that().haveFullNameNotMatching(quote(classNameDot) + "f.*A.*")), union( - allFieldsExcept(FIELD_A), - ALL_CODE_UNIT_DESCRIPTIONS)), - $(described(codeUnits().that().haveFullNameNotMatching(quote(classNameDot) + "f.*A.*")), ALL_CODE_UNIT_DESCRIPTIONS), - $(described(methods().that().haveFullNameNotMatching(quote(classNameDot) + ".*A.*")), allMethodsExcept(METHOD_A)), - $(described(constructors().that().haveFullNameNotMatching(quote(classNameDot) + ".*init.*String\\)")), - allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), - $(described(fields().that().haveFullNameNotMatching(quote(classNameDot) + ".*A.*")), allFieldsExcept(FIELD_A)), - - $(described(members().that().haveNameStartingWith("fie")), ALL_FIELD_DESCRIPTIONS), - $(described(codeUnits().that().haveNameStartingWith("me")), ALL_METHOD_DESCRIPTIONS), - $(described(methods().that().haveNameStartingWith("m")), ALL_METHOD_DESCRIPTIONS), - $(described(constructors().that().haveNameStartingWith("<")), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(fields().that().haveNameStartingWith("f")), ALL_FIELD_DESCRIPTIONS), - $(described(members().that().haveNameNotStartingWith("fie")), ALL_CODE_UNIT_DESCRIPTIONS), - $(described(codeUnits().that().haveNameNotStartingWith("me")), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(methods().that().haveNameNotStartingWith("m")), emptySet()), - $(described(constructors().that().haveNameNotStartingWith("<")), emptySet()), - $(described(fields().that().haveNameNotStartingWith("f")), emptySet()), - - $(described(members().that().haveNameContaining("et")), ALL_METHOD_DESCRIPTIONS), - $(described(codeUnits().that().haveNameContaining("et")), ALL_METHOD_DESCRIPTIONS), - $(described(methods().that().haveNameContaining("dA")), ImmutableSet.of(METHOD_A)), - $(described(constructors().that().haveNameContaining("init")), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(fields().that().haveNameContaining("dA")), ImmutableSet.of(FIELD_A)), - $(described(members().that().haveNameNotContaining("et")), union(ALL_FIELD_DESCRIPTIONS, ALL_CONSTRUCTOR_DESCRIPTIONS)), - $(described(codeUnits().that().haveNameNotContaining("et")), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(methods().that().haveNameNotContaining("dA")), allMethodsExcept(METHOD_A)), - $(described(constructors().that().haveNameNotContaining("init")), emptySet()), - $(described(fields().that().haveNameNotContaining("dA")), allFieldsExcept(FIELD_A)), - - $(described(members().that().haveNameEndingWith("D")), ImmutableSet.of(FIELD_D, METHOD_D)), - $(described(codeUnits().that().haveNameEndingWith("A")), ImmutableSet.of(METHOD_A)), - $(described(methods().that().haveNameEndingWith("C")), ImmutableSet.of(METHOD_C)), - $(described(constructors().that().haveNameEndingWith("it>")), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(fields().that().haveNameEndingWith("B")), ImmutableSet.of(FIELD_B)), - $(described(members().that().haveNameNotEndingWith("D")), allMembersExcept(FIELD_D, METHOD_D)), - $(described(codeUnits().that().haveNameNotEndingWith("A")), allCodeUnitsExcept(METHOD_A)), - $(described(methods().that().haveNameNotEndingWith("C")), allMethodsExcept(METHOD_C)), - $(described(constructors().that().haveNameNotEndingWith("it>")), emptySet()), - $(described(fields().that().haveNameNotEndingWith("B")), allFieldsExcept(FIELD_B)), - - $(described(members().that().arePublic()), ImmutableSet.of( - FIELD_PUBLIC, METHOD_PUBLIC, CONSTRUCTOR_PUBLIC)), - $(described(fields().that().arePublic()), ImmutableSet.of(FIELD_C)), - $(described(codeUnits().that().arePublic()), ImmutableSet.of(METHOD_PUBLIC, CONSTRUCTOR_PUBLIC)), - $(described(methods().that().arePublic()), ImmutableSet.of(METHOD_PUBLIC)), - $(described(constructors().that().arePublic()), ImmutableSet.of(CONSTRUCTOR_PUBLIC)), - $(described(members().that().areNotPublic()), - allMembersExcept(FIELD_PUBLIC, METHOD_PUBLIC, CONSTRUCTOR_PUBLIC)), - $(described(fields().that().areNotPublic()), allFieldsExcept(FIELD_C)), - $(described(codeUnits().that().areNotPublic()), - allCodeUnitsExcept(METHOD_PUBLIC, CONSTRUCTOR_PUBLIC)), - $(described(methods().that().areNotPublic()), allMethodsExcept(METHOD_PUBLIC)), - $(described(constructors().that().areNotPublic()), allConstructorsExcept(CONSTRUCTOR_PUBLIC)), - - $(described(members().that().areProtected()), ImmutableSet.of( - FIELD_PROTECTED, METHOD_PROTECTED, CONSTRUCTOR_PROTECTED)), - $(described(fields().that().areProtected()), ImmutableSet.of(FIELD_PROTECTED)), - $(described(codeUnits().that().areProtected()), ImmutableSet.of( - METHOD_PROTECTED, CONSTRUCTOR_PROTECTED)), - $(described(methods().that().areProtected()), ImmutableSet.of(METHOD_PROTECTED)), - $(described(constructors().that().areProtected()), ImmutableSet.of(CONSTRUCTOR_PROTECTED)), - $(described(members().that().areNotProtected()), - allMembersExcept(FIELD_PROTECTED, METHOD_PROTECTED, CONSTRUCTOR_PROTECTED)), - $(described(fields().that().areNotProtected()), allFieldsExcept(FIELD_PROTECTED)), - $(described(codeUnits().that().areNotProtected()), - allCodeUnitsExcept(METHOD_PROTECTED, CONSTRUCTOR_PROTECTED)), - $(described(methods().that().areNotProtected()), allMethodsExcept(METHOD_PROTECTED)), - $(described(constructors().that().areNotProtected()), allConstructorsExcept(CONSTRUCTOR_PROTECTED)), - - $(described(members().that().arePackagePrivate()), ImmutableSet.of( - FIELD_PACKAGE_PRIVATE, METHOD_PACKAGE_PRIVATE, CONSTRUCTOR_PACKAGE_PRIVATE)), - $(described(fields().that().arePackagePrivate()), ImmutableSet.of(FIELD_PACKAGE_PRIVATE)), - $(described(codeUnits().that().arePackagePrivate()), ImmutableSet.of( - METHOD_PACKAGE_PRIVATE, CONSTRUCTOR_PACKAGE_PRIVATE)), - $(described(methods().that().arePackagePrivate()), ImmutableSet.of(METHOD_PACKAGE_PRIVATE)), - $(described(constructors().that().arePackagePrivate()), ImmutableSet.of(CONSTRUCTOR_PACKAGE_PRIVATE)), - $(described(members().that().areNotPackagePrivate()), - allMembersExcept(FIELD_PACKAGE_PRIVATE, METHOD_PACKAGE_PRIVATE, CONSTRUCTOR_PACKAGE_PRIVATE)), - $(described(fields().that().areNotPackagePrivate()), allFieldsExcept(FIELD_PACKAGE_PRIVATE)), - $(described(codeUnits().that().areNotPackagePrivate()), - allCodeUnitsExcept(METHOD_PACKAGE_PRIVATE, CONSTRUCTOR_PACKAGE_PRIVATE)), - $(described(methods().that().areNotPackagePrivate()), allMethodsExcept(METHOD_PACKAGE_PRIVATE)), - $(described(constructors().that().areNotPackagePrivate()), allConstructorsExcept(CONSTRUCTOR_PACKAGE_PRIVATE)), - - $(described(members().that().arePrivate()), ImmutableSet.of( - FIELD_PRIVATE, METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(fields().that().arePrivate()), ImmutableSet.of(FIELD_PRIVATE)), - $(described(codeUnits().that().arePrivate()), ImmutableSet.of( - METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(methods().that().arePrivate()), ImmutableSet.of(METHOD_PRIVATE)), - $(described(constructors().that().arePrivate()), ImmutableSet.of(CONSTRUCTOR_PRIVATE)), - $(described(members().that().areNotPrivate()), - allMembersExcept(FIELD_PRIVATE, METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(fields().that().areNotPrivate()), allFieldsExcept(FIELD_PRIVATE)), - $(described(codeUnits().that().areNotPrivate()), - allCodeUnitsExcept(METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(methods().that().areNotPrivate()), allMethodsExcept(METHOD_PRIVATE)), - $(described(constructors().that().areNotPrivate()), allConstructorsExcept(CONSTRUCTOR_PRIVATE)), - - $(described(members().that().haveModifier(PRIVATE)), ImmutableSet.of( - FIELD_PRIVATE, METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(fields().that().haveModifier(PRIVATE)), ImmutableSet.of(FIELD_PRIVATE)), - $(described(codeUnits().that().haveModifier(PRIVATE)), ImmutableSet.of( - METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(methods().that().haveModifier(PRIVATE)), ImmutableSet.of(METHOD_PRIVATE)), - $(described(constructors().that().haveModifier(PRIVATE)), ImmutableSet.of(CONSTRUCTOR_PRIVATE)), - $(described(members().that().doNotHaveModifier(PRIVATE)), - allMembersExcept(FIELD_PRIVATE, METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(fields().that().doNotHaveModifier(PRIVATE)), allFieldsExcept(FIELD_PRIVATE)), - $(described(codeUnits().that().doNotHaveModifier(PRIVATE)), - allCodeUnitsExcept(METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(methods().that().doNotHaveModifier(PRIVATE)), allMethodsExcept(METHOD_PRIVATE)), - $(described(constructors().that().doNotHaveModifier(PRIVATE)), allConstructorsExcept(CONSTRUCTOR_PRIVATE))); - - data.add(annotatedWithDataPoints( - membersThat -> membersThat.areAnnotatedWith(A.class), - membersThat -> membersThat.areNotAnnotatedWith(A.class))); - data.add(annotatedWithDataPoints( - membersThat -> membersThat.areAnnotatedWith(A.class.getName()), - membersThat -> membersThat.areNotAnnotatedWith(A.class.getName()))); - data.add(annotatedWithDataPoints( - membersThat -> membersThat.areAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(A.class))), - membersThat -> membersThat.areNotAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(A.class))))); - - data.add(annotatedWithDataPoints( - membersThat -> membersThat.areMetaAnnotatedWith(MetaAnnotation.class), - membersThat -> membersThat.areNotMetaAnnotatedWith(MetaAnnotation.class))); - data.add(annotatedWithDataPoints( - membersThat -> membersThat.areMetaAnnotatedWith(MetaAnnotation.class.getName()), - membersThat -> membersThat.areNotMetaAnnotatedWith(MetaAnnotation.class.getName()))); - data.add(annotatedWithDataPoints( - membersThat -> membersThat.areMetaAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(MetaAnnotation.class))), - membersThat -> membersThat.areNotMetaAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(MetaAnnotation.class))))); - return data.build().toArray(new Object[0][]); + return ImmutableList.builder().add( + $(described(members().that().haveName(FIELD_A)), ImmutableSet.of(FIELD_A)), + $(described(codeUnits().that().haveName(FIELD_A)), ImmutableSet.of()), + $(described(fields().that().haveName(FIELD_A)), ImmutableSet.of(FIELD_A)), + $(described(codeUnits().that().haveName("methodA")), ImmutableSet.of(METHOD_A)), + $(described(methods().that().haveName("methodA")), ImmutableSet.of(METHOD_A)), + $(described(codeUnits().that().haveName(CONSTRUCTOR_NAME)), ALL_CONSTRUCTOR_DESCRIPTIONS), + $(described(constructors().that().haveName(CONSTRUCTOR_NAME)), ALL_CONSTRUCTOR_DESCRIPTIONS), + $(described(members().that().doNotHaveName(FIELD_A)), union( + allFieldsExcept(FIELD_A), + ALL_CODE_UNIT_DESCRIPTIONS)), + $(described(codeUnits().that().doNotHaveName(FIELD_A)), ALL_CODE_UNIT_DESCRIPTIONS), + $(described(fields().that().doNotHaveName(FIELD_A)), allFieldsExcept(FIELD_A)), + $(described(codeUnits().that().doNotHaveName("methodA")), union( + allMethodsExcept(METHOD_A), + ALL_CONSTRUCTOR_DESCRIPTIONS)), + $(described(methods().that().doNotHaveName("methodA")), allMethodsExcept(METHOD_A)), + $(described(codeUnits().that().doNotHaveName(CONSTRUCTOR_NAME)), ALL_METHOD_DESCRIPTIONS), + $(described(constructors().that().doNotHaveName(CONSTRUCTOR_NAME)), ImmutableSet.of()), + + $(described(members().that().haveNameMatching("f.*A")), ImmutableSet.of(FIELD_A)), + $(described(codeUnits().that().haveNameMatching("f.*A")), ImmutableSet.of()), + $(described(fields().that().haveNameMatching("f.*A")), ImmutableSet.of(FIELD_A)), + $(described(codeUnits().that().haveNameMatching("m.*A")), ImmutableSet.of(METHOD_A)), + $(described(methods().that().haveNameMatching("m.*A")), ImmutableSet.of(METHOD_A)), + $(described(codeUnits().that().haveNameMatching(".*init.*")), ALL_CONSTRUCTOR_DESCRIPTIONS), + $(described(constructors().that().haveNameMatching(".*init.*")), ALL_CONSTRUCTOR_DESCRIPTIONS), + $(described(members().that().haveNameNotMatching("f.*A")), union( + allFieldsExcept(FIELD_A), + ALL_CODE_UNIT_DESCRIPTIONS)), + $(described(codeUnits().that().haveNameNotMatching("f.*A")), ALL_CODE_UNIT_DESCRIPTIONS), + $(described(fields().that().haveNameNotMatching("f.*A")), allFieldsExcept(FIELD_A)), + $(described(codeUnits().that().haveNameNotMatching("m.*A")), union( + allMethodsExcept(METHOD_A), + ALL_CONSTRUCTOR_DESCRIPTIONS)), + $(described(methods().that().haveNameNotMatching("m.*A")), allMethodsExcept(METHOD_A)), + $(described(codeUnits().that().haveNameNotMatching(".*init.*")), ALL_METHOD_DESCRIPTIONS), + $(described(constructors().that().haveNameNotMatching(".*init.*")), emptySet()), + + $(described(members().that().haveFullName(classNameDot + FIELD_A)), ImmutableSet.of(FIELD_A)), + $(described(codeUnits().that().haveFullName(classNameDot + METHOD_A)), ImmutableSet.of(METHOD_A)), + $(described(methods().that().haveFullName(classNameDot + METHOD_A)), ImmutableSet.of(METHOD_A)), + $(described(constructors().that().haveFullName(classNameDot + CONSTRUCTOR_ONE_ARG)), ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), + $(described(fields().that().haveFullName(classNameDot + FIELD_A)), ImmutableSet.of(FIELD_A)), + $(described(members().that().doNotHaveFullName(classNameDot + FIELD_A)), union(allFieldsExcept(FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS)), + $(described(codeUnits().that().doNotHaveFullName(classNameDot + METHOD_A)), allCodeUnitsExcept(METHOD_A)), + $(described(methods().that().doNotHaveFullName(classNameDot + METHOD_A)), allMethodsExcept(METHOD_A)), + $(described(constructors().that().doNotHaveFullName(classNameDot + CONSTRUCTOR_ONE_ARG)), allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), + $(described(fields().that().doNotHaveFullName(classNameDot + FIELD_A)), allFieldsExcept(FIELD_A)), + + $(described(members().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(FIELD_A, METHOD_A)), + $(described(codeUnits().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(METHOD_A)), + $(described(methods().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(METHOD_A)), + $(described(constructors().that().haveFullNameMatching(quote(classNameDot) + ".*init.*String\\)")), + ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), + $(described(fields().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(FIELD_A)), + $(described(members().that().haveFullNameNotMatching(quote(classNameDot) + "f.*A.*")), union( + allFieldsExcept(FIELD_A), + ALL_CODE_UNIT_DESCRIPTIONS)), + $(described(codeUnits().that().haveFullNameNotMatching(quote(classNameDot) + "f.*A.*")), ALL_CODE_UNIT_DESCRIPTIONS), + $(described(methods().that().haveFullNameNotMatching(quote(classNameDot) + ".*A.*")), allMethodsExcept(METHOD_A)), + $(described(constructors().that().haveFullNameNotMatching(quote(classNameDot) + ".*init.*String\\)")), + allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), + $(described(fields().that().haveFullNameNotMatching(quote(classNameDot) + ".*A.*")), allFieldsExcept(FIELD_A)), + + $(described(members().that().haveNameStartingWith("fie")), ALL_FIELD_DESCRIPTIONS), + $(described(codeUnits().that().haveNameStartingWith("me")), ALL_METHOD_DESCRIPTIONS), + $(described(methods().that().haveNameStartingWith("m")), ALL_METHOD_DESCRIPTIONS), + $(described(constructors().that().haveNameStartingWith("<")), ALL_CONSTRUCTOR_DESCRIPTIONS), + $(described(fields().that().haveNameStartingWith("f")), ALL_FIELD_DESCRIPTIONS), + $(described(members().that().haveNameNotStartingWith("fie")), ALL_CODE_UNIT_DESCRIPTIONS), + $(described(codeUnits().that().haveNameNotStartingWith("me")), ALL_CONSTRUCTOR_DESCRIPTIONS), + $(described(methods().that().haveNameNotStartingWith("m")), emptySet()), + $(described(constructors().that().haveNameNotStartingWith("<")), emptySet()), + $(described(fields().that().haveNameNotStartingWith("f")), emptySet()), + + $(described(members().that().haveNameContaining("et")), ALL_METHOD_DESCRIPTIONS), + $(described(codeUnits().that().haveNameContaining("et")), ALL_METHOD_DESCRIPTIONS), + $(described(methods().that().haveNameContaining("dA")), ImmutableSet.of(METHOD_A)), + $(described(constructors().that().haveNameContaining("init")), ALL_CONSTRUCTOR_DESCRIPTIONS), + $(described(fields().that().haveNameContaining("dA")), ImmutableSet.of(FIELD_A)), + $(described(members().that().haveNameNotContaining("et")), union(ALL_FIELD_DESCRIPTIONS, ALL_CONSTRUCTOR_DESCRIPTIONS)), + $(described(codeUnits().that().haveNameNotContaining("et")), ALL_CONSTRUCTOR_DESCRIPTIONS), + $(described(methods().that().haveNameNotContaining("dA")), allMethodsExcept(METHOD_A)), + $(described(constructors().that().haveNameNotContaining("init")), emptySet()), + $(described(fields().that().haveNameNotContaining("dA")), allFieldsExcept(FIELD_A)), + + $(described(members().that().haveNameEndingWith("D")), ImmutableSet.of(FIELD_D, METHOD_D)), + $(described(codeUnits().that().haveNameEndingWith("A")), ImmutableSet.of(METHOD_A)), + $(described(methods().that().haveNameEndingWith("C")), ImmutableSet.of(METHOD_C)), + $(described(constructors().that().haveNameEndingWith("it>")), ALL_CONSTRUCTOR_DESCRIPTIONS), + $(described(fields().that().haveNameEndingWith("B")), ImmutableSet.of(FIELD_B)), + $(described(members().that().haveNameNotEndingWith("D")), allMembersExcept(FIELD_D, METHOD_D)), + $(described(codeUnits().that().haveNameNotEndingWith("A")), allCodeUnitsExcept(METHOD_A)), + $(described(methods().that().haveNameNotEndingWith("C")), allMethodsExcept(METHOD_C)), + $(described(constructors().that().haveNameNotEndingWith("it>")), emptySet()), + $(described(fields().that().haveNameNotEndingWith("B")), allFieldsExcept(FIELD_B)), + + $(described(members().that().arePublic()), ImmutableSet.of( + FIELD_PUBLIC, METHOD_PUBLIC, CONSTRUCTOR_PUBLIC)), + $(described(fields().that().arePublic()), ImmutableSet.of(FIELD_C)), + $(described(codeUnits().that().arePublic()), ImmutableSet.of(METHOD_PUBLIC, CONSTRUCTOR_PUBLIC)), + $(described(methods().that().arePublic()), ImmutableSet.of(METHOD_PUBLIC)), + $(described(constructors().that().arePublic()), ImmutableSet.of(CONSTRUCTOR_PUBLIC)), + $(described(members().that().areNotPublic()), + allMembersExcept(FIELD_PUBLIC, METHOD_PUBLIC, CONSTRUCTOR_PUBLIC)), + $(described(fields().that().areNotPublic()), allFieldsExcept(FIELD_C)), + $(described(codeUnits().that().areNotPublic()), + allCodeUnitsExcept(METHOD_PUBLIC, CONSTRUCTOR_PUBLIC)), + $(described(methods().that().areNotPublic()), allMethodsExcept(METHOD_PUBLIC)), + $(described(constructors().that().areNotPublic()), allConstructorsExcept(CONSTRUCTOR_PUBLIC)), + + $(described(members().that().areProtected()), ImmutableSet.of( + FIELD_PROTECTED, METHOD_PROTECTED, CONSTRUCTOR_PROTECTED)), + $(described(fields().that().areProtected()), ImmutableSet.of(FIELD_PROTECTED)), + $(described(codeUnits().that().areProtected()), ImmutableSet.of( + METHOD_PROTECTED, CONSTRUCTOR_PROTECTED)), + $(described(methods().that().areProtected()), ImmutableSet.of(METHOD_PROTECTED)), + $(described(constructors().that().areProtected()), ImmutableSet.of(CONSTRUCTOR_PROTECTED)), + $(described(members().that().areNotProtected()), + allMembersExcept(FIELD_PROTECTED, METHOD_PROTECTED, CONSTRUCTOR_PROTECTED)), + $(described(fields().that().areNotProtected()), allFieldsExcept(FIELD_PROTECTED)), + $(described(codeUnits().that().areNotProtected()), + allCodeUnitsExcept(METHOD_PROTECTED, CONSTRUCTOR_PROTECTED)), + $(described(methods().that().areNotProtected()), allMethodsExcept(METHOD_PROTECTED)), + $(described(constructors().that().areNotProtected()), allConstructorsExcept(CONSTRUCTOR_PROTECTED)), + + $(described(members().that().arePackagePrivate()), ImmutableSet.of( + FIELD_PACKAGE_PRIVATE, METHOD_PACKAGE_PRIVATE, CONSTRUCTOR_PACKAGE_PRIVATE)), + $(described(fields().that().arePackagePrivate()), ImmutableSet.of(FIELD_PACKAGE_PRIVATE)), + $(described(codeUnits().that().arePackagePrivate()), ImmutableSet.of( + METHOD_PACKAGE_PRIVATE, CONSTRUCTOR_PACKAGE_PRIVATE)), + $(described(methods().that().arePackagePrivate()), ImmutableSet.of(METHOD_PACKAGE_PRIVATE)), + $(described(constructors().that().arePackagePrivate()), ImmutableSet.of(CONSTRUCTOR_PACKAGE_PRIVATE)), + $(described(members().that().areNotPackagePrivate()), + allMembersExcept(FIELD_PACKAGE_PRIVATE, METHOD_PACKAGE_PRIVATE, CONSTRUCTOR_PACKAGE_PRIVATE)), + $(described(fields().that().areNotPackagePrivate()), allFieldsExcept(FIELD_PACKAGE_PRIVATE)), + $(described(codeUnits().that().areNotPackagePrivate()), + allCodeUnitsExcept(METHOD_PACKAGE_PRIVATE, CONSTRUCTOR_PACKAGE_PRIVATE)), + $(described(methods().that().areNotPackagePrivate()), allMethodsExcept(METHOD_PACKAGE_PRIVATE)), + $(described(constructors().that().areNotPackagePrivate()), allConstructorsExcept(CONSTRUCTOR_PACKAGE_PRIVATE)), + + $(described(members().that().arePrivate()), ImmutableSet.of( + FIELD_PRIVATE, METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), + $(described(fields().that().arePrivate()), ImmutableSet.of(FIELD_PRIVATE)), + $(described(codeUnits().that().arePrivate()), ImmutableSet.of( + METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), + $(described(methods().that().arePrivate()), ImmutableSet.of(METHOD_PRIVATE)), + $(described(constructors().that().arePrivate()), ImmutableSet.of(CONSTRUCTOR_PRIVATE)), + $(described(members().that().areNotPrivate()), + allMembersExcept(FIELD_PRIVATE, METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), + $(described(fields().that().areNotPrivate()), allFieldsExcept(FIELD_PRIVATE)), + $(described(codeUnits().that().areNotPrivate()), + allCodeUnitsExcept(METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), + $(described(methods().that().areNotPrivate()), allMethodsExcept(METHOD_PRIVATE)), + $(described(constructors().that().areNotPrivate()), allConstructorsExcept(CONSTRUCTOR_PRIVATE)), + + $(described(members().that().haveModifier(PRIVATE)), ImmutableSet.of( + FIELD_PRIVATE, METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), + $(described(fields().that().haveModifier(PRIVATE)), ImmutableSet.of(FIELD_PRIVATE)), + $(described(codeUnits().that().haveModifier(PRIVATE)), ImmutableSet.of( + METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), + $(described(methods().that().haveModifier(PRIVATE)), ImmutableSet.of(METHOD_PRIVATE)), + $(described(constructors().that().haveModifier(PRIVATE)), ImmutableSet.of(CONSTRUCTOR_PRIVATE)), + $(described(members().that().doNotHaveModifier(PRIVATE)), + allMembersExcept(FIELD_PRIVATE, METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), + $(described(fields().that().doNotHaveModifier(PRIVATE)), allFieldsExcept(FIELD_PRIVATE)), + $(described(codeUnits().that().doNotHaveModifier(PRIVATE)), + allCodeUnitsExcept(METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), + $(described(methods().that().doNotHaveModifier(PRIVATE)), allMethodsExcept(METHOD_PRIVATE)), + $(described(constructors().that().doNotHaveModifier(PRIVATE)), allConstructorsExcept(CONSTRUCTOR_PRIVATE)) + ) + .addAll(annotatedWithDataPoints( + membersThat -> membersThat.areAnnotatedWith(A.class), + membersThat -> membersThat.areNotAnnotatedWith(A.class))) + .addAll(annotatedWithDataPoints( + membersThat -> membersThat.areAnnotatedWith(A.class.getName()), + membersThat -> membersThat.areNotAnnotatedWith(A.class.getName()))) + .addAll(annotatedWithDataPoints( + membersThat -> membersThat.areAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(A.class))), + membersThat -> membersThat.areNotAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(A.class))))) + .addAll(annotatedWithDataPoints( + membersThat -> membersThat.areMetaAnnotatedWith(MetaAnnotation.class), + membersThat -> membersThat.areNotMetaAnnotatedWith(MetaAnnotation.class))) + .addAll(annotatedWithDataPoints( + membersThat -> membersThat.areMetaAnnotatedWith(MetaAnnotation.class.getName()), + membersThat -> membersThat.areNotMetaAnnotatedWith(MetaAnnotation.class.getName()))) + .addAll(annotatedWithDataPoints( + membersThat -> membersThat.areMetaAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(MetaAnnotation.class))), + membersThat -> membersThat.areNotMetaAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(MetaAnnotation.class))))) + .build(); } - private static Object[][] annotatedWithDataPoints( + private static List annotatedWithDataPoints( Function>, GivenMembersConjunction> makeAnnotatedWithMatchingA, Function>, GivenMembersConjunction> makeNotAnnotatedWithMatchingA) { @@ -356,7 +351,7 @@ private static Object[][] annotatedWithDataPoints( Function> areAnnotatedWithA = (Function) makeAnnotatedWithMatchingA; @SuppressWarnings({"unchecked", "rawtypes"}) Function> areNotAnnotatedWithA = (Function) makeNotAnnotatedWithMatchingA; - return $$( + return ImmutableList.of( $(described(areAnnotatedWithA.apply(members().that())), ImmutableSet.of( FIELD_ANNOTATED_WITH_A, METHOD_ANNOTATED_WITH_A, CONSTRUCTOR_ANNOTATED_WITH_A)), $(described(areAnnotatedWithA.apply(fields().that())), ImmutableSet.of(FIELD_ANNOTATED_WITH_A)), @@ -373,10 +368,10 @@ private static Object[][] annotatedWithDataPoints( $(described(areNotAnnotatedWithA.apply(constructors().that())), allConstructorsExcept(CONSTRUCTOR_ANNOTATED_WITH_A))); } - @Test - @UseDataProvider("restricted_property_rule_starts") - public void property_predicates(DescribedRuleStart conjunction, Set expectedMessages) { - archConfigurationRule.setFailOnEmptyShould(false); + @ParameterizedTest + @MethodSource("restricted_property_rule_starts") + void property_predicates(DescribedRuleStart conjunction, Set expectedMessages) { + archConfiguration.setFailOnEmptyShould(false); EvaluationResult result = conjunction.should(everythingViolationPrintMemberName()) .evaluate(importClasses(ClassWithVariousMembers.class, A.class, B.class, C.class, MetaAnnotation.class)); @@ -384,28 +379,24 @@ public void property_predicates(DescribedRuleStart conjunction, Set expe assertThat(result.getFailureReport().getDetails()).hasSameElementsAs(expectedMessages); } - @DataProvider - public static Object[][] restricted_declaration_rule_starts() { - return ImmutableList.builder().add( - declaredInDataPoints( + static List restricted_declaration_rule_starts() { + return ImmutableList.builder() + .addAll(declaredInDataPoints( membersThat -> membersThat.areDeclaredIn(ClassWithVariousMembers.class), - membersThat -> membersThat.areNotDeclaredIn(ClassWithVariousMembers.class) - )).add( - declaredInDataPoints( + membersThat -> membersThat.areNotDeclaredIn(ClassWithVariousMembers.class))) + .addAll(declaredInDataPoints( membersThat -> membersThat.areDeclaredIn(ClassWithVariousMembers.class.getName()), - membersThat -> membersThat.areNotDeclaredIn(ClassWithVariousMembers.class.getName()) - )).add( - declaredInDataPoints( + membersThat -> membersThat.areNotDeclaredIn(ClassWithVariousMembers.class.getName()))) + .addAll(declaredInDataPoints( membersThat -> membersThat.areDeclaredInClassesThat(equivalentTo(ClassWithVariousMembers.class)), - membersThat -> membersThat.areDeclaredInClassesThat(not(equivalentTo(ClassWithVariousMembers.class))) - )).add( - declaredInDataPoints( + membersThat -> membersThat.areDeclaredInClassesThat(not(equivalentTo(ClassWithVariousMembers.class))))) + .addAll(declaredInDataPoints( membersThat -> membersThat.areDeclaredInClassesThat().areAssignableTo(ClassWithVariousMembers.class), - membersThat -> membersThat.areDeclaredInClassesThat().areNotAssignableTo(ClassWithVariousMembers.class) - )).build().toArray(new Object[0][]); + membersThat -> membersThat.areDeclaredInClassesThat().areNotAssignableTo(ClassWithVariousMembers.class))) + .build(); } - private static Object[][] declaredInDataPoints( + private static List declaredInDataPoints( Function>, GivenMembersConjunction> makeDeclaredInClassWithVariousMembers, Function>, GivenMembersConjunction> makeNotDeclaredInClassWithVariousMembers) { @@ -413,7 +404,7 @@ private static Object[][] declaredInDataPoints( Function> areDeclaredInClass = (Function) makeDeclaredInClassWithVariousMembers; @SuppressWarnings({"unchecked", "rawtypes"}) Function> areNotDeclaredInClass = (Function) makeNotDeclaredInClassWithVariousMembers; - return $$( + return ImmutableList.of( $(described(areDeclaredInClass.apply(members().that())), ALL_MEMBER_DESCRIPTIONS), $(described(areDeclaredInClass.apply(fields().that())), ALL_FIELD_DESCRIPTIONS), $(described(areDeclaredInClass.apply(codeUnits().that())), ALL_CODE_UNIT_DESCRIPTIONS), @@ -426,9 +417,9 @@ private static Object[][] declaredInDataPoints( $(described(areNotDeclaredInClass.apply(constructors().that())), ALL_OTHER_CONSTRUCTOR_DESCRIPTIONS)); } - @Test - @UseDataProvider("restricted_declaration_rule_starts") - public void declaration_predicates(DescribedRuleStart conjunction, Set expectedMessages) { + @ParameterizedTest + @MethodSource("restricted_declaration_rule_starts") + void declaration_predicates(DescribedRuleStart conjunction, Set expectedMessages) { EvaluationResult result = conjunction.should(everythingViolationPrintMemberName()) .evaluate(importClasses(ClassWithVariousMembers.class, OtherClassWithMembers.class)); diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MembersShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MembersShouldTest.java index 4f1103a4a3..df4cd0411f 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MembersShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MembersShouldTest.java @@ -4,6 +4,7 @@ import java.util.Set; import java.util.function.Function; import java.util.regex.Pattern; +import java.util.stream.Stream; import com.google.common.base.Joiner; import com.google.common.collect.ImmutableList; @@ -19,14 +20,13 @@ import com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.MetaAnnotation; import com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.OtherClassWithMembers; import com.tngtech.archunit.lang.syntax.elements.testclasses.SimpleFieldAndMethod; -import com.tngtech.archunit.testutil.ArchConfigurationRule; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; +import com.tngtech.archunit.testutil.ArchConfigurationExtension; import org.assertj.core.api.ThrowableAssert; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.base.DescribedPredicate.alwaysFalse; @@ -87,8 +87,7 @@ import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.areNoFieldsWithType; import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.assertViolation; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; +import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.Collections.emptySet; import static java.util.regex.Pattern.quote; import static java.util.stream.Collectors.toList; @@ -96,11 +95,10 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -@RunWith(DataProviderRunner.class) public class MembersShouldTest { - @Rule - public final ArchConfigurationRule configurationRule = new ArchConfigurationRule(); + @RegisterExtension + ArchConfigurationExtension archConfiguration = new ArchConfigurationExtension(); @Test public void complex_members_syntax() { @@ -120,197 +118,195 @@ public void complex_members_syntax() { .matches(String.format(".*Field .*%s.* is not annotated with @B.*", FIELD_D)); } - @DataProvider - public static Object[][] restricted_property_rule_ends() { + static List restricted_property_rule_ends() { String classNameDot = ClassWithVariousMembers.class.getName() + "."; - ImmutableList.Builder data = ImmutableList.builder().add( - $(members().should().haveName(FIELD_A), allMembersExcept(FIELD_A)), - $(codeUnits().should().haveName(FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS), - $(fields().should().haveName(FIELD_A), allFieldsExcept(FIELD_A)), - $(codeUnits().should().haveName("methodA"), allCodeUnitsExcept(METHOD_A)), - $(methods().should().haveName("methodA"), allMethodsExcept(METHOD_A)), - $(codeUnits().should().haveName(CONSTRUCTOR_NAME), ALL_METHOD_DESCRIPTIONS), - $(constructors().should().haveName(CONSTRUCTOR_NAME), emptySet()), - $(members().should().notHaveName(FIELD_A), ImmutableSet.of(FIELD_A)), - $(codeUnits().should().notHaveName("methodA"), ImmutableSet.of(METHOD_A)), - $(fields().should().notHaveName(FIELD_A), ImmutableSet.of(FIELD_A)), - $(codeUnits().should().notHaveName("methodA"), ImmutableSet.of(METHOD_A)), - $(methods().should().notHaveName("methodA"), ImmutableSet.of(METHOD_A)), - $(codeUnits().should().notHaveName(CONSTRUCTOR_NAME), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(constructors().should().notHaveName(CONSTRUCTOR_NAME), ALL_CONSTRUCTOR_DESCRIPTIONS), - - $(members().should().haveNameMatching("f.*A"), allMembersExcept(FIELD_A)), - $(codeUnits().should().haveNameMatching("f.*A"), ALL_CODE_UNIT_DESCRIPTIONS), - $(fields().should().haveNameMatching("f.*A"), allFieldsExcept(FIELD_A)), - $(codeUnits().should().haveNameMatching("m.*A"), allCodeUnitsExcept(METHOD_A)), - $(methods().should().haveNameMatching("m.*A"), allMethodsExcept(METHOD_A)), - $(codeUnits().should().haveNameMatching(".*init.*"), ALL_METHOD_DESCRIPTIONS), - $(constructors().should().haveNameMatching(".*init.*"), emptySet()), - $(members().should().haveNameNotMatching("f.*A"), ImmutableSet.of(FIELD_A)), - $(codeUnits().should().haveNameNotMatching("f.*A"), emptySet()), - $(fields().should().haveNameNotMatching("f.*A"), ImmutableSet.of(FIELD_A)), - $(codeUnits().should().haveNameNotMatching("m.*A"), ImmutableSet.of(METHOD_A)), - $(methods().should().haveNameNotMatching("m.*A"), ImmutableSet.of(METHOD_A)), - $(codeUnits().should().haveNameNotMatching(".*init.*"), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(constructors().should().haveNameNotMatching(".*init.*"), ALL_CONSTRUCTOR_DESCRIPTIONS), - - $(members().should().haveFullName(classNameDot + FIELD_A), allMembersExcept(FIELD_A)), - $(fields().should().haveFullName(classNameDot + FIELD_A), allFieldsExcept(FIELD_A)), - $(codeUnits().should().haveFullName(classNameDot + FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS), - $(methods().should().haveFullName(classNameDot + METHOD_A), allMethodsExcept(METHOD_A)), - $(codeUnits().should().haveFullName(classNameDot + METHOD_A), allCodeUnitsExcept(METHOD_A)), - $(members().should().notHaveFullName(classNameDot + FIELD_A), ImmutableSet.of(FIELD_A)), - $(fields().should().notHaveFullName(classNameDot + FIELD_A), ImmutableSet.of(FIELD_A)), - $(codeUnits().should().notHaveFullName(classNameDot + FIELD_A), emptySet()), - $(methods().should().notHaveFullName(classNameDot + METHOD_A), ImmutableSet.of(METHOD_A)), - $(codeUnits().should().notHaveFullName(classNameDot + METHOD_A), ImmutableSet.of(METHOD_A)), - - $(members().should().haveFullNameMatching(quote(classNameDot) + ".*A\\(?\\)?"), allMembersExcept(FIELD_A, METHOD_A)), - $(codeUnits().should().haveFullNameMatching(quote(classNameDot) + ".*A"), ALL_CODE_UNIT_DESCRIPTIONS), - $(fields().should().haveFullNameMatching(quote(classNameDot) + ".*A"), allFieldsExcept(FIELD_A)), - $(codeUnits().should().haveFullNameMatching(quote(classNameDot) + ".*A" + quote("()")), allCodeUnitsExcept(METHOD_A)), - $(methods().should().haveFullNameMatching(quote(classNameDot) + ".*A" + quote("()")), allMethodsExcept(METHOD_A)), - $(codeUnits().should().haveFullNameMatching(quote(classNameDot) + "..*init.*"), ALL_METHOD_DESCRIPTIONS), - $(constructors().should().haveFullNameMatching(quote(classNameDot) + ".*init.*String\\)"), - allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), - $(members().should().haveFullNameNotMatching(quote(classNameDot) + ".*A\\(?\\)?"), ImmutableSet.of(FIELD_A, METHOD_A)), - $(codeUnits().should().haveFullNameNotMatching(quote(classNameDot) + ".*A"), emptySet()), - $(fields().should().haveFullNameNotMatching(quote(classNameDot) + ".*A"), ImmutableSet.of(FIELD_A)), - $(codeUnits().should().haveFullNameNotMatching(quote(classNameDot) + ".*A" + quote("()")), ImmutableSet.of(METHOD_A)), - $(methods().should().haveFullNameNotMatching(quote(classNameDot) + ".*A" + quote("()")), ImmutableSet.of(METHOD_A)), - $(codeUnits().should().haveFullNameNotMatching(quote(classNameDot) + ".*init.*"), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(constructors().should().haveFullNameNotMatching(quote(classNameDot) + ".*init.*String\\)"), ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), - - $(members().should().haveNameStartingWith("fi"), ALL_CODE_UNIT_DESCRIPTIONS), - $(fields().should().haveNameStartingWith("m"), ALL_FIELD_DESCRIPTIONS), - $(codeUnits().should().haveNameStartingWith(""), ALL_METHOD_DESCRIPTIONS), - $(methods().should().haveNameEndingWith("dC"), allMethodsExcept(METHOD_C)), - $(constructors().should().haveNameEndingWith(""), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(methods().should().haveNameNotEndingWith("dC"), ImmutableSet.of(METHOD_C)), - $(constructors().should().haveNameNotEndingWith(" membersShould.beAnnotatedWith(A.class), - membersShould -> membersShould.notBeAnnotatedWith(A.class))); - data.add(annotatedWithDataPoints( - membersShould -> membersShould.beAnnotatedWith(A.class.getName()), - membersShould -> membersShould.notBeAnnotatedWith(A.class.getName()))); - data.add(annotatedWithDataPoints( - membersShould -> membersShould.beAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(A.class))), - membersShould -> membersShould.notBeAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(A.class))))); - - data.add(annotatedWithDataPoints( - membersShould -> membersShould.beMetaAnnotatedWith(MetaAnnotation.class), - membersShould -> membersShould.notBeMetaAnnotatedWith(MetaAnnotation.class))); - data.add(annotatedWithDataPoints( - membersShould -> membersShould.beMetaAnnotatedWith(MetaAnnotation.class.getName()), - membersShould -> membersShould.notBeMetaAnnotatedWith(MetaAnnotation.class.getName()))); - data.add(annotatedWithDataPoints( - membersShould -> membersShould.beMetaAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(MetaAnnotation.class))), - membersShould -> membersShould.notBeMetaAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(MetaAnnotation.class))))); - return data.build().toArray(new Object[0][]); + return ImmutableList.builder().add( + $(members().should().haveName(FIELD_A), allMembersExcept(FIELD_A)), + $(codeUnits().should().haveName(FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS), + $(fields().should().haveName(FIELD_A), allFieldsExcept(FIELD_A)), + $(codeUnits().should().haveName("methodA"), allCodeUnitsExcept(METHOD_A)), + $(methods().should().haveName("methodA"), allMethodsExcept(METHOD_A)), + $(codeUnits().should().haveName(CONSTRUCTOR_NAME), ALL_METHOD_DESCRIPTIONS), + $(constructors().should().haveName(CONSTRUCTOR_NAME), emptySet()), + $(members().should().notHaveName(FIELD_A), ImmutableSet.of(FIELD_A)), + $(codeUnits().should().notHaveName("methodA"), ImmutableSet.of(METHOD_A)), + $(fields().should().notHaveName(FIELD_A), ImmutableSet.of(FIELD_A)), + $(codeUnits().should().notHaveName("methodA"), ImmutableSet.of(METHOD_A)), + $(methods().should().notHaveName("methodA"), ImmutableSet.of(METHOD_A)), + $(codeUnits().should().notHaveName(CONSTRUCTOR_NAME), ALL_CONSTRUCTOR_DESCRIPTIONS), + $(constructors().should().notHaveName(CONSTRUCTOR_NAME), ALL_CONSTRUCTOR_DESCRIPTIONS), + + $(members().should().haveNameMatching("f.*A"), allMembersExcept(FIELD_A)), + $(codeUnits().should().haveNameMatching("f.*A"), ALL_CODE_UNIT_DESCRIPTIONS), + $(fields().should().haveNameMatching("f.*A"), allFieldsExcept(FIELD_A)), + $(codeUnits().should().haveNameMatching("m.*A"), allCodeUnitsExcept(METHOD_A)), + $(methods().should().haveNameMatching("m.*A"), allMethodsExcept(METHOD_A)), + $(codeUnits().should().haveNameMatching(".*init.*"), ALL_METHOD_DESCRIPTIONS), + $(constructors().should().haveNameMatching(".*init.*"), emptySet()), + $(members().should().haveNameNotMatching("f.*A"), ImmutableSet.of(FIELD_A)), + $(codeUnits().should().haveNameNotMatching("f.*A"), emptySet()), + $(fields().should().haveNameNotMatching("f.*A"), ImmutableSet.of(FIELD_A)), + $(codeUnits().should().haveNameNotMatching("m.*A"), ImmutableSet.of(METHOD_A)), + $(methods().should().haveNameNotMatching("m.*A"), ImmutableSet.of(METHOD_A)), + $(codeUnits().should().haveNameNotMatching(".*init.*"), ALL_CONSTRUCTOR_DESCRIPTIONS), + $(constructors().should().haveNameNotMatching(".*init.*"), ALL_CONSTRUCTOR_DESCRIPTIONS), + + $(members().should().haveFullName(classNameDot + FIELD_A), allMembersExcept(FIELD_A)), + $(fields().should().haveFullName(classNameDot + FIELD_A), allFieldsExcept(FIELD_A)), + $(codeUnits().should().haveFullName(classNameDot + FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS), + $(methods().should().haveFullName(classNameDot + METHOD_A), allMethodsExcept(METHOD_A)), + $(codeUnits().should().haveFullName(classNameDot + METHOD_A), allCodeUnitsExcept(METHOD_A)), + $(members().should().notHaveFullName(classNameDot + FIELD_A), ImmutableSet.of(FIELD_A)), + $(fields().should().notHaveFullName(classNameDot + FIELD_A), ImmutableSet.of(FIELD_A)), + $(codeUnits().should().notHaveFullName(classNameDot + FIELD_A), emptySet()), + $(methods().should().notHaveFullName(classNameDot + METHOD_A), ImmutableSet.of(METHOD_A)), + $(codeUnits().should().notHaveFullName(classNameDot + METHOD_A), ImmutableSet.of(METHOD_A)), + + $(members().should().haveFullNameMatching(quote(classNameDot) + ".*A\\(?\\)?"), allMembersExcept(FIELD_A, METHOD_A)), + $(codeUnits().should().haveFullNameMatching(quote(classNameDot) + ".*A"), ALL_CODE_UNIT_DESCRIPTIONS), + $(fields().should().haveFullNameMatching(quote(classNameDot) + ".*A"), allFieldsExcept(FIELD_A)), + $(codeUnits().should().haveFullNameMatching(quote(classNameDot) + ".*A" + quote("()")), allCodeUnitsExcept(METHOD_A)), + $(methods().should().haveFullNameMatching(quote(classNameDot) + ".*A" + quote("()")), allMethodsExcept(METHOD_A)), + $(codeUnits().should().haveFullNameMatching(quote(classNameDot) + "..*init.*"), ALL_METHOD_DESCRIPTIONS), + $(constructors().should().haveFullNameMatching(quote(classNameDot) + ".*init.*String\\)"), + allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), + $(members().should().haveFullNameNotMatching(quote(classNameDot) + ".*A\\(?\\)?"), ImmutableSet.of(FIELD_A, METHOD_A)), + $(codeUnits().should().haveFullNameNotMatching(quote(classNameDot) + ".*A"), emptySet()), + $(fields().should().haveFullNameNotMatching(quote(classNameDot) + ".*A"), ImmutableSet.of(FIELD_A)), + $(codeUnits().should().haveFullNameNotMatching(quote(classNameDot) + ".*A" + quote("()")), ImmutableSet.of(METHOD_A)), + $(methods().should().haveFullNameNotMatching(quote(classNameDot) + ".*A" + quote("()")), ImmutableSet.of(METHOD_A)), + $(codeUnits().should().haveFullNameNotMatching(quote(classNameDot) + ".*init.*"), ALL_CONSTRUCTOR_DESCRIPTIONS), + $(constructors().should().haveFullNameNotMatching(quote(classNameDot) + ".*init.*String\\)"), ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), + + $(members().should().haveNameStartingWith("fi"), ALL_CODE_UNIT_DESCRIPTIONS), + $(fields().should().haveNameStartingWith("m"), ALL_FIELD_DESCRIPTIONS), + $(codeUnits().should().haveNameStartingWith(""), ALL_METHOD_DESCRIPTIONS), + $(methods().should().haveNameEndingWith("dC"), allMethodsExcept(METHOD_C)), + $(constructors().should().haveNameEndingWith(""), ALL_CONSTRUCTOR_DESCRIPTIONS), + $(methods().should().haveNameNotEndingWith("dC"), ImmutableSet.of(METHOD_C)), + $(constructors().should().haveNameNotEndingWith(" membersShould.beAnnotatedWith(A.class), + membersShould -> membersShould.notBeAnnotatedWith(A.class))) + .addAll(annotatedWithDataPoints( + membersShould -> membersShould.beAnnotatedWith(A.class.getName()), + membersShould -> membersShould.notBeAnnotatedWith(A.class.getName()))) + .addAll(annotatedWithDataPoints( + membersShould -> membersShould.beAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(A.class))), + membersShould -> membersShould.notBeAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(A.class))))) + .addAll(annotatedWithDataPoints( + membersShould -> membersShould.beMetaAnnotatedWith(MetaAnnotation.class), + membersShould -> membersShould.notBeMetaAnnotatedWith(MetaAnnotation.class))) + .addAll(annotatedWithDataPoints( + membersShould -> membersShould.beMetaAnnotatedWith(MetaAnnotation.class.getName()), + membersShould -> membersShould.notBeMetaAnnotatedWith(MetaAnnotation.class.getName()))) + .addAll(annotatedWithDataPoints( + membersShould -> membersShould.beMetaAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(MetaAnnotation.class))), + membersShould -> membersShould.notBeMetaAnnotatedWith(GET_RAW_TYPE.is(equivalentTo(MetaAnnotation.class))))) + .build(); } - private static Object[][] annotatedWithDataPoints( + private static List annotatedWithDataPoints( Function>, MembersShouldConjunction> makeAnnotatedWithMatchingA, Function>, MembersShouldConjunction> makeNotAnnotatedWithMatchingA) { @@ -318,7 +314,7 @@ private static Object[][] annotatedWithDataPoints( Function, MembersShouldConjunction> areAnnotatedWithA = (Function) makeAnnotatedWithMatchingA; @SuppressWarnings({"unchecked", "rawtypes"}) Function, MembersShouldConjunction> areNotAnnotatedWithA = (Function) makeNotAnnotatedWithMatchingA; - return $$( + return ImmutableList.of( $(areAnnotatedWithA.apply(members().should()), allMembersExcept( FIELD_ANNOTATED_WITH_A, METHOD_ANNOTATED_WITH_A, CONSTRUCTOR_ANNOTATED_WITH_A)), $(areAnnotatedWithA.apply(fields().should()), allFieldsExcept(FIELD_ANNOTATED_WITH_A)), @@ -335,9 +331,9 @@ private static Object[][] annotatedWithDataPoints( $(areNotAnnotatedWithA.apply(constructors().should()), ImmutableSet.of(CONSTRUCTOR_ANNOTATED_WITH_A))); } - @Test - @UseDataProvider("restricted_property_rule_ends") - public void property_predicates(MembersShouldConjunction conjunction, Set expectedMembers) { + @ParameterizedTest + @MethodSource("restricted_property_rule_ends") + void property_predicates(MembersShouldConjunction conjunction, Set expectedMembers) { EvaluationResult result = conjunction .evaluate(importClasses(ClassWithVariousMembers.class, A.class, B.class, C.class, MetaAnnotation.class)); @@ -345,28 +341,24 @@ public void property_predicates(MembersShouldConjunction conjunction, Setbuilder().add( - declaredInDataPoints( + static List restricted_declaration_rule_ends() { + return ImmutableList.builder() + .addAll(declaredInDataPoints( membersShould -> membersShould.beDeclaredIn(ClassWithVariousMembers.class), - membersShould -> membersShould.notBeDeclaredIn(ClassWithVariousMembers.class) - )).add( - declaredInDataPoints( + membersShould -> membersShould.notBeDeclaredIn(ClassWithVariousMembers.class))) + .addAll(declaredInDataPoints( membersShould -> membersShould.beDeclaredIn(ClassWithVariousMembers.class.getName()), - membersShould -> membersShould.notBeDeclaredIn(ClassWithVariousMembers.class.getName()) - )).add( - declaredInDataPoints( + membersShould -> membersShould.notBeDeclaredIn(ClassWithVariousMembers.class.getName()))) + .addAll(declaredInDataPoints( membersShould -> membersShould.beDeclaredInClassesThat(equivalentTo(ClassWithVariousMembers.class)), - membersShould -> membersShould.beDeclaredInClassesThat(not(equivalentTo(ClassWithVariousMembers.class))) - )).add( - declaredInDataPoints( + membersShould -> membersShould.beDeclaredInClassesThat(not(equivalentTo(ClassWithVariousMembers.class))))) + .addAll(declaredInDataPoints( membersShould -> membersShould.beDeclaredInClassesThat().areAssignableTo(ClassWithVariousMembers.class), - membersShould -> membersShould.beDeclaredInClassesThat().areNotAssignableTo(ClassWithVariousMembers.class) - )).build().toArray(new Object[0][]); + membersShould -> membersShould.beDeclaredInClassesThat().areNotAssignableTo(ClassWithVariousMembers.class))) + .build(); } - private static Object[][] declaredInDataPoints( + private static List declaredInDataPoints( Function>, MembersShouldConjunction> makeDeclaredInClassWithVariousMembers, Function>, MembersShouldConjunction> makeNotDeclaredInClassWithVariousMembers) { @@ -374,7 +366,7 @@ private static Object[][] declaredInDataPoints( Function, MembersShouldConjunction> areDeclaredInClass = (Function) makeDeclaredInClassWithVariousMembers; @SuppressWarnings({"unchecked", "rawtypes"}) Function, MembersShouldConjunction> areNotDeclaredInClass = (Function) makeNotDeclaredInClassWithVariousMembers; - return $$( + return ImmutableList.of( $(areDeclaredInClass.apply(members().should()), ALL_OTHER_MEMBER_DESCRIPTIONS), $(areDeclaredInClass.apply(fields().should()), ALL_OTHER_FIELD_DESCRIPTIONS), $(areDeclaredInClass.apply(codeUnits().should()), ALL_OTHER_CODE_UNIT_DESCRIPTIONS), @@ -387,9 +379,9 @@ private static Object[][] declaredInDataPoints( $(areNotDeclaredInClass.apply(constructors().should()), ALL_CONSTRUCTOR_DESCRIPTIONS)); } - @Test - @UseDataProvider("restricted_declaration_rule_ends") - public void declaration_predicates(MembersShouldConjunction conjunction, Set expectedMessages) { + @ParameterizedTest + @MethodSource("restricted_declaration_rule_ends") + void declaration_predicates(MembersShouldConjunction conjunction, Set expectedMessages) { EvaluationResult result = conjunction .evaluate(importClasses(ClassWithVariousMembers.class, OtherClassWithMembers.class)); @@ -397,9 +389,8 @@ public void declaration_predicates(MembersShouldConjunction conjunction, Set< assertThat(actualMembers).hasSameElementsAs(expectedMessages); } - @DataProvider - public static Object[][] haveNameStartingWith_rules() { - return $$( + static Stream haveNameStartingWith_rules() { + return Stream.of( $(members().should().haveNameStartingWith("field"), "field", "violated"), $(members().should(ArchConditions.haveNameStartingWith("field")), "field", "violated"), $(fields().should().haveNameStartingWith("field"), "field", "violated"), @@ -413,9 +404,9 @@ public static Object[][] haveNameStartingWith_rules() { ); } - @Test - @UseDataProvider("haveNameStartingWith_rules") - public void haveNameStartingWith(ArchRule rule, String prefix, String violatingMember) { + @ParameterizedTest + @MethodSource("haveNameStartingWith_rules") + void haveNameStartingWith(ArchRule rule, String prefix, String violatingMember) { EvaluationResult result = rule.evaluate(importClasses(SimpleFieldAndMethod.class)); assertThat(singleLineFailureReportOf(result)) @@ -425,9 +416,8 @@ public void haveNameStartingWith(ArchRule rule, String prefix, String violatingM locationPattern(SimpleFieldAndMethod.class))); } - @DataProvider - public static Object[][] haveNameNotStartingWith_rules() { - return $$( + static Stream haveNameNotStartingWith_rules() { + return Stream.of( $(members().should().haveNameNotStartingWith("violated"), "violated"), $(members().should(ArchConditions.haveNameNotStartingWith("violated")), "violated"), $(fields().should().haveNameNotStartingWith("violated"), "violated"), @@ -441,9 +431,9 @@ public static Object[][] haveNameNotStartingWith_rules() { ); } - @Test - @UseDataProvider("haveNameNotStartingWith_rules") - public void haveNameNotStartingWith(ArchRule rule, String prefix) { + @ParameterizedTest + @MethodSource("haveNameNotStartingWith_rules") + void haveNameNotStartingWith(ArchRule rule, String prefix) { EvaluationResult result = rule.evaluate(importClasses(SimpleFieldAndMethod.class)); assertThat(singleLineFailureReportOf(result)) @@ -453,9 +443,8 @@ public void haveNameNotStartingWith(ArchRule rule, String prefix) { locationPattern(SimpleFieldAndMethod.class))); } - @DataProvider - public static Object[][] haveNameContaining_rules() { - return $$( + static Stream haveNameContaining_rules() { + return Stream.of( $(members().should().haveNameContaining("field"), "field", "violated"), $(members().should(ArchConditions.haveNameContaining("field")), "field", "violated"), $(fields().should().haveNameContaining("field"), "field", "violated"), @@ -469,9 +458,9 @@ public static Object[][] haveNameContaining_rules() { ); } - @Test - @UseDataProvider("haveNameContaining_rules") - public void haveNameContaining(ArchRule rule, String infix, String violatingMember) { + @ParameterizedTest + @MethodSource("haveNameContaining_rules") + void haveNameContaining(ArchRule rule, String infix, String violatingMember) { EvaluationResult result = rule.evaluate(importClasses(SimpleFieldAndMethod.class)); assertThat(singleLineFailureReportOf(result)) @@ -481,9 +470,8 @@ public void haveNameContaining(ArchRule rule, String infix, String violatingMemb locationPattern(SimpleFieldAndMethod.class))); } - @DataProvider - public static Object[][] haveNameNotContaining_rules() { - return $$( + static Stream haveNameNotContaining_rules() { + return Stream.of( $(members().should().haveNameNotContaining("violated"), "violated"), $(members().should(ArchConditions.haveNameNotContaining("violated")), "violated"), $(fields().should().haveNameNotContaining("violated"), "violated"), @@ -497,9 +485,9 @@ public static Object[][] haveNameNotContaining_rules() { ); } - @Test - @UseDataProvider("haveNameNotContaining_rules") - public void haveNameNotContaining(ArchRule rule, String infix) { + @ParameterizedTest + @MethodSource("haveNameNotContaining_rules") + void haveNameNotContaining(ArchRule rule, String infix) { EvaluationResult result = rule.evaluate(importClasses(SimpleFieldAndMethod.class)); assertThat(singleLineFailureReportOf(result)) @@ -509,9 +497,8 @@ public void haveNameNotContaining(ArchRule rule, String infix) { locationPattern(SimpleFieldAndMethod.class))); } - @DataProvider - public static Object[][] haveNameEndingWith_rules() { - return $$( + static Stream haveNameEndingWith_rules() { + return Stream.of( $(members().should().haveNameEndingWith("field"), "field", "violated"), $(members().should(ArchConditions.haveNameEndingWith("field")), "field", "violated"), $(fields().should().haveNameEndingWith("field"), "field", "violated"), @@ -525,9 +512,9 @@ public static Object[][] haveNameEndingWith_rules() { ); } - @Test - @UseDataProvider("haveNameEndingWith_rules") - public void haveNameEndingWith(ArchRule rule, String suffix, String violatingMember) { + @ParameterizedTest + @MethodSource("haveNameEndingWith_rules") + void haveNameEndingWith(ArchRule rule, String suffix, String violatingMember) { EvaluationResult result = rule.evaluate(importClasses(SimpleFieldAndMethod.class)); assertThat(singleLineFailureReportOf(result)) @@ -537,9 +524,8 @@ public void haveNameEndingWith(ArchRule rule, String suffix, String violatingMem locationPattern(SimpleFieldAndMethod.class))); } - @DataProvider - public static Object[][] haveNameNotEndingWith_rules() { - return $$( + static Stream haveNameNotEndingWith_rules() { + return Stream.of( $(members().should().haveNameNotEndingWith("violated"), "violated"), $(members().should(ArchConditions.haveNameNotEndingWith("violated")), "violated"), $(fields().should().haveNameNotEndingWith("violated"), "violated"), @@ -553,9 +539,9 @@ public static Object[][] haveNameNotEndingWith_rules() { ); } - @Test - @UseDataProvider("haveNameNotEndingWith_rules") - public void haveNameNotEndingWith(ArchRule rule, String suffix) { + @ParameterizedTest + @MethodSource("haveNameNotEndingWith_rules") + void haveNameNotEndingWith(ArchRule rule, String suffix) { EvaluationResult result = rule.evaluate(importClasses(SimpleFieldAndMethod.class)); assertThat(singleLineFailureReportOf(result)) @@ -595,14 +581,14 @@ public void call() { @Test public void should_allow_empty_should_if_configured() { - configurationRule.setFailOnEmptyShould(false); + archConfiguration.setFailOnEmptyShould(false); ruleWithEmptyShould().check(new ClassFileImporter().importClasses(getClass())); } @Test public void should_allow_empty_should_if_overridden_by_rule() { - configurationRule.setFailOnEmptyShould(true); + archConfiguration.setFailOnEmptyShould(true); ruleWithEmptyShould().allowEmptyShould(true).check(new ClassFileImporter().importClasses(getClass())); } diff --git a/archunit/src/test/java/com/tngtech/archunit/library/dependencies/RandomSlicesSyntaxTest.java b/archunit/src/test/java/com/tngtech/archunit/library/dependencies/RandomSlicesSyntaxTest.java index e9636eea11..b153765513 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/dependencies/RandomSlicesSyntaxTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/dependencies/RandomSlicesSyntaxTest.java @@ -2,18 +2,18 @@ import java.util.List; import java.util.regex.Pattern; +import java.util.stream.Stream; import com.tngtech.archunit.library.dependencies.syntax.GivenSlices; import com.tngtech.archunit.testutil.syntax.MethodChoiceStrategy; import com.tngtech.archunit.testutil.syntax.RandomSyntaxSeed; import com.tngtech.archunit.testutil.syntax.RandomSyntaxTestBase; -import com.tngtech.java.junit.dataprovider.DataProvider; +import org.junit.jupiter.params.provider.Arguments; import static com.tngtech.archunit.library.dependencies.SlicesRuleDefinition.slices; public class RandomSlicesSyntaxTest extends RandomSyntaxTestBase { - @DataProvider - public static List> random_rules() { + static Stream random_rules() { return RandomSyntaxTestBase.createRandomRules(givenClassesSeed(), MethodChoiceStrategy.chooseAllArchUnitSyntaxMethods().exceptMethodsWithName("ignoreDependency"), new Skip("^naming slices.*"), diff --git a/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SliceRuleTest.java b/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SliceRuleTest.java index 78cf89515f..549fe8f832 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SliceRuleTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SliceRuleTest.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Set; import java.util.stream.IntStream; +import java.util.stream.Stream; import com.google.common.base.Splitter; import com.tngtech.archunit.ArchConfiguration; @@ -20,15 +21,14 @@ import com.tngtech.archunit.library.testclasses.second.three.any.SecondThreeAnyClass; import com.tngtech.archunit.library.testclasses.some.pkg.SomePkgClass; import com.tngtech.archunit.library.testclasses.some.pkg.sub.SomePkgSubclass; -import com.tngtech.archunit.testutil.ArchConfigurationRule; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; +import com.tngtech.archunit.testutil.ArchConfigurationExtension; import org.assertj.core.api.Condition; import org.assertj.core.api.ThrowableAssert.ThrowingCallable; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.math.IntMath.factorial; import static com.tngtech.archunit.library.cycle_detection.CycleConfiguration.MAX_NUMBER_OF_CYCLES_TO_DETECT_PROPERTY_NAME; @@ -36,25 +36,21 @@ import static com.tngtech.archunit.library.dependencies.GivenSlicesTest.TEST_CLASSES_PACKAGE; import static com.tngtech.archunit.library.dependencies.SlicesRuleDefinition.slices; import static com.tngtech.archunit.testutil.Assertions.assertThatDependencies; -import static com.tngtech.java.junit.dataprovider.DataProviders.$; -import static com.tngtech.java.junit.dataprovider.DataProviders.$$; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; +import static com.tngtech.archunit.testutil.DataProviders.$; import static java.lang.System.lineSeparator; import static java.util.stream.Collectors.toList; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -@RunWith(DataProviderRunner.class) public class SliceRuleTest { - @Rule - public final ArchConfigurationRule configurationRule = new ArchConfigurationRule(); + @RegisterExtension + ArchConfigurationExtension archConfiguration = new ArchConfigurationExtension(); - @DataProvider - public static Object[][] cycle_limits() { + static Stream cycle_limits() { int totalNumberOfCycles = getNumberOfCyclesInCompleteGraph(7); int halfOfTotal = totalNumberOfCycles / 2; - return $$( + return Stream.of( $(new Runnable() { @Override public void run() { @@ -105,9 +101,9 @@ public String toString() { ); } - @Test - @UseDataProvider("cycle_limits") - public void limits_number_of_cycles_to_configured_limit(Runnable configureLimit, int expectedNumberOfReportedCycles) { + @ParameterizedTest + @MethodSource("cycle_limits") + void limits_number_of_cycles_to_configured_limit(Runnable configureLimit, int expectedNumberOfReportedCycles) { configureLimit.run(); String violations = getFailureReportForCyclesInRootPackageOf(CompleteSevenNodesGraphRoot.class); @@ -175,28 +171,27 @@ public void call() { @Test public void should_allow_empty_should_if_configured() { - configurationRule.setFailOnEmptyShould(false); + archConfiguration.setFailOnEmptyShould(false); ruleWithEmptyShould().check(new ClassFileImporter().importClasses(getClass())); } @Test public void allows_empty_should_if_overridden() { - configurationRule.setFailOnEmptyShould(true); + archConfiguration.setFailOnEmptyShould(true); ruleWithEmptyShould().allowEmptyShould(true).check(new ClassFileImporter().importClasses(getClass())); } - @DataProvider - public static Object[][] rules() { - return testForEach( + static Stream rules() { + return Stream.of( slices().matching(TEST_CLASSES_PACKAGE + ".(*)..").should().notDependOnEachOther(), slices().matching(TEST_CLASSES_PACKAGE + ".(*)..").should().beFreeOfCycles()); } - @Test - @UseDataProvider("rules") - public void handles_violations_as_dependencies(SliceRule rule) { + @ParameterizedTest + @MethodSource("rules") + void handles_violations_as_dependencies(SliceRule rule) { JavaClasses classes = new ClassFileImporter().importPackages(TEST_CLASSES_PACKAGE); Set reportedDependencies = new HashSet<>(); diff --git a/archunit/src/test/java/com/tngtech/archunit/library/freeze/FreezingArchRuleTest.java b/archunit/src/test/java/com/tngtech/archunit/library/freeze/FreezingArchRuleTest.java index 8c5e4f87d9..9fdd366005 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/freeze/FreezingArchRuleTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/freeze/FreezingArchRuleTest.java @@ -13,6 +13,7 @@ import java.util.Set; import java.util.concurrent.atomic.AtomicReference; import java.util.function.Function; +import java.util.stream.Stream; import com.google.common.base.Functions; import com.google.common.collect.ImmutableList; @@ -25,15 +26,14 @@ import com.tngtech.archunit.lang.ArchRule; import com.tngtech.archunit.lang.ConditionEvent; import com.tngtech.archunit.lang.ConditionEvents; -import com.tngtech.archunit.testutil.ArchConfigurationRule; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; +import com.tngtech.archunit.testutil.ArchConfigurationExtension; import org.assertj.core.api.ThrowableAssert.ThrowingCallable; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TemporaryFolder; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.io.TempDir; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.collect.Sets.cartesianProduct; @@ -48,7 +48,6 @@ import static java.util.stream.Collectors.toList; import static org.assertj.core.api.Assertions.assertThatThrownBy; -@RunWith(DataProviderRunner.class) public class FreezingArchRuleTest { private static final String STORE_PROPERTY_NAME = "freeze.store"; @@ -57,11 +56,11 @@ public class FreezingArchRuleTest { private static final String ALLOW_STORE_UPDATE_PROPERTY_NAME = "freeze.store.default.allowStoreUpdate"; private static final String LINE_MATCHER_PROPERTY_NAME = "freeze.lineMatcher"; - @Rule - public final ArchConfigurationRule configurationRule = new ArchConfigurationRule(); + @RegisterExtension + ArchConfigurationExtension archConfiguration = new ArchConfigurationExtension(); - @Rule - public final TemporaryFolder temporaryFolder = new TemporaryFolder(); + @TempDir + File temporaryFolder; @Test public void delegates_description() { @@ -252,8 +251,7 @@ public void fails_on_an_increased_violation_count_of_the_same_violation_compared .hasAnyViolationOf("violation", "equivalent one"); } - @DataProvider - public static List> different_line_separators_to_store_and_read() { + static Stream different_line_separators_to_store_and_read() { String windowsLineSeparator = "\r\n"; String unixLineSeparator = "\n"; @@ -263,12 +261,12 @@ public static List> different_line_separators_to_store_and_read() { return cartesianProduct(lineSeparators, lineSeparators).stream() .filter(input -> !input.get(0).equals(input.get(1))) - .collect(toList()); + .map(list -> Arguments.of(list.get(0), list.get(1))); } - @Test - @UseDataProvider("different_line_separators_to_store_and_read") - public void default_violation_store_works_with_multi_line_rule_texts_with_different_line_separators( + @ParameterizedTest + @MethodSource("different_line_separators_to_store_and_read") + void default_violation_store_works_with_multi_line_rule_texts_with_different_line_separators( String lineSeparatorOnFreeze, String lineSeparatorOnCheck) throws IOException { useTemporaryDefaultStorePath(); @@ -287,9 +285,9 @@ public void default_violation_store_works_with_multi_line_rule_texts_with_differ .hasOnlyViolations("new"); } - @Test - @UseDataProvider("different_line_separators_to_store_and_read") - public void works_with_multi_line_violations_with_different_line_separators(String lineSeparatorOnFreeze, String lineSeparatorOnCheck) { + @ParameterizedTest + @MethodSource("different_line_separators_to_store_and_read") + void works_with_multi_line_violations_with_different_line_separators(String lineSeparatorOnFreeze, String lineSeparatorOnCheck) { TestViolationStore violationStore = new TestViolationStore(); RuleCreator ruleCreator = rule("some rule") @@ -533,7 +531,7 @@ private void createFrozen(TestViolationStore violationStore, ArchRule rule) { } private File useTemporaryDefaultStorePath() throws IOException { - File folder = temporaryFolder.newFolder(); + File folder = temporaryFolder; ArchConfiguration.get().setProperty(STORE_DEFAULT_PATH_PROPERTY_NAME, folder.getAbsolutePath()); return folder; } diff --git a/archunit/src/test/java/com/tngtech/archunit/library/modules/RandomModulesSyntaxTest.java b/archunit/src/test/java/com/tngtech/archunit/library/modules/RandomModulesSyntaxTest.java index 4a6265e495..a97c8b5e1e 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/modules/RandomModulesSyntaxTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/modules/RandomModulesSyntaxTest.java @@ -1,8 +1,7 @@ package com.tngtech.archunit.library.modules; import java.util.Arrays; -import java.util.Collection; -import java.util.List; +import java.util.stream.Stream; import com.google.common.reflect.TypeToken; import com.tngtech.archunit.base.DescribedFunction; @@ -17,15 +16,13 @@ import com.tngtech.archunit.testutil.syntax.RandomSyntaxSeed; import com.tngtech.archunit.testutil.syntax.RandomSyntaxTestBase; import com.tngtech.archunit.testutil.syntax.SingleParameterProvider; -import com.tngtech.java.junit.dataprovider.DataProvider; +import org.junit.jupiter.params.provider.Arguments; import static com.tngtech.archunit.base.DescribedPredicate.alwaysTrue; import static com.tngtech.archunit.testutil.syntax.MethodChoiceStrategy.chooseAllArchUnitSyntaxMethods; -import static java.util.stream.Collectors.toList; public class RandomModulesSyntaxTest extends RandomSyntaxTestBase { - @DataProvider - public static List> random_rules() { + static Stream random_rules() { return createRandomRulesForSeeds( new RandomSyntaxSeed<>( givenModulesClass(), @@ -55,9 +52,9 @@ public static List> random_rules() { } @SafeVarargs - private static List> createRandomRulesForSeeds(RandomSyntaxSeed>... seeds) { - return Arrays.stream(seeds) - .map(seed -> RandomSyntaxTestBase.createRandomRules( + private static Stream createRandomRulesForSeeds(RandomSyntaxSeed>... seeds) { + return Arrays.stream(seeds).flatMap(seed -> + RandomSyntaxTestBase.createRandomRules( RandomRulesBlueprint .seed(seed) .methodChoiceStrategy(chooseAllArchUnitSyntaxMethods().exceptMethodsWithName("ignoreDependency")) @@ -117,10 +114,8 @@ public Parameter get(String methodName, TypeToken type) { new ReplaceEverythingSoFar("as '([^']+)'.*", "$1"), new SingleStringReplacement("meta annotated", "meta-annotated") ) - ) ) - .flatMap(Collection::stream) - .collect(toList()); + ); } @SuppressWarnings({"unchecked", "rawtypes"}) diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/ArchConfigurationExtension.java b/archunit/src/test/java/com/tngtech/archunit/testutil/ArchConfigurationExtension.java new file mode 100644 index 0000000000..c6495b156b --- /dev/null +++ b/archunit/src/test/java/com/tngtech/archunit/testutil/ArchConfigurationExtension.java @@ -0,0 +1,49 @@ +package com.tngtech.archunit.testutil; + +import java.util.ArrayList; +import java.util.List; + +import com.tngtech.archunit.ArchConfiguration; +import org.junit.jupiter.api.extension.AfterEachCallback; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.Extension; +import org.junit.jupiter.api.extension.ExtensionContext; + +public class ArchConfigurationExtension implements Extension, BeforeEachCallback, AfterEachCallback { + + public static final String FAIL_ON_EMPTY_SHOULD_PROPERTY_NAME = "archRule.failOnEmptyShould"; + + private boolean beforeHasBeenExecuted = false; + private final List configurationInitializers = new ArrayList<>(); + + public void resolveAdditionalDependenciesFromClassPath(boolean enabled) { + addConfigurationInitializer(() -> ArchConfiguration.get().setResolveMissingDependenciesFromClassPath(enabled)); + } + + public ArchConfigurationExtension setFailOnEmptyShould(boolean failOnEmptyShould) { + addConfigurationInitializer(() -> ArchConfiguration.get().setProperty(FAIL_ON_EMPTY_SHOULD_PROPERTY_NAME, String.valueOf(failOnEmptyShould))); + return this; + } + + private void addConfigurationInitializer(Runnable initializer) { + if (beforeHasBeenExecuted) { + initializer.run(); + } else { + configurationInitializers.add(initializer); + } + } + + @Override + public void beforeEach(ExtensionContext context) { + ArchConfiguration.get().reset(); + for (Runnable initializer : configurationInitializers) { + initializer.run(); + } + beforeHasBeenExecuted = true; + } + + @Override + public void afterEach(ExtensionContext context) { + ArchConfiguration.get().reset(); + } +} \ No newline at end of file diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/ArchConfigurationRule.java b/archunit/src/test/java/com/tngtech/archunit/testutil/ArchConfigurationRule.java index a1a0f33fd0..bd635ce771 100644 --- a/archunit/src/test/java/com/tngtech/archunit/testutil/ArchConfigurationRule.java +++ b/archunit/src/test/java/com/tngtech/archunit/testutil/ArchConfigurationRule.java @@ -1,48 +1,38 @@ package com.tngtech.archunit.testutil; -import java.util.ArrayList; -import java.util.List; import java.util.concurrent.Callable; import com.tngtech.archunit.ArchConfiguration; +import org.junit.jupiter.api.extension.ExtensionContext; import org.junit.rules.ExternalResource; +/** + * @deprecated use JUnit 5 and {@link ArchConfigurationExtension} instead + */ +@Deprecated public class ArchConfigurationRule extends ExternalResource { - public static final String FAIL_ON_EMPTY_SHOULD_PROPERTY_NAME = "archRule.failOnEmptyShould"; - - private boolean beforeHasBeenExecuted = false; - private final List configurationInitializers = new ArrayList<>(); + private final ArchConfigurationExtension configuration = new ArchConfigurationExtension(); public ArchConfigurationRule resolveAdditionalDependenciesFromClassPath(boolean enabled) { - addConfigurationInitializer(() -> ArchConfiguration.get().setResolveMissingDependenciesFromClassPath(enabled)); + configuration.resolveAdditionalDependenciesFromClassPath(enabled); return this; } public ArchConfigurationRule setFailOnEmptyShould(boolean failOnEmptyShould) { - addConfigurationInitializer(() -> ArchConfiguration.get().setProperty(FAIL_ON_EMPTY_SHOULD_PROPERTY_NAME, String.valueOf(failOnEmptyShould))); + configuration.setFailOnEmptyShould(failOnEmptyShould); return this; } - private void addConfigurationInitializer(Runnable initializer) { - if (beforeHasBeenExecuted) { - initializer.run(); - } else { - configurationInitializers.add(initializer); - } - } - @Override protected void before() { - ArchConfiguration.get().reset(); - for (Runnable initializer : configurationInitializers) { - initializer.run(); - } - beforeHasBeenExecuted = true; + ExtensionContext unusedContext = null; // good enough for now, and ArchConfigurationRule is deprecated anyways + configuration.beforeEach(unusedContext); } @Override protected void after() { - ArchConfiguration.get().reset(); + ExtensionContext unusedContext = null; // good enough for now, and ArchConfigurationRule is deprecated anyways + configuration.afterEach(unusedContext); } public static T resetConfigurationAround(Callable callable) { diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/syntax/RandomSyntaxTestBase.java b/archunit/src/test/java/com/tngtech/archunit/testutil/syntax/RandomSyntaxTestBase.java index 7e2626c098..3e71113c55 100644 --- a/archunit/src/test/java/com/tngtech/archunit/testutil/syntax/RandomSyntaxTestBase.java +++ b/archunit/src/test/java/com/tngtech/archunit/testutil/syntax/RandomSyntaxTestBase.java @@ -21,12 +21,11 @@ import com.tngtech.archunit.lang.ArchCondition; import com.tngtech.archunit.lang.ArchRule; import com.tngtech.archunit.lang.ConditionEvents; -import com.tngtech.archunit.testutil.ArchConfigurationRule; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; +import com.tngtech.archunit.testutil.ArchConfigurationExtension; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -35,6 +34,7 @@ import static com.tngtech.archunit.core.domain.Formatters.ensureSimpleName; import static com.tngtech.archunit.core.domain.JavaConstructor.CONSTRUCTOR_NAME; import static com.tngtech.archunit.core.domain.TestUtils.importClassesWithContext; +import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.Arrays.asList; import static java.util.Arrays.stream; import static java.util.Collections.emptyList; @@ -43,23 +43,22 @@ import static java.util.stream.Collectors.toSet; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public abstract class RandomSyntaxTestBase { private static final Logger LOG = LoggerFactory.getLogger(RandomSyntaxTestBase.class); protected static final Random random = new Random(); private static final int NUMBER_OF_RULES_TO_BUILD = 1000; - @Rule - public final ArchConfigurationRule archConfigurationRule = new ArchConfigurationRule().setFailOnEmptyShould(false); + @RegisterExtension + ArchConfigurationExtension archConfiguration = new ArchConfigurationExtension().setFailOnEmptyShould(false); - public static List> createRandomRules( + protected static Stream createRandomRules( RandomSyntaxSeed seed, DescriptionReplacement... replacements ) { return createRandomRules(seed, MethodChoiceStrategy.chooseAllArchUnitSyntaxMethods(), replacements); } - public static List> createRandomRules( + protected static Stream createRandomRules( RandomSyntaxSeed seed, MethodChoiceStrategy methodChoiceStrategy, DescriptionReplacement... replacements @@ -67,7 +66,7 @@ public static List> createRandomRules( return createRandomRules(RandomRulesBlueprint.seed(seed).methodChoiceStrategy(methodChoiceStrategy).descriptionReplacements(replacements)); } - public static List> createRandomRules(RandomRulesBlueprint blueprint) { + protected static Stream createRandomRules(RandomRulesBlueprint blueprint) { return IntStream.range(0, NUMBER_OF_RULES_TO_BUILD) .mapToObj(i -> new SyntaxSpec<>( blueprint.seed, @@ -75,12 +74,11 @@ public static List> createRandomRules(RandomRulesBlueprint blueprint) { blueprint.parameterProviders, ExpectedDescription.from(blueprint.seed, blueprint.descriptionReplacements)) ) - .map(spec -> ImmutableList.of(spec.getActualArchRule(), spec.getExpectedDescription())) - .collect(toList()); + .map(spec -> $(spec.getActualArchRule(), spec.getExpectedDescription())); } - @Test - @UseDataProvider("random_rules") + @ParameterizedTest + @MethodSource("random_rules") public void rule_has_expected_description_and_can_be_evaluated_without_error( DescribedRule describedRule, String expectedDescription) { ArchRule archRule = describedRule.archRule; From bea2204d8ede218af469aa9c8c0f37206523c690 Mon Sep 17 00:00:00 2001 From: Manfred Hanke Date: Sun, 4 May 2025 11:54:23 +0200 Subject: [PATCH 07/11] migrate ClassFileImporterTest to junit-jupiter-params replacing the JUnit 4 `@Rule`s with JUnit Jupiter extensions (`ContextClassLoaderExtension`, `LogTestExtension`, `OutsideOfClassPathExtension`, `ReplaceFileExtension`, `SystemPropertiesExtension`) and also converting some other tests that made use of the same `TestRule`s to JUnit 5 to eliminate some of these custom `TestRule`s already (`LogTestRule`, `OutsideOfClassPathRule`, `ReplaceFileRule`) Signed-off-by: Manfred Hanke --- .../core/importer/ClassFileImporterTest.java | 88 ++++++++----------- ...ava => IndependentClasspathExtension.java} | 41 ++++----- .../archunit/core/importer/LocationsTest.java | 24 ++--- .../resolvers/ClassResolverFactoryTest.java | 22 +++-- .../ArchUnitExtensionLoaderTest.java | 20 ++--- .../extension/ArchUnitExtensionsTest.java | 33 ++++--- .../lang/extension/TestServicesFile.java | 18 +--- .../testutil/ContextClassLoaderExtension.java | 19 ++++ .../testutil/ContextClassLoaderRule.java | 3 + ...LogTestRule.java => LogTestExtension.java} | 7 +- ....java => OutsideOfClassPathExtension.java} | 35 +++++--- ...ileRule.java => ReplaceFileExtension.java} | 7 +- .../testutil/SystemPropertiesExtension.java | 21 +++++ .../testutil/SystemPropertiesRule.java | 3 + 14 files changed, 188 insertions(+), 153 deletions(-) rename archunit/src/test/java/com/tngtech/archunit/core/importer/{IndependentClasspathRule.java => IndependentClasspathExtension.java} (80%) create mode 100644 archunit/src/test/java/com/tngtech/archunit/testutil/ContextClassLoaderExtension.java rename archunit/src/test/java/com/tngtech/archunit/testutil/{LogTestRule.java => LogTestExtension.java} (86%) rename archunit/src/test/java/com/tngtech/archunit/testutil/{OutsideOfClassPathRule.java => OutsideOfClassPathExtension.java} (82%) rename archunit/src/test/java/com/tngtech/archunit/testutil/{ReplaceFileRule.java => ReplaceFileExtension.java} (94%) create mode 100644 archunit/src/test/java/com/tngtech/archunit/testutil/SystemPropertiesExtension.java diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterTest.java index d9ad9c25c6..a7bff77874 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterTest.java @@ -12,6 +12,7 @@ import java.nio.file.Paths; import java.util.Collection; import java.util.Set; +import java.util.stream.Stream; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; @@ -72,18 +73,18 @@ import com.tngtech.archunit.core.importer.testexamples.simpleimport.InterfaceToImport; import com.tngtech.archunit.core.importer.testexamples.simplenames.SimpleNameExamples; import com.tngtech.archunit.core.importer.testexamples.syntheticimport.ClassWithSynthetics; -import com.tngtech.archunit.testutil.ArchConfigurationRule; -import com.tngtech.archunit.testutil.LogTestRule; -import com.tngtech.archunit.testutil.OutsideOfClassPathRule; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; +import com.tngtech.archunit.testutil.ArchConfigurationExtension; +import com.tngtech.archunit.testutil.LogTestExtension; +import com.tngtech.archunit.testutil.OutsideOfClassPathExtension; import org.apache.logging.log4j.Level; import org.assertj.core.api.Condition; import org.junit.Ignore; import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TemporaryFolder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; import org.junit.runner.RunWith; import static com.google.common.collect.Iterables.getOnlyElement; @@ -109,24 +110,20 @@ import static com.tngtech.archunit.testutil.TestUtils.uriOf; import static com.tngtech.archunit.testutil.TestUtils.urlOf; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteParameterizedType.parameterizedType; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; import static java.nio.charset.StandardCharsets.UTF_8; import static java.util.Arrays.stream; import static java.util.stream.Collectors.toSet; -import static org.junit.Assume.assumeTrue; +import static org.junit.jupiter.api.Assumptions.assumeTrue; -@RunWith(DataProviderRunner.class) public class ClassFileImporterTest { - @Rule - public final OutsideOfClassPathRule outsideOfClassPath = new OutsideOfClassPathRule(); - @Rule - public final TemporaryFolder temporaryFolder = new TemporaryFolder(); - @Rule - public final LogTestRule logTest = new LogTestRule(); - @Rule - public final IndependentClasspathRule independentClasspathRule = new IndependentClasspathRule(); - @Rule - public final ArchConfigurationRule archConfigurationRule = new ArchConfigurationRule(); + @RegisterExtension + OutsideOfClassPathExtension outsideOfClassPath = new OutsideOfClassPathExtension(); + @RegisterExtension + LogTestExtension logTest = new LogTestExtension(); + @RegisterExtension + IndependentClasspathExtension independentClasspathExtension = new IndependentClasspathExtension(); + @RegisterExtension + ArchConfigurationExtension archConfiguration = new ArchConfigurationExtension(); @Test public void imports_simple_package() { @@ -188,13 +185,8 @@ public void imports_simple_enum() { .containsOnly(EnumToImport.FIRST.name(), EnumToImport.SECOND.name()); } - @DataProvider - public static Object[][] nested_static_classes() { - return testForEach(ClassWithInnerClass.NestedStatic.class, ClassWithInnerClass.ImplicitlyNestedStatic.class); - } - - @Test - @UseDataProvider("nested_static_classes") + @ParameterizedTest + @ValueSource(classes = {ClassWithInnerClass.NestedStatic.class, ClassWithInnerClass.ImplicitlyNestedStatic.class}) public void imports_simple_static_nested_class(Class nestedStaticClass) { JavaClasses classes = new ClassFileImporter().importUrl(getClass().getResource("testexamples/innerclassimport")); @@ -396,15 +388,10 @@ public void creates_JavaPackages_for_each_JavaClass() { assertThatTypes(javaPackage.getParent().get().getClasses()).contain(getClass()); } - @DataProvider - public static Object[][] array_types() { - return testForEach(ClassAccessingOneDimensionalArray.class, ClassAccessingTwoDimensionalArray.class); - } - // we want to diverge from the Reflection API in this place, because it is way more useful for dependency checks, // if com.some.SomeArray[].getPackageName() reports 'com.some' instead of '' (which would be ArchUnit's equivalent of null) - @Test - @UseDataProvider("array_types") + @ParameterizedTest + @ValueSource(classes = {ClassAccessingOneDimensionalArray.class, ClassAccessingTwoDimensionalArray.class}) public void adds_package_of_component_type_to_arrays(Class classAccessingArray) { JavaClass javaClass = new ClassFileImporter().importPackagesOf(classAccessingArray) .get(classAccessingArray); @@ -720,8 +707,8 @@ public void imports_urls_of_folders() throws Exception { @Test public void imports_urls_of_jars() { Set urls = newHashSet(urlOf(Test.class), urlOf(RunWith.class)); - assumeTrue("We can't completely ensure that this will always be taken from a JAR file, though it's very likely", - "jar".equals(urls.iterator().next().getProtocol())); + assumeTrue("jar".equals(urls.iterator().next().getProtocol()), + "We can't completely ensure that this will always be taken from a JAR file, though it's very likely"); JavaClasses classes = new ClassFileImporter().importUrls(urls) .that(DescribedPredicate.not(type(Annotation.class))); // NOTE @Test and @RunWith implement Annotation.class @@ -787,7 +774,7 @@ public void resolve_missing_dependencies_from_classpath_can_be_toggled() { public void import_is_resilient_against_broken_class_files() throws Exception { Class expectedClass = getClass(); - File folder = temporaryFolder.newFolder(); + File folder = outsideOfClassPath.getTemporaryFolder(); copyClassFile(expectedClass, folder); Files.write(new File(folder, "Evil.class").toPath(), "broken".getBytes(UTF_8)); @@ -838,23 +825,23 @@ public void imports_class_objects() { */ @Test public void imports_packages_even_if_jar_entry_for_package_is_missing() { - String packageToImport = independentClasspathRule.getIndependentTopLevelPackage(); + String packageToImport = independentClasspathExtension.getIndependentTopLevelPackage(); ClassFileImporter classFileImporter = new ClassFileImporter(); JavaClasses classes = classFileImporter.importPackages(packageToImport); assertThat(classes).extracting("name") - .doesNotContain(independentClasspathRule.getNameOfSomeContainedClass()); + .doesNotContain(independentClasspathExtension.getNameOfSomeContainedClass()); - independentClasspathRule.configureClasspath(); + independentClasspathExtension.configureClasspath(); - classes = classFileImporter.importUrl(independentClasspathRule.getOnlyUrl()); + classes = classFileImporter.importUrl(independentClasspathExtension.getOnlyUrl()); assertThat(classes).extracting("name") - .containsAll(independentClasspathRule.getNamesOfClasses()); + .containsAll(independentClasspathExtension.getNamesOfClasses()); assertThat(classes).extracting("packageName") - .containsAll(independentClasspathRule.getPackagesOfClasses()); + .containsAll(independentClasspathExtension.getPackagesOfClasses()); classes = classFileImporter.importPackages(packageToImport); - assertThat(classes).extracting("name").contains(independentClasspathRule.getNameOfSomeContainedClass()); + assertThat(classes).extracting("name").contains(independentClasspathExtension.getNameOfSomeContainedClass()); } @Test @@ -880,9 +867,8 @@ public void imports_paths() { assertThatTypes(classes).matchInAnyOrder(Class11.class, Class12.class); } - @DataProvider - public static Object[][] data_ImportOptions_are_respected() { - return testForEach( + static Stream importOptions_are_respected() { + return Stream.of( new ClassFileImporter().withImportOption(importOnly(ClassFileImporterTest.class, Rule.class)), new ClassFileImporter().withImportOptions(ImmutableSet.of( importOnly(ClassFileImporterTest.class, ClassFileImporterTestUtils.class, Rule.class, Test.class), @@ -891,9 +877,9 @@ public static Object[][] data_ImportOptions_are_respected() { ); } - @Test - @UseDataProvider - public void test_ImportOptions_are_respected(ClassFileImporter importer) throws Exception { + @ParameterizedTest + @MethodSource + public void importOptions_are_respected(ClassFileImporter importer) throws Exception { assertThatTypes(importer.importPath(Paths.get(uriOf(getClass())))).matchExactly(getClass()); assertThatTypes(importer.importUrl(urlOf(getClass()))).matchExactly(getClass()); assertThatTypes(importer.importJar(jarFileOf(Rule.class))).matchExactly(Rule.class); diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/IndependentClasspathRule.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/IndependentClasspathExtension.java similarity index 80% rename from archunit/src/test/java/com/tngtech/archunit/core/importer/IndependentClasspathRule.java rename to archunit/src/test/java/com/tngtech/archunit/core/importer/IndependentClasspathExtension.java index 1073c49821..17423e9f9a 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/IndependentClasspathRule.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/IndependentClasspathExtension.java @@ -8,34 +8,35 @@ import java.util.Set; import com.google.common.collect.ImmutableSet; -import com.tngtech.archunit.testutil.ContextClassLoaderRule; -import com.tngtech.archunit.testutil.SystemPropertiesRule; +import com.tngtech.archunit.testutil.ContextClassLoaderExtension; +import com.tngtech.archunit.testutil.SystemPropertiesExtension; import org.junit.Assert; -import org.junit.rules.TestRule; -import org.junit.runner.Description; -import org.junit.runners.model.Statement; +import org.junit.jupiter.api.extension.AfterEachCallback; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; import static com.google.common.base.Preconditions.checkState; import static com.google.common.collect.Iterables.getOnlyElement; -public class IndependentClasspathRule implements TestRule { +public class IndependentClasspathExtension implements BeforeEachCallback, AfterEachCallback { private Setup setup; - private final SystemPropertiesRule systemPropertiesRule = new SystemPropertiesRule(); - private final ContextClassLoaderRule contextClassLoaderRule = new ContextClassLoaderRule(); + private final SystemPropertiesExtension systemPropertiesExtension = new SystemPropertiesExtension(); + private final ContextClassLoaderExtension contextClassLoaderExtension = new ContextClassLoaderExtension(); @Override - public Statement apply(Statement base, Description description) { - Statement statement = new Statement() { - @Override - public void evaluate() throws Throwable { - base.evaluate(); - setup = null; - } - }; - return systemPropertiesRule.apply( - contextClassLoaderRule.apply(statement, description), - description - ); + public void beforeEach(ExtensionContext context) { + systemPropertiesExtension.beforeEach(context); + contextClassLoaderExtension.beforeEach(context); + } + + @Override + public void afterEach(ExtensionContext context) throws Exception { + try { + contextClassLoaderExtension.afterEach(context); + } finally { + systemPropertiesExtension.afterEach(context); + setup = null; + } } void configureClasspath() { diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/LocationsTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/LocationsTest.java index 0aa4db027b..8d6dcfe759 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/LocationsTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/LocationsTest.java @@ -16,8 +16,8 @@ import com.google.common.collect.ImmutableList; import com.tngtech.archunit.core.importer.testexamples.SomeEnum; import com.tngtech.java.junit.dataprovider.DataProvider; -import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; import static com.google.common.collect.Iterables.getOnlyElement; import static com.google.common.io.ByteStreams.toByteArray; @@ -28,8 +28,8 @@ import static org.assertj.core.api.Assertions.assertThat; public class LocationsTest { - @Rule - public final IndependentClasspathRule independentClasspathRule = new IndependentClasspathRule(); + @RegisterExtension + final IndependentClasspathExtension independentClasspathExtension = new IndependentClasspathExtension(); @Test public void locations_of_URLs() throws Exception { @@ -56,7 +56,7 @@ public void locations_of_packages_within_JAR_URIs() throws Exception { Set locations = Locations.ofPackage("org.junit"); assertThat(urisOf(locations)).contains( - uriOfFolderOf(Test.class) + uriOfFolderOf(org.junit.Test.class) ); } @@ -67,9 +67,9 @@ public void locations_of_packages_within_JAR_URIs() throws Exception { @Test @SuppressWarnings("EmptyTryBlock") public void locations_of_packages_within_JAR_URIs_that_do_not_contain_package_folder() throws Exception { - independentClasspathRule.configureClasspath(); + independentClasspathExtension.configureClasspath(); - Set locations = Locations.ofPackage(independentClasspathRule.getIndependentTopLevelPackage()); + Set locations = Locations.ofPackage(independentClasspathExtension.getIndependentTopLevelPackage()); ClassFileSource source = getOnlyElement(locations).asClassFileSource(new ImportOptions()); for (ClassFileLocation classFileLocation : source) { @@ -79,8 +79,8 @@ public void locations_of_packages_within_JAR_URIs_that_do_not_contain_package_fo } assertThat(source) - .as("URIs in " + independentClasspathRule.getIndependentTopLevelPackage()) - .hasSize(independentClasspathRule.getNamesOfClasses().size()); + .as("URIs in " + independentClasspathExtension.getIndependentTopLevelPackage()) + .hasSize(independentClasspathExtension.getNamesOfClasses().size()); } @Test @@ -151,8 +151,8 @@ public void locations_of_class_from_file_URI() throws Exception { @Test public void locations_of_class_from_JAR_URI() throws Exception { - assertThat(urisOf(Locations.ofClass(Test.class))).containsExactly( - urlOfClass(Test.class).toURI() + assertThat(urisOf(Locations.ofClass(org.junit.Test.class))).containsExactly( + urlOfClass(org.junit.Test.class).toURI() ); } @@ -161,7 +161,7 @@ public void locations_in_classpath() throws Exception { assertThat(urisOf(Locations.inClassPath())).contains( getClass().getResource("/").toURI(), resolvedUri(DataProvider.class, "/"), - resolvedUri(Test.class, "/") + resolvedUri(org.junit.Test.class, "/") ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/resolvers/ClassResolverFactoryTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/resolvers/ClassResolverFactoryTest.java index 178cbf1d3d..3c879ebb44 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/resolvers/ClassResolverFactoryTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/resolvers/ClassResolverFactoryTest.java @@ -12,23 +12,21 @@ import com.tngtech.archunit.base.ArchUnitException.ClassResolverConfigurationException; import com.tngtech.archunit.core.domain.JavaClass; import com.tngtech.archunit.core.importer.resolvers.ClassResolver.Factory.NoOpClassResolver; -import com.tngtech.archunit.testutil.ArchConfigurationRule; -import com.tngtech.archunit.testutil.ContextClassLoaderRule; -import com.tngtech.archunit.testutil.OutsideOfClassPathRule; +import com.tngtech.archunit.testutil.ArchConfigurationExtension; +import com.tngtech.archunit.testutil.ContextClassLoaderExtension; +import com.tngtech.archunit.testutil.OutsideOfClassPathExtension; import org.assertj.core.api.ThrowableAssert.ThrowingCallable; -import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.api.extension.RegisterExtension; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +@ExtendWith({ArchConfigurationExtension.class, ContextClassLoaderExtension.class}) public class ClassResolverFactoryTest { - @Rule - public final ArchConfigurationRule archConfigurationRule = new ArchConfigurationRule(); - @Rule - public final OutsideOfClassPathRule outsideOfClassPathRule = new OutsideOfClassPathRule(); - @Rule - public final ContextClassLoaderRule contextClassLoaderRule = new ContextClassLoaderRule(); + @RegisterExtension + final OutsideOfClassPathExtension outsideOfClassPath = new OutsideOfClassPathExtension(); private final ClassResolver.Factory resolverFactory = new ClassResolver.Factory(); @@ -105,7 +103,7 @@ public void exception_while_creating_resolver() { @Test public void loads_resolver_from_context_ClassLoader() throws IOException { - Path targetDir = outsideOfClassPathRule + Path targetDir = outsideOfClassPath .compileClassesFrom(getClass().getResource("testclasses/someresolver")) .getPath(); diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/extension/ArchUnitExtensionLoaderTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/extension/ArchUnitExtensionLoaderTest.java index fa9a7fa488..2fb87e1b80 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/extension/ArchUnitExtensionLoaderTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/extension/ArchUnitExtensionLoaderTest.java @@ -9,11 +9,11 @@ import com.tngtech.archunit.lang.extension.examples.TestExtensionWithNullIdentifier; import com.tngtech.archunit.lang.extension.examples.TestExtensionWithSameIdentifier; import com.tngtech.archunit.lang.extension.examples.YetAnotherDummyTestExtension; -import com.tngtech.archunit.testutil.LogTestRule; +import com.tngtech.archunit.testutil.LogTestExtension; import org.apache.logging.log4j.Level; import org.assertj.core.api.Condition; -import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; import static com.google.common.collect.Iterables.getOnlyElement; import static java.util.regex.Pattern.quote; @@ -21,10 +21,10 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; public class ArchUnitExtensionLoaderTest { - @Rule - public final TestServicesFile testServicesFile = new TestServicesFile(); - @Rule - public final LogTestRule logTestRule = new LogTestRule(); + @RegisterExtension + final TestServicesFile testServicesFile = new TestServicesFile(); + @RegisterExtension + final LogTestExtension logTest = new LogTestExtension(); private final ArchUnitExtensionLoader extensionLoader = new ArchUnitExtensionLoader(); @@ -102,12 +102,12 @@ public void logs_discovered_extensions() { testServicesFile.addService(TestExtension.class); testServicesFile.addService(DummyTestExtension.class); - logTestRule.watch(ArchUnitExtensionLoader.class, Level.INFO); + logTest.watch(ArchUnitExtensionLoader.class, Level.INFO); extensionLoader.getAll(); - logTestRule.assertLogMessage(Level.INFO, expectedExtensionLoadedMessage(TestExtension.UNIQUE_IDENTIFIER)); - logTestRule.assertLogMessage(Level.INFO, expectedExtensionLoadedMessage(DummyTestExtension.UNIQUE_IDENTIFIER)); + logTest.assertLogMessage(Level.INFO, expectedExtensionLoadedMessage(TestExtension.UNIQUE_IDENTIFIER)); + logTest.assertLogMessage(Level.INFO, expectedExtensionLoadedMessage(DummyTestExtension.UNIQUE_IDENTIFIER)); } private String expectedExtensionLoadedMessage(String identifier) { diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/extension/ArchUnitExtensionsTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/extension/ArchUnitExtensionsTest.java index b52074ebbb..9e7da99bd2 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/extension/ArchUnitExtensionsTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/extension/ArchUnitExtensionsTest.java @@ -5,15 +5,15 @@ import com.google.common.collect.ImmutableSet; import com.tngtech.archunit.ArchConfiguration; import com.tngtech.archunit.lang.extension.examples.TestExtension; -import com.tngtech.archunit.testutil.ArchConfigurationRule; -import com.tngtech.archunit.testutil.LogTestRule; +import com.tngtech.archunit.testutil.ArchConfigurationExtension; +import com.tngtech.archunit.testutil.LogTestExtension; import org.apache.logging.log4j.Level; -import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.api.extension.RegisterExtension; import org.mockito.InjectMocks; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; import static com.google.common.base.Preconditions.checkNotNull; import static com.tngtech.archunit.testutil.TestUtils.properties; @@ -21,13 +21,12 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.when; +@ExtendWith(MockitoExtension.class) public class ArchUnitExtensionsTest { - @Rule - public final MockitoRule mockitoRule = MockitoJUnit.rule(); - @Rule - public final ArchConfigurationRule configurationRule = new ArchConfigurationRule(); - @Rule - public final LogTestRule logTestRule = new LogTestRule(); + @RegisterExtension + final ArchConfigurationExtension configuration = new ArchConfigurationExtension(); + @RegisterExtension + final LogTestExtension logTest = new LogTestExtension(); @Mock private EvaluatedRule evaluatedRule; @@ -94,13 +93,13 @@ public void only_dispatches_to_enabled_extensions() { when(extensionLoader.getAll()).thenReturn(ImmutableSet.of(extensionOne, extensionTwo)); - logTestRule.watch(ArchUnitExtensions.class, Level.DEBUG); + logTest.watch(ArchUnitExtensions.class, Level.DEBUG); extensions.dispatch(evaluatedRule); assertThat(extensionOne.wasNeverCalled()).as("Extension 'one' was never called").isTrue(); assertThat(extensionTwo.wasNeverCalled()).as("Extension 'two' was never called").isFalse(); - logTestRule.assertLogMessage(Level.DEBUG, + logTest.assertLogMessage(Level.DEBUG, "Extension 'one' is disabled, skipping... (to enable this extension, configure extension.one.enabled=true)"); } @@ -142,12 +141,12 @@ private TestExtension newExtensionWithEnabled(String identifier, boolean enabled private void evaluateExtensionAndVerifyLog(String expectedExceptionMessage, ArchUnitExtension evilExtension) { when(extensionLoader.getAll()).thenReturn(singleton(evilExtension)); - logTestRule.watch(ArchUnitExtensions.class, Level.WARN); + logTest.watch(ArchUnitExtensions.class, Level.WARN); extensions.dispatch(evaluatedRule); - logTestRule.assertLogMessage(Level.WARN, evilExtension.getUniqueIdentifier()); - logTestRule.assertException(Level.WARN, TestException.class, expectedExceptionMessage); + logTest.assertLogMessage(Level.WARN, evilExtension.getUniqueIdentifier()); + logTest.assertException(Level.WARN, TestException.class, expectedExceptionMessage); } private static class TestException extends RuntimeException { diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/extension/TestServicesFile.java b/archunit/src/test/java/com/tngtech/archunit/lang/extension/TestServicesFile.java index df6fec66ae..b097a3610b 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/extension/TestServicesFile.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/extension/TestServicesFile.java @@ -1,27 +1,17 @@ package com.tngtech.archunit.lang.extension; -import com.tngtech.archunit.testutil.ReplaceFileRule; -import org.junit.rules.TestRule; -import org.junit.runner.Description; -import org.junit.runners.model.Statement; - import java.io.File; +import com.tngtech.archunit.testutil.ReplaceFileExtension; + import static com.tngtech.archunit.testutil.TestUtils.toUri; import static java.nio.charset.StandardCharsets.UTF_8; -public class TestServicesFile implements TestRule { - private final ReplaceFileRule replaceFile = new ReplaceFileRule(); - - @Override - public Statement apply(Statement base, Description description) { - return replaceFile.apply(base, description); - } - +public class TestServicesFile extends ReplaceFileExtension { public void addService(Class extensionClass) { File root = new File(toUri(getClass().getResource("/"))); File metaInfServices = new File(new File(root, "META-INF"), "services"); File extensionSPI = new File(metaInfServices, ArchUnitExtension.class.getName()); - replaceFile.appendLine(extensionSPI, extensionClass.getName(), UTF_8); + appendLine(extensionSPI, extensionClass.getName(), UTF_8); } } diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/ContextClassLoaderExtension.java b/archunit/src/test/java/com/tngtech/archunit/testutil/ContextClassLoaderExtension.java new file mode 100644 index 0000000000..5b9357d5f9 --- /dev/null +++ b/archunit/src/test/java/com/tngtech/archunit/testutil/ContextClassLoaderExtension.java @@ -0,0 +1,19 @@ +package com.tngtech.archunit.testutil; + +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.AfterEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; + +public class ContextClassLoaderExtension implements BeforeEachCallback, AfterEachCallback { + private ClassLoader contextClassLoader; + + @Override + public void beforeEach(ExtensionContext context) { + contextClassLoader = Thread.currentThread().getContextClassLoader(); + } + + @Override + public void afterEach(ExtensionContext context) { + Thread.currentThread().setContextClassLoader(contextClassLoader); + } +} diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/ContextClassLoaderRule.java b/archunit/src/test/java/com/tngtech/archunit/testutil/ContextClassLoaderRule.java index 6bdab426a4..c28099705e 100644 --- a/archunit/src/test/java/com/tngtech/archunit/testutil/ContextClassLoaderRule.java +++ b/archunit/src/test/java/com/tngtech/archunit/testutil/ContextClassLoaderRule.java @@ -2,6 +2,9 @@ import org.junit.rules.ExternalResource; +/** + * @deprecated use JUnit 5 and {@link ContextClassLoaderExtension} instead + */ public class ContextClassLoaderRule extends ExternalResource { private ClassLoader contextClassLoader; diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/LogTestRule.java b/archunit/src/test/java/com/tngtech/archunit/testutil/LogTestExtension.java similarity index 86% rename from archunit/src/test/java/com/tngtech/archunit/testutil/LogTestRule.java rename to archunit/src/test/java/com/tngtech/archunit/testutil/LogTestExtension.java index a2b641c1fc..4254e34cdb 100644 --- a/archunit/src/test/java/com/tngtech/archunit/testutil/LogTestRule.java +++ b/archunit/src/test/java/com/tngtech/archunit/testutil/LogTestExtension.java @@ -6,9 +6,10 @@ import com.tngtech.archunit.testutil.TestLogRecorder.RecordedLogEvent; import org.apache.logging.log4j.Level; import org.junit.Assert; -import org.junit.rules.ExternalResource; +import org.junit.jupiter.api.extension.AfterEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; -public class LogTestRule extends ExternalResource { +public class LogTestExtension implements AfterEachCallback { private final TestLogRecorder testLogRecorder = new TestLogRecorder(); public void watch(Class loggerClass, Level level) { @@ -16,7 +17,7 @@ public void watch(Class loggerClass, Level level) { } @Override - protected void after() { + public void afterEach(ExtensionContext context) throws Exception { testLogRecorder.reset(); } diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/OutsideOfClassPathRule.java b/archunit/src/test/java/com/tngtech/archunit/testutil/OutsideOfClassPathExtension.java similarity index 82% rename from archunit/src/test/java/com/tngtech/archunit/testutil/OutsideOfClassPathRule.java rename to archunit/src/test/java/com/tngtech/archunit/testutil/OutsideOfClassPathExtension.java index 5553ecd3d5..feabfce194 100644 --- a/archunit/src/test/java/com/tngtech/archunit/testutil/OutsideOfClassPathRule.java +++ b/archunit/src/test/java/com/tngtech/archunit/testutil/OutsideOfClassPathExtension.java @@ -1,6 +1,7 @@ package com.tngtech.archunit.testutil; import java.io.ByteArrayOutputStream; +import java.io.File; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.net.URL; @@ -11,6 +12,7 @@ import java.nio.file.SimpleFileVisitor; import java.nio.file.attribute.BasicFileAttributes; import java.util.List; +import java.util.UUID; import java.util.function.Predicate; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -19,24 +21,34 @@ import javax.tools.ToolProvider; import com.google.common.base.Splitter; -import org.junit.rules.TemporaryFolder; -import org.junit.rules.TestRule; -import org.junit.runner.Description; -import org.junit.runners.model.Statement; +import org.junit.jupiter.api.extension.AfterEachCallback; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; import static com.tngtech.archunit.testutil.TestUtils.newTemporaryFolder; import static com.tngtech.archunit.testutil.TestUtils.toUri; import static com.tngtech.archunit.testutil.TestUtils.unchecked; import static java.nio.charset.StandardCharsets.UTF_8; -public class OutsideOfClassPathRule implements TestRule { +public class OutsideOfClassPathExtension implements BeforeEachCallback, AfterEachCallback { private static final Pattern PACKAGE_DECLARATION_PATTERN = Pattern.compile("package (.*);"); - private final TemporaryFolder temporaryFolder = new TemporaryFolder(newTemporaryFolder()); + private final File temporaryFolder = newTemporaryFolder(); @Override - public Statement apply(Statement base, Description description) { - return temporaryFolder.apply(base, description); + public void beforeEach(ExtensionContext context) throws Exception { + if (!temporaryFolder.exists() && !temporaryFolder.mkdirs()) { + throw new IOException("Couldn't create temporary folder " + temporaryFolder); + } + } + + @Override + public void afterEach(ExtensionContext context) throws Exception { + temporaryFolder.delete(); + } + + public File getTemporaryFolder() { + return temporaryFolder; } /** @@ -48,7 +60,7 @@ public Statement apply(Statement base, Description description) { public CompiledClasses compileClassesFrom(URL url) { return unchecked(() -> { Path sourceFileDir = Paths.get(toUri(url)); - Path classFileDir = temporaryFolder.newFolder().toPath(); + Path classFileDir = new File(temporaryFolder, UUID.randomUUID().toString()).toPath(); try (Stream files = Files.list(sourceFileDir)) { files.filter(it -> it.toString().endsWith(".java")) @@ -63,7 +75,8 @@ private void compileJavaSourceFile(Path originalJavaSourceFile, Path targetDir) String packageName = readPackageNameOf(originalJavaSourceFile); Path packagePath = convertToRelativePath(packageName); - Path javaSourceDir = temporaryFolder.newFolder().toPath(); + Path javaSourceDir = new File(temporaryFolder, UUID.randomUUID().toString()).toPath(); + Files.createDirectories(javaSourceDir); Path javaSourceFile = Files.copy(originalJavaSourceFile, javaSourceDir.resolve(originalJavaSourceFile.getFileName())).toAbsolutePath(); executeCompile(javaSourceFile); @@ -73,7 +86,7 @@ private void compileJavaSourceFile(Path originalJavaSourceFile, Path targetDir) private static String readPackageNameOf(Path originalJavaSourceFile) throws IOException { return Files.readAllLines(originalJavaSourceFile, UTF_8).stream() - .flatMap(OutsideOfClassPathRule::tryMatchPackage) + .flatMap(OutsideOfClassPathExtension::tryMatchPackage) .findFirst() .orElseThrow(() -> new IllegalArgumentException( "Couldn't find package declaration in source file " + originalJavaSourceFile.toAbsolutePath())); diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/ReplaceFileRule.java b/archunit/src/test/java/com/tngtech/archunit/testutil/ReplaceFileExtension.java similarity index 94% rename from archunit/src/test/java/com/tngtech/archunit/testutil/ReplaceFileRule.java rename to archunit/src/test/java/com/tngtech/archunit/testutil/ReplaceFileExtension.java index cadfd5c209..6b469dafac 100644 --- a/archunit/src/test/java/com/tngtech/archunit/testutil/ReplaceFileRule.java +++ b/archunit/src/test/java/com/tngtech/archunit/testutil/ReplaceFileExtension.java @@ -11,13 +11,14 @@ import java.util.Set; import com.google.common.collect.Lists; -import org.junit.rules.ExternalResource; +import org.junit.jupiter.api.extension.AfterEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; import static com.google.common.base.Preconditions.checkState; import static java.nio.file.StandardOpenOption.APPEND; import static java.nio.file.StandardOpenOption.WRITE; -public class ReplaceFileRule extends ExternalResource { +public class ReplaceFileExtension implements AfterEachCallback { private final File tempDir = TestUtils.newTemporaryFolder(); private final List fileActions = new ArrayList<>(); @@ -69,7 +70,7 @@ private void addMoveAction(MoveAction moveAction) { } @Override - protected void after() { + public void afterEach(ExtensionContext context) { for (FileAction action : Lists.reverse(fileActions)) { action.revert(); } diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/SystemPropertiesExtension.java b/archunit/src/test/java/com/tngtech/archunit/testutil/SystemPropertiesExtension.java new file mode 100644 index 0000000000..db147f6f38 --- /dev/null +++ b/archunit/src/test/java/com/tngtech/archunit/testutil/SystemPropertiesExtension.java @@ -0,0 +1,21 @@ +package com.tngtech.archunit.testutil; + +import java.util.Properties; + +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.AfterEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; + +public class SystemPropertiesExtension implements BeforeEachCallback, AfterEachCallback { + private Properties properties; + + @Override + public void beforeEach(ExtensionContext context) { + properties = (Properties) System.getProperties().clone(); + } + + @Override + public void afterEach(ExtensionContext context) { + System.setProperties(properties); + } +} diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/SystemPropertiesRule.java b/archunit/src/test/java/com/tngtech/archunit/testutil/SystemPropertiesRule.java index 1ee5b6d29b..cdd0cda099 100644 --- a/archunit/src/test/java/com/tngtech/archunit/testutil/SystemPropertiesRule.java +++ b/archunit/src/test/java/com/tngtech/archunit/testutil/SystemPropertiesRule.java @@ -4,6 +4,9 @@ import org.junit.rules.ExternalResource; +/** + * @deprecated use JUnit 5 and {@link SystemPropertiesExtension} instead + */ public class SystemPropertiesRule extends ExternalResource { private Properties properties; From 84f6d3d0dafff73ed86934719743633ba88e9a1c Mon Sep 17 00:00:00 2001 From: Manfred Hanke Date: Sun, 5 Jul 2026 20:44:44 +0200 Subject: [PATCH 08/11] migrate archunit-junit's junit-dataprovider test to junit-jupiter-params Signed-off-by: Manfred Hanke --- archunit-junit/build.gradle | 2 +- .../junit/internal/ClassCacheTest.java | 36 ++++++++----------- .../testutil/ArchConfigurationExtension.java | 3 +- 3 files changed, 18 insertions(+), 23 deletions(-) diff --git a/archunit-junit/build.gradle b/archunit-junit/build.gradle index 97b776e414..3fcb0522d9 100644 --- a/archunit-junit/build.gradle +++ b/archunit-junit/build.gradle @@ -39,8 +39,8 @@ dependencies { dependency.addGuava { dependencyNotation, config -> implementation(dependencyNotation, config) } testImplementation libs.junit4 - testImplementation libs.junitDataprovider testImplementation libs.mockito + testImplementation libs.mockito.junit5 testImplementation libs.assertj testImplementation project(path: ':archunit', configuration: 'tests') diff --git a/archunit-junit/src/test/java/com/tngtech/archunit/junit/internal/ClassCacheTest.java b/archunit-junit/src/test/java/com/tngtech/archunit/junit/internal/ClassCacheTest.java index eb1cb5b6e5..77ac8fd184 100644 --- a/archunit-junit/src/test/java/com/tngtech/archunit/junit/internal/ClassCacheTest.java +++ b/archunit-junit/src/test/java/com/tngtech/archunit/junit/internal/ClassCacheTest.java @@ -3,6 +3,7 @@ import java.util.Collection; import java.util.Collections; import java.util.Set; +import java.util.stream.Stream; import com.tngtech.archunit.core.domain.JavaClass; import com.tngtech.archunit.core.domain.JavaClasses; @@ -12,24 +13,22 @@ import com.tngtech.archunit.core.importer.Locations; import com.tngtech.archunit.junit.LocationProvider; import com.tngtech.archunit.junit.internal.ClassCache.CacheClassFileImporter; -import com.tngtech.archunit.testutil.ArchConfigurationRule; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; +import com.tngtech.archunit.testutil.ArchConfigurationExtension; import org.assertj.core.api.Condition; import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; import org.mockito.Spy; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; import static com.tngtech.archunit.junit.CacheMode.PER_CLASS; import static com.tngtech.archunit.testutil.Assertions.assertThatTypes; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.mockito.ArgumentMatchers.anyCollection; @@ -39,15 +38,11 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoMoreInteractions; -@RunWith(DataProviderRunner.class) +@ExtendWith(MockitoExtension.class) public class ClassCacheTest { - @Rule - public final MockitoRule mockitoRule = MockitoJUnit.rule(); - - @Rule - public final ArchConfigurationRule archConfigurationRule = new ArchConfigurationRule() - .resolveAdditionalDependenciesFromClassPath(false); + @RegisterExtension + public final ArchConfigurationExtension archConfigurationRule = new ArchConfigurationExtension().resolveAdditionalDependenciesFromClassPath(false); @Spy private CacheClassFileImporter cacheClassFileImporter; @@ -186,15 +181,14 @@ public void non_existing_packages_are_ignored() { verifyNumberOfImports(1); } - @DataProvider - public static Object[][] test_classes_without_any_imported_classes() { - return testForEach( + static Stream test_classes_without_any_imported_classes() { + return Stream.of( new TestAnalysisRequest().withPackages("does.not.exist"), new TestAnalysisRequest().withLocationProviders(EmptyLocations.class)); } - @Test - @UseDataProvider("test_classes_without_any_imported_classes") + @ParameterizedTest + @MethodSource("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); diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/ArchConfigurationExtension.java b/archunit/src/test/java/com/tngtech/archunit/testutil/ArchConfigurationExtension.java index c6495b156b..236a0f0dbb 100644 --- a/archunit/src/test/java/com/tngtech/archunit/testutil/ArchConfigurationExtension.java +++ b/archunit/src/test/java/com/tngtech/archunit/testutil/ArchConfigurationExtension.java @@ -16,8 +16,9 @@ public class ArchConfigurationExtension implements Extension, BeforeEachCallback private boolean beforeHasBeenExecuted = false; private final List configurationInitializers = new ArrayList<>(); - public void resolveAdditionalDependenciesFromClassPath(boolean enabled) { + public ArchConfigurationExtension resolveAdditionalDependenciesFromClassPath(boolean enabled) { addConfigurationInitializer(() -> ArchConfiguration.get().setResolveMissingDependenciesFromClassPath(enabled)); + return this; } public ArchConfigurationExtension setFailOnEmptyShould(boolean failOnEmptyShould) { From 3d5a627c9157b2c5cc7bfa9e9fff5151bfab1b60 Mon Sep 17 00:00:00 2001 From: Manfred Hanke Date: Mon, 6 Jul 2026 08:48:01 +0200 Subject: [PATCH 09/11] migrate archunit-3rd-party-test's junit-dataprovider test to junit-jupiter-params Signed-off-by: Manfred Hanke --- archunit-3rd-party-test/build.gradle | 2 -- .../core/importer/SpringLocationsTest.java | 26 +++++++------------ 2 files changed, 10 insertions(+), 18 deletions(-) diff --git a/archunit-3rd-party-test/build.gradle b/archunit-3rd-party-test/build.gradle index 825728ae04..24c9e65be1 100644 --- a/archunit-3rd-party-test/build.gradle +++ b/archunit-3rd-party-test/build.gradle @@ -10,7 +10,5 @@ dependencies { testImplementation project(path: ':archunit', configuration: 'tests') testImplementation exampleLibs.springBootLoader dependency.addGuava { dependencyNotation, config -> testImplementation(dependencyNotation, config) } - testImplementation libs.junit4 - testImplementation libs.junitDataprovider testImplementation libs.assertj } diff --git a/archunit-3rd-party-test/src/test/java/com/tngtech/archunit/core/importer/SpringLocationsTest.java b/archunit-3rd-party-test/src/test/java/com/tngtech/archunit/core/importer/SpringLocationsTest.java index bcdc624d47..1c4b69407e 100644 --- a/archunit-3rd-party-test/src/test/java/com/tngtech/archunit/core/importer/SpringLocationsTest.java +++ b/archunit-3rd-party-test/src/test/java/com/tngtech/archunit/core/importer/SpringLocationsTest.java @@ -10,13 +10,10 @@ import java.util.stream.Stream; import com.tngtech.archunit.core.importer.testexamples.SomeEnum; -import com.tngtech.archunit.testutil.SystemPropertiesRule; -import com.tngtech.java.junit.dataprovider.DataProvider; -import com.tngtech.java.junit.dataprovider.DataProviderRunner; -import com.tngtech.java.junit.dataprovider.UseDataProvider; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; +import com.tngtech.archunit.testutil.SystemPropertiesExtension; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import org.springframework.boot.loader.LaunchedURLClassLoader; import org.springframework.boot.loader.archive.Archive; import org.springframework.boot.loader.archive.JarFileArchive; @@ -28,31 +25,28 @@ import static com.tngtech.archunit.core.importer.LocationTest.classFileEntry; import static com.tngtech.archunit.core.importer.LocationTest.urlOfClass; import static com.tngtech.archunit.core.importer.LocationsTest.unchecked; -import static com.tngtech.java.junit.dataprovider.DataProviders.testForEach; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(DataProviderRunner.class) public class SpringLocationsTest { /** * Spring Boot configures some system properties that we want to reset afterward (e.g. custom URL stream handler) */ - @Rule - public final SystemPropertiesRule systemPropertiesRule = new SystemPropertiesRule(); + @RegisterExtension + final SystemPropertiesExtension systemPropertiesExtension = new SystemPropertiesExtension(); - @DataProvider - public static Object[][] springBootJars() { + static Stream springBootJars() { Function, TestJarFile> createSpringBootJar = setUpJarFile -> setUpJarFile.apply(new TestJarFile()) .withNestedClassFilesDirectory("BOOT-INF/classes") .withEntry(classFileEntry(SomeEnum.class).toAbsolutePath()); - return testForEach( + return Stream.of( createSpringBootJar.apply(TestJarFile::withDirectoryEntries), createSpringBootJar.apply(TestJarFile::withoutDirectoryEntries) ); } - @Test - @UseDataProvider("springBootJars") + @ParameterizedTest + @MethodSource("springBootJars") public void finds_locations_of_packages_from_Spring_Boot_ClassLoader_for_JARs(TestJarFile jarFileToTest) throws Exception { try (JarFile jarFile = jarFileToTest.create()) { From 7d8c067bfad58f6a72c522a1d76c8a2a37496d1c Mon Sep 17 00:00:00 2001 From: Manfred Hanke Date: Mon, 6 Jul 2026 08:55:41 +0200 Subject: [PATCH 10/11] remove junit-dataprovider dependency Signed-off-by: Manfred Hanke --- archunit/build.gradle | 1 - .../com/tngtech/archunit/core/importer/LocationsTest.java | 5 +---- gradle/libs.versions.toml | 1 - 3 files changed, 1 insertion(+), 6 deletions(-) diff --git a/archunit/build.gradle b/archunit/build.gradle index d57cea608a..6d303f8c1c 100644 --- a/archunit/build.gradle +++ b/archunit/build.gradle @@ -13,7 +13,6 @@ dependencies { testImplementation libs.log4j.api testImplementation libs.log4j.core testImplementation libs.junit4 - testImplementation libs.junitDataprovider testImplementation libs.mockito testImplementation libs.mockito.junit5 testImplementation libs.assertj diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/LocationsTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/LocationsTest.java index 8d6dcfe759..0f17ac7f74 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/LocationsTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/LocationsTest.java @@ -15,7 +15,6 @@ import com.google.common.collect.ImmutableList; import com.tngtech.archunit.core.importer.testexamples.SomeEnum; -import com.tngtech.java.junit.dataprovider.DataProvider; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -137,8 +136,7 @@ public void locations_of_packages_from_mixed_URIs() { Set locations = Locations.ofPackage("com.tngtech"); assertThat(urisOf(locations)).contains( - resolvedUri(getClass(), "/com/tngtech"), - resolvedUri(DataProvider.class, "/com/tngtech") + resolvedUri(getClass(), "/com/tngtech") ); } @@ -160,7 +158,6 @@ public void locations_of_class_from_JAR_URI() throws Exception { public void locations_in_classpath() throws Exception { assertThat(urisOf(Locations.inClassPath())).contains( getClass().getResource("/").toURI(), - resolvedUri(DataProvider.class, "/"), resolvedUri(org.junit.Test.class, "/") ); } diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index b57da6b48d..e3fb9b525e 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -19,7 +19,6 @@ junit5PlatformCommons = { group = "org.junit.platform", name = "junit-platform-c junit5PlatformEngine = { group = "org.junit.platform", name = "junit-platform-engine", version.ref = "junit5Platform" } junit5PlatformLauncher = { group = "org.junit.platform", name = "junit-platform-launcher", version.ref = "junit5Platform" } hamcrest = { group = "org.hamcrest", name = "hamcrest-core", version = "1.3" } -junitDataprovider = { group = "com.tngtech.java", name = "junit-dataprovider", version = "1.11.0" } mockito = { group = "org.mockito", name = "mockito-core", version = "4.11.0" } # mockito 5 requires Java 11 mockito_junit5 = { group = "org.mockito", name = "mockito-junit-jupiter", version = "4.11.0" } assertj = { group = "org.assertj", name = "assertj-core", version.ref = "assertj" } From ca4035cef1d3a34c4e225862338cda1a1db18b4a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stefan=20Gr=C3=A4ber?= Date: Fri, 10 Jul 2026 14:50:04 +0200 Subject: [PATCH 11/11] replace DataProviders.$ with Arguments.arguments MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Stefan Gräber --- .../ClassesShouldNewerJavaVersionTest.java | 10 +- .../archunit/core/domain/DependencyTest.java | 16 +- .../archunit/core/domain/FormattersTest.java | 24 +- .../core/domain/JavaClassDescriptorTest.java | 10 +- .../archunit/core/domain/JavaClassTest.java | 20 +- .../domain/JavaParameterizedTypeTest.java | 4 +- .../archunit/core/domain/SourceTest.java | 24 +- ...ssFileImporterAutomaticResolutionTest.java | 48 +- ...assFileImporterCodeUnitReferencesTest.java | 14 +- .../ClassFileImporterGenericClassesTest.java | 10 +- ...rterGenericCodeUnitParameterTypesTest.java | 6 +- ...assFileImporterLambdaDependenciesTest.java | 12 +- .../core/importer/ClassFileSourceTest.java | 12 +- .../core/importer/ImportOptionsTest.java | 6 +- .../importer/NormalizedResourceNameTest.java | 44 +- .../ClassResolverFromClassPathTest.java | 6 +- .../archunit/lang/CompositeArchRuleTest.java | 10 +- .../lang/syntax/TransformersTest.java | 12 +- .../syntax/elements/ClassesShouldTest.java | 457 ++++++++---------- .../syntax/elements/CodeUnitsShouldTest.java | 178 ++++--- .../syntax/elements/FieldsShouldTest.java | 22 +- .../syntax/elements/GivenClassShouldTest.java | 382 ++++++++------- .../syntax/elements/GivenCodeUnitsTest.java | 110 ++--- .../lang/syntax/elements/GivenFieldsTest.java | 24 +- .../syntax/elements/GivenMembersTest.java | 333 ++++++------- .../syntax/elements/GivenMethodsTest.java | 14 +- .../syntax/elements/MembersShouldTest.java | 440 ++++++++--------- .../syntax/elements/MethodsShouldTest.java | 14 +- .../archunit/library/ProxyRulesTest.java | 10 +- .../library/dependencies/SliceRuleTest.java | 10 +- .../dependencies/SlicesShouldTest.java | 6 +- .../library/metrics/LakosMetricsTest.java | 28 +- .../library/modules/ArchModuleTest.java | 6 +- .../archunit/testutil/DataProviders.java | 9 - .../testutil/syntax/RandomSyntaxTestBase.java | 4 +- 35 files changed, 1134 insertions(+), 1201 deletions(-) delete mode 100644 archunit/src/test/java/com/tngtech/archunit/testutil/DataProviders.java diff --git a/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldNewerJavaVersionTest.java b/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldNewerJavaVersionTest.java index 03058e27c2..10088c4e29 100644 --- a/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldNewerJavaVersionTest.java +++ b/archunit/src/jdk16test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldNewerJavaVersionTest.java @@ -15,15 +15,15 @@ import static com.tngtech.archunit.lang.syntax.elements.ClassesShouldTest.locationPattern; import static com.tngtech.archunit.lang.syntax.elements.ClassesShouldTest.singleLineFailureReportOf; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.regex.Pattern.quote; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class ClassesShouldNewerJavaVersionTest { static Stream be_records() { return Stream.of( - $(classes().should().beRecords(), SomeRecord.class, String.class), - $(classes().should(ArchConditions.beRecords()), SomeRecord.class, String.class)); + arguments(classes().should().beRecords(), SomeRecord.class, String.class), + arguments(classes().should(ArchConditions.beRecords()), SomeRecord.class, String.class)); } @ParameterizedTest @@ -41,8 +41,8 @@ void be_records(ArchRule rule, Class satisfied, Class violated) { static Stream not_be_records() { return Stream.of( - $(classes().should().notBeRecords(), String.class, SomeRecord.class), - $(classes().should(ArchConditions.notBeRecords()), String.class, SomeRecord.class)); + arguments(classes().should().notBeRecords(), String.class, SomeRecord.class), + arguments(classes().should(ArchConditions.notBeRecords()), String.class, SomeRecord.class)); } @ParameterizedTest diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/DependencyTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/DependencyTest.java index 3181d85be2..694420d68d 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/DependencyTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/DependencyTest.java @@ -41,8 +41,8 @@ import static com.tngtech.archunit.testutil.Assertions.assertThatConversionOf; import static com.tngtech.archunit.testutil.Assertions.assertThatDependencies; import static com.tngtech.archunit.testutil.Assertions.assertThatType; -import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.assertion.DependenciesAssertion.from; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class DependencyTest { @@ -131,8 +131,8 @@ void dependency_from_access(JavaAccess access) { static Stream method_calls_to_array_types() { return Stream.of( - $(ClassWithArrayDependencies.class, "oneDimArray", String[].class, 6), - $(ClassWithArrayDependencies.class, "multiDimArray", String[][].class, 10) + arguments(ClassWithArrayDependencies.class, "oneDimArray", String[].class, 6), + arguments(ClassWithArrayDependencies.class, "multiDimArray", String[][].class, 10) ); } @@ -199,9 +199,9 @@ static Stream with_instanceof_check_members() { .get(ClassWithDependencyOnInstanceofCheck.class); return Stream.of( - $(javaClass.getStaticInitializer().get(), 6), - $(javaClass.getConstructor(Object.class), 9), - $(javaClass.getMethod("method", Object.class), 13)); + arguments(javaClass.getStaticInitializer().get(), 6), + arguments(javaClass.getConstructor(Object.class), 9), + arguments(javaClass.getMethod("method", Object.class), 13)); } @ParameterizedTest @@ -494,8 +494,8 @@ void genericTypeOnMethod(SomeGenericType param) { .get(GenericTypeOnMethod.class).getMethod("genericTypeOnMethod", SomeGenericType.class); String expectedGenericParameterTypeName = SomeGenericType.class.getName() + "<" + String.class.getName() + ">"; return Stream.of( - $(constructor, expectedGenericParameterTypeName), - $(method, expectedGenericParameterTypeName)); + arguments(constructor, expectedGenericParameterTypeName), + arguments(method, expectedGenericParameterTypeName)); } @ParameterizedTest diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/FormattersTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/FormattersTest.java index de3ab1a213..aa4379f029 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/FormattersTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/FormattersTest.java @@ -21,12 +21,12 @@ import static com.google.common.primitives.Primitives.allPrimitiveTypes; import static com.tngtech.archunit.core.domain.Formatters.joinSingleQuoted; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.Arrays.stream; import static java.util.Collections.emptyList; import static java.util.Collections.singleton; import static java.util.stream.Collectors.toList; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class FormattersTest { @@ -81,10 +81,10 @@ class SomeClass { } return ImmutableList.builder() - .add($("", "")) - .add($(SomeClass.class.getSimpleName(), SomeClass.class.getSimpleName())) + .add(arguments("", "")) + .add(arguments(SomeClass.class.getSimpleName(), SomeClass.class.getSimpleName())) .addAll(generateCanonicalNameTestCases(union(ImmutableSet.of(String.class, SomeClass.class), allRelevantPrimitiveTypes()))) - .add($("[[Lorg.example.Some$Inner;", "org.example.Some$Inner[][]")) + .add(arguments("[[Lorg.example.Some$Inner;", "org.example.Some$Inner[][]")) .build(); } @@ -95,13 +95,13 @@ private static Set> allRelevantPrimitiveTypes() { private static List generateCanonicalNameTestCases(Iterable> classes) { List result = new ArrayList<>(); for (Class componentType : classes) { - result.add($(componentType.getName(), componentType.getName())); + result.add(arguments(componentType.getName(), componentType.getName())); Class oneDim = Array.newInstance(componentType, 0).getClass(); - result.add($(oneDim.getName(), componentType.getName() + "[]")); + result.add(arguments(oneDim.getName(), componentType.getName() + "[]")); Class twoDim = Array.newInstance(oneDim, 0).getClass(); - result.add($(twoDim.getName(), componentType.getName() + "[][]")); + result.add(arguments(twoDim.getName(), componentType.getName() + "[][]")); } return result; } @@ -114,11 +114,11 @@ void ensureCanonicalArrayTypeName(String input, String expected) { static Stream test_joinSingleQuoted() { return Stream.of( - $(new String[0], ""), - $(new String[]{"one"}, "'one'"), - $(new String[]{"one", "two"}, "'one', 'two'"), - $(new String[]{"one", "two", "three"}, "'one', 'two', 'three'"), - $(new String[]{"", ""}, "'', ''") + arguments(new String[0], ""), + arguments(new String[]{"one"}, "'one'"), + arguments(new String[]{"one", "two"}, "'one', 'two'"), + arguments(new String[]{"one", "two", "three"}, "'one', 'two', 'three'"), + arguments(new String[]{"", ""}, "'', ''") ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassDescriptorTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassDescriptorTest.java index 6caff16270..1ae268402a 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassDescriptorTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassDescriptorTest.java @@ -12,8 +12,8 @@ import org.objectweb.asm.Type; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class JavaClassDescriptorTest { @@ -156,8 +156,8 @@ public void converts_descriptor_repeatedly_multi_dim_array_descriptor() { private static List namesToPrimitive(Class primitiveType) { return ImmutableList.of( - $(primitiveType.getName(), primitiveType), - $(Type.getType(primitiveType).getDescriptor(), primitiveType)); + arguments(primitiveType.getName(), primitiveType), + arguments(Type.getType(primitiveType).getDescriptor(), primitiveType)); } static List arrays() { @@ -185,7 +185,7 @@ static List arrays() { private static List namesToArray(Class arrayType) { return ImmutableList.of( - $(arrayType.getName(), arrayType), - $(arrayType.getCanonicalName(), arrayType)); + arguments(arrayType.getName(), arrayType), + arguments(arrayType.getCanonicalName(), arrayType)); } } diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassTest.java index cda8ed5fcc..52f9064600 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassTest.java @@ -97,7 +97,6 @@ import static com.tngtech.archunit.testutil.Assertions.assertThatTypes; import static com.tngtech.archunit.testutil.Conditions.codeUnitWithSignature; import static com.tngtech.archunit.testutil.Conditions.containing; -import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.ReflectionTestUtils.getHierarchy; import static com.tngtech.archunit.testutil.assertion.DependenciesAssertion.from; import static java.lang.annotation.RetentionPolicy.RUNTIME; @@ -106,6 +105,7 @@ import static java.util.stream.Collectors.toSet; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.jupiter.api.Assertions.fail; +import static org.junit.jupiter.params.provider.Arguments.arguments; @SuppressWarnings("SameParameterValue") public class JavaClassTest { @@ -193,13 +193,13 @@ class InnerPackagePrivateClassArray { SomePackagePrivateClass[] array; } return Stream.of( - $(PublicClassArray.class, String[].class), - $(PublicClassMultiDimArray.class, String[][].class), - $(PrimitiveClassArray.class, int[].class), - $(LocalClassArray.class, LocalClass[].class), - $(PrivateClassArray.class, SomePrivateClass[].class), - $(ProtectedClassArray.class, SomeProtectedClass[].class), - $(InnerPackagePrivateClassArray.class, SomePackagePrivateClass[].class) + arguments(PublicClassArray.class, String[].class), + arguments(PublicClassMultiDimArray.class, String[][].class), + arguments(PrimitiveClassArray.class, int[].class), + arguments(LocalClassArray.class, LocalClass[].class), + arguments(PrivateClassArray.class, SomePrivateClass[].class), + arguments(ProtectedClassArray.class, SomeProtectedClass[].class), + arguments(InnerPackagePrivateClassArray.class, SomePackagePrivateClass[].class) ); } @@ -1503,12 +1503,12 @@ > void secondDependingOnOtherThroughMethodTypeParameter() { SecondDependingOnOtherThroughMethodTypeParameter.class ); return Stream.of( - $( + arguments( dependenciesThroughConstructorTypeParameters.get(FirstDependingOnOtherThroughConstructorTypeParameter.class), dependenciesThroughConstructorTypeParameters.get(SecondDependingOnOtherThroughConstructorTypeParameter.class), dependenciesThroughConstructorTypeParameters.get(ClassOtherConstructorTypeSignaturesDependOn.class) ), - $( + arguments( dependenciesThroughMethodTypeParameters.get(FirstDependingOnOtherThroughMethodTypeParameter.class), dependenciesThroughMethodTypeParameters.get(SecondDependingOnOtherThroughMethodTypeParameter.class), dependenciesThroughMethodTypeParameters.get(ClassOtherMethodTypeSignaturesDependOn.class) diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaParameterizedTypeTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaParameterizedTypeTest.java index 388d22e87f..e8a432c882 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaParameterizedTypeTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaParameterizedTypeTest.java @@ -12,8 +12,8 @@ import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; -import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class JavaParameterizedTypeTest { @@ -52,7 +52,7 @@ private static Arguments createTestInput(Class testClass) { .map(v -> v.getBounds().get(0)) .findFirst().get(); - return $(javaType, reflectionType); + return arguments(javaType, reflectionType); } @ParameterizedTest diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/SourceTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/SourceTest.java index 0542ed69f5..165004cb27 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/domain/SourceTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/domain/SourceTest.java @@ -26,11 +26,11 @@ import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.TestUtils.uriOf; import static com.tngtech.archunit.testutil.TestUtils.urlOf; import static java.nio.charset.StandardCharsets.UTF_8; import static java.util.stream.Collectors.toList; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class SourceTest { @AfterEach @@ -49,13 +49,13 @@ public void source_file_name() { static Stream expectedHexCodes() { return Stream.of( - $(new byte[]{0}, "00"), - $(new byte[]{15}, "0f"), - $(new byte[]{16}, "10"), - $(new byte[]{31}, "1f"), - $(new byte[]{32}, "20"), - $(new byte[]{(byte) 255}, "ff"), - $(new byte[]{(byte) 128, 37, 45, 22, 99}, "80252d1663") + arguments(new byte[]{0}, "00"), + arguments(new byte[]{15}, "0f"), + arguments(new byte[]{16}, "10"), + arguments(new byte[]{31}, "1f"), + arguments(new byte[]{32}, "20"), + arguments(new byte[]{(byte) 255}, "ff"), + arguments(new byte[]{(byte) 128, 37, 45, 22, 99}, "80252d1663") ); } @@ -93,9 +93,9 @@ void equals_hashcode_and_toString(URL url) throws Exception { static Stream equalMd5Sums() { return Stream.of( - $(Md5sum.UNDETERMINED, Md5sum.UNDETERMINED), - $(Md5sum.NOT_SUPPORTED, Md5sum.NOT_SUPPORTED), - $(md5sumOf("anything"), md5sumOf("anything"))); + arguments(Md5sum.UNDETERMINED, Md5sum.UNDETERMINED), + arguments(Md5sum.NOT_SUPPORTED, Md5sum.NOT_SUPPORTED), + arguments(md5sumOf("anything"), md5sumOf("anything"))); } @ParameterizedTest @@ -126,7 +126,7 @@ private static List createUnequalTestCasesFor(Md5sum... md5sums) { private static List zip(List first, List second) { return IntStream.range(0, first.size()) - .mapToObj(i -> $(first.get(i), second.get(i))) + .mapToObj(i -> arguments(first.get(i), second.get(i))) .collect(toList()); } diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAutomaticResolutionTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAutomaticResolutionTest.java index 9e7c720d24..973c0008bc 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAutomaticResolutionTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterAutomaticResolutionTest.java @@ -67,8 +67,8 @@ import static com.tngtech.archunit.testutil.Assertions.assertThat; import static com.tngtech.archunit.testutil.Assertions.assertThatAnnotation; import static com.tngtech.archunit.testutil.Assertions.assertThatType; -import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.assertion.JavaAnnotationAssertion.annotationProperty; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class ClassFileImporterAutomaticResolutionTest { @@ -481,9 +481,9 @@ class OnParameter { private static List nestedAnnotationValueTestCases(HasAnnotations hasAnnotations) { return ImmutableList.of( - $(getNestedAnnotationClassValue(hasAnnotations, SomeAnnotationWithClassParameter.class), expect(String.class)), - $(getNestedAnnotationClassValue(hasAnnotations, SomeAnnotationWithAnnotationParameter.class), expect(File.class)), - $(getNestedAnnotationClassValue(hasAnnotations, AnotherAnnotationWithAnnotationParameter.class), expect(Serializable.class)) + arguments(getNestedAnnotationClassValue(hasAnnotations, SomeAnnotationWithClassParameter.class), expect(String.class)), + arguments(getNestedAnnotationClassValue(hasAnnotations, SomeAnnotationWithAnnotationParameter.class), expect(File.class)), + arguments(getNestedAnnotationClassValue(hasAnnotations, AnotherAnnotationWithAnnotationParameter.class), expect(Serializable.class)) ); } @@ -662,16 +662,16 @@ class TypeArgumentWithInterfaceBoundOnConstructor { } return Stream.of( - $(importFirstTypeParameterClassBound(TypeParameterOnClassWithClassBound.class), String.class), - $(importFirstTypeParameterClassBound(TypeParameterOnClassWithInterfaceBound.class), Serializable.class), - $(importFirstTypeParameterMethodBound(TypeParameterOnMethodWithClassBound.class), String.class), - $(importFirstTypeParameterMethodBound(TypeParameterOnMethodWithInterfaceBound.class), Serializable.class), - $(importFirstTypeArgumentFieldBound(TypeArgumentWithClassBoundOnField.class), String.class), - $(importFirstTypeArgumentFieldBound(TypeArgumentWithInterfaceBoundOnField.class), Serializable.class), - $(importFirstTypeArgumentMethodParameterBound(TypeArgumentWithClassBoundOnMethod.class), String.class), - $(importFirstTypeArgumentMethodParameterBound(TypeArgumentWithInterfaceBoundOnMethod.class), Serializable.class), - $(importFirstTypeArgumentConstructorParameterBound(TypeArgumentWithClassBoundOnConstructor.class), String.class), - $(importFirstTypeArgumentConstructorParameterBound(TypeArgumentWithInterfaceBoundOnConstructor.class), Serializable.class) + arguments(importFirstTypeParameterClassBound(TypeParameterOnClassWithClassBound.class), String.class), + arguments(importFirstTypeParameterClassBound(TypeParameterOnClassWithInterfaceBound.class), Serializable.class), + arguments(importFirstTypeParameterMethodBound(TypeParameterOnMethodWithClassBound.class), String.class), + arguments(importFirstTypeParameterMethodBound(TypeParameterOnMethodWithInterfaceBound.class), Serializable.class), + arguments(importFirstTypeArgumentFieldBound(TypeArgumentWithClassBoundOnField.class), String.class), + arguments(importFirstTypeArgumentFieldBound(TypeArgumentWithInterfaceBoundOnField.class), Serializable.class), + arguments(importFirstTypeArgumentMethodParameterBound(TypeArgumentWithClassBoundOnMethod.class), String.class), + arguments(importFirstTypeArgumentMethodParameterBound(TypeArgumentWithInterfaceBoundOnMethod.class), Serializable.class), + arguments(importFirstTypeArgumentConstructorParameterBound(TypeArgumentWithClassBoundOnConstructor.class), String.class), + arguments(importFirstTypeArgumentConstructorParameterBound(TypeArgumentWithInterfaceBoundOnConstructor.class), Serializable.class) ); } @@ -729,16 +729,16 @@ class ClassTypeArgumentBoundsOnConstructor { } return Stream.of( - $(importFirstTypeParameterClassBound(InterfaceTypeParameterBoundsOnClass.class), List.class, Map.class, Serializable.class), - $(importFirstTypeParameterClassBound(ClassTypeParameterBoundsOnClass.class), ArrayList.class, HashMap.class, String.class), - $(importFirstTypeParameterMethodBound(InterfaceTypeParameterBoundsOnMethod.class), List.class, Map.class, Serializable.class), - $(importFirstTypeParameterMethodBound(ClassTypeParameterBoundsOnMethod.class), ArrayList.class, HashMap.class, String.class), - $(importFirstTypeArgumentFieldBound(InterfaceTypeArgumentBoundsOnField.class), List.class, Map.class, Serializable.class), - $(importFirstTypeArgumentFieldBound(ClassTypeArgumentBoundsOnField.class), ArrayList.class, HashMap.class, String.class), - $(importFirstTypeArgumentMethodParameterBound(InterfaceTypeArgumentBoundsOnMethod.class), List.class, Map.class, Serializable.class), - $(importFirstTypeArgumentMethodParameterBound(ClassTypeArgumentBoundsOnMethod.class), ArrayList.class, HashMap.class, String.class), - $(importFirstTypeArgumentConstructorParameterBound(InterfaceTypeArgumentBoundsOnConstructor.class), List.class, Map.class, Serializable.class), - $(importFirstTypeArgumentConstructorParameterBound(ClassTypeArgumentBoundsOnConstructor.class), ArrayList.class, HashMap.class, String.class) + arguments(importFirstTypeParameterClassBound(InterfaceTypeParameterBoundsOnClass.class), List.class, Map.class, Serializable.class), + arguments(importFirstTypeParameterClassBound(ClassTypeParameterBoundsOnClass.class), ArrayList.class, HashMap.class, String.class), + arguments(importFirstTypeParameterMethodBound(InterfaceTypeParameterBoundsOnMethod.class), List.class, Map.class, Serializable.class), + arguments(importFirstTypeParameterMethodBound(ClassTypeParameterBoundsOnMethod.class), ArrayList.class, HashMap.class, String.class), + arguments(importFirstTypeArgumentFieldBound(InterfaceTypeArgumentBoundsOnField.class), List.class, Map.class, Serializable.class), + arguments(importFirstTypeArgumentFieldBound(ClassTypeArgumentBoundsOnField.class), ArrayList.class, HashMap.class, String.class), + arguments(importFirstTypeArgumentMethodParameterBound(InterfaceTypeArgumentBoundsOnMethod.class), List.class, Map.class, Serializable.class), + arguments(importFirstTypeArgumentMethodParameterBound(ClassTypeArgumentBoundsOnMethod.class), ArrayList.class, HashMap.class, String.class), + arguments(importFirstTypeArgumentConstructorParameterBound(InterfaceTypeArgumentBoundsOnConstructor.class), List.class, Map.class, Serializable.class), + arguments(importFirstTypeArgumentConstructorParameterBound(ClassTypeArgumentBoundsOnConstructor.class), ArrayList.class, HashMap.class, String.class) ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterCodeUnitReferencesTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterCodeUnitReferencesTest.java index a460d5b220..016bac933a 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterCodeUnitReferencesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterCodeUnitReferencesTest.java @@ -19,8 +19,8 @@ import static com.google.common.collect.Iterables.getOnlyElement; import static com.tngtech.archunit.testutil.Assertions.assertThatAccess; -import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class ClassFileImporterCodeUnitReferencesTest { @@ -51,11 +51,11 @@ void accessesStaticMethodReference() { static Stream imports_static_method_references() { return Stream.of( - $( + arguments( Data_imports_static_method_references.OriginReferencingInterface.class, Data_imports_static_method_references.ReferencedInterfaceTarget.class ), - $( + arguments( Data_imports_static_method_references.OriginReferencingClass.class, Data_imports_static_method_references.ReferencedClassTarget.class )); @@ -107,11 +107,11 @@ void referencesInstanceMethodBoundToInstance() { static Stream imports_instance_method_references_bound_to_instance() { return Stream.of( - $( + arguments( Data_imports_instance_method_references_bound_to_instance.OriginReferencingInterface.class, Data_imports_instance_method_references_bound_to_instance.ReferencedInterfaceTarget.class ), - $( + arguments( Data_imports_instance_method_references_bound_to_instance.OriginReferencingClass.class, Data_imports_instance_method_references_bound_to_instance.ReferencedClassTarget.class )); @@ -159,11 +159,11 @@ void referencesInstanceMethodNotBoundToInstance() { static Stream imports_instance_method_references_not_bound_to_instance() { return Stream.of( - $( + arguments( Data_imports_instance_method_references_not_bound_to_instance.OriginReferencingInterface.class, Data_imports_instance_method_references_not_bound_to_instance.ReferencedInterfaceTarget.class ), - $( + arguments( Data_imports_instance_method_references_not_bound_to_instance.OriginReferencingClass.class, Data_imports_instance_method_references_not_bound_to_instance.ReferencedClassTarget.class )); diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericClassesTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericClassesTest.java index 2ccadf1b36..ad4aef67be 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericClassesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericClassesTest.java @@ -22,7 +22,6 @@ import static com.tngtech.archunit.testutil.ArchConfigurationRule.resetConfigurationAround; import static com.tngtech.archunit.testutil.Assertions.assertThat; import static com.tngtech.archunit.testutil.Assertions.assertThatType; -import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteClass.concreteClass; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteGenericArray.genericArray; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteGenericArray.parameterizedTypeArrayName; @@ -30,6 +29,7 @@ import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteParameterizedType.parameterizedType; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteTypeVariable.typeVariable; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteWildcardType.wildcardType; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class ClassFileImporterGenericClassesTest { @@ -222,8 +222,8 @@ class ClassWithSingleTypeParameterBoundByTypeWithWildcardWithUpperInterfaceBound } return Stream.of( - $(ClassWithSingleTypeParameterBoundByTypeWithWildcardWithUpperClassBound.class, String.class), - $(ClassWithSingleTypeParameterBoundByTypeWithWildcardWithUpperInterfaceBound.class, Serializable.class) + arguments(ClassWithSingleTypeParameterBoundByTypeWithWildcardWithUpperClassBound.class, String.class), + arguments(ClassWithSingleTypeParameterBoundByTypeWithWildcardWithUpperInterfaceBound.class, Serializable.class) ); } @@ -245,8 +245,8 @@ class ClassWithSingleTypeParameterBoundByTypeWithWildcardWithLowerInterfaceBound } return Stream.of( - $(ClassWithSingleTypeParameterBoundByTypeWithWildcardWithLowerClassBound.class, String.class), - $(ClassWithSingleTypeParameterBoundByTypeWithWildcardWithLowerInterfaceBound.class, Serializable.class) + arguments(ClassWithSingleTypeParameterBoundByTypeWithWildcardWithLowerClassBound.class, String.class), + arguments(ClassWithSingleTypeParameterBoundByTypeWithWildcardWithLowerInterfaceBound.class, Serializable.class) ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericCodeUnitParameterTypesTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericCodeUnitParameterTypesTest.java index 693c09e0b7..92f79c7154 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericCodeUnitParameterTypesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterGenericCodeUnitParameterTypesTest.java @@ -26,7 +26,6 @@ import static com.tngtech.archunit.testutil.Assertions.assertThat; import static com.tngtech.archunit.testutil.Assertions.assertThatType; import static com.tngtech.archunit.testutil.Assertions.assertThatTypes; -import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteClass.concreteClass; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteGenericArray.genericArray; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteGenericArray.parameterizedTypeArrayName; @@ -35,6 +34,7 @@ import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteTypeVariable.typeVariable; import static com.tngtech.archunit.testutil.assertion.ExpectedConcreteType.ExpectedConcreteWildcardType.wildcardType; import static java.util.stream.Collectors.toList; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class ClassFileImporterGenericCodeUnitParameterTypesTest { @@ -56,8 +56,8 @@ void method(NonGenericParameterType param) { NoGenericSignatureOnMethod.class ).collect(toList()); return Stream.of( - $(testCases.get(0), NonGenericParameterType.class), - $(testCases.get(1), NonGenericParameterType.class) + arguments(testCases.get(0), NonGenericParameterType.class), + arguments(testCases.get(1), NonGenericParameterType.class) ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterLambdaDependenciesTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterLambdaDependenciesTest.java index 43cb81b98f..69f608aaf9 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterLambdaDependenciesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterLambdaDependenciesTest.java @@ -42,12 +42,12 @@ import static com.tngtech.archunit.testutil.Assertions.assertThatCall; import static com.tngtech.archunit.testutil.Assertions.assertThatInstanceofChecks; import static com.tngtech.archunit.testutil.Assertions.assertThatReferencedClassObjects; -import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.assertion.AccessesAssertion.access; import static com.tngtech.archunit.testutil.assertion.InstanceofChecksAssertion.instanceofCheck; import static com.tngtech.archunit.testutil.assertion.ReferencedClassObjectsAssertion.referencedClassObject; import static com.tngtech.archunit.testutil.assertion.TryCatchBlockAssertion.tryCatchBlock; import static java.util.stream.Collectors.toSet; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class ClassFileImporterLambdaDependenciesTest { @Test @@ -527,11 +527,11 @@ Supplier expected_classes() { return Stream.of( - $(ImmutableSet.of("/one/Foo.class", "/one/Bar.class", "/two/Bar.class"), + arguments(ImmutableSet.of("/one/Foo.class", "/one/Bar.class", "/two/Bar.class"), new ImportOptions(), ImmutableSet.of("/one/Foo.class", "/one/Bar.class", "/two/Bar.class")), - $(ImmutableSet.of("/one/Foo.class", "/one/Bar.class", "/two/Bar.class"), + arguments(ImmutableSet.of("/one/Foo.class", "/one/Bar.class", "/two/Bar.class"), locationContains("/one/"), ImmutableSet.of("/one/Foo.class", "/one/Bar.class")), - $(ImmutableSet.of("/one/Foo.class", "/one/Bar.class", "/two/Bar.class"), + arguments(ImmutableSet.of("/one/Foo.class", "/one/Bar.class", "/two/Bar.class"), locationContains("/two/"), ImmutableSet.of("/two/Bar.class")), - $(ImmutableSet.of("/one/Foo.class", "/one/Bar.class", "/two/Bar.class"), + arguments(ImmutableSet.of("/one/Foo.class", "/one/Bar.class", "/two/Bar.class"), locationContains("Bar"), ImmutableSet.of("/one/Bar.class", "/two/Bar.class")), - $(ImmutableSet.of("/one/Foo.class", "/one/Bar.class", "/two/Bar.class"), + arguments(ImmutableSet.of("/one/Foo.class", "/one/Bar.class", "/two/Bar.class"), locationContains("notthere"), ImmutableSet.of())); } diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/ImportOptionsTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/ImportOptionsTest.java index fc8a954f6d..8e84f89a5a 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/ImportOptionsTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/ImportOptionsTest.java @@ -29,10 +29,10 @@ import static com.tngtech.archunit.core.importer.ImportOption.Predefined.DO_NOT_INCLUDE_TESTS; import static com.tngtech.archunit.core.importer.ImportOption.Predefined.DO_NOT_INCLUDE_TEST_FIXTURES; import static com.tngtech.archunit.core.importer.ImportOption.Predefined.ONLY_INCLUDE_TESTS; -import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.TestUtils.relativeResourceUri; import static java.util.Arrays.stream; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class ImportOptionsTest { @TempDir @@ -95,8 +95,8 @@ static Stream test_location_predicates_and_expected_folder_patterns() List includeMainFolderInput = new ArrayList<>(); List includeTestFolderInput = new ArrayList<>(); for (FolderPattern folderPattern : getFolderPatterns()) { - includeMainFolderInput.add($(folderPattern.folders, folderPattern.isMainFolder)); - includeTestFolderInput.add($(folderPattern.folders, !folderPattern.isMainFolder)); + includeMainFolderInput.add(arguments(folderPattern.folders, folderPattern.isMainFolder)); + includeTestFolderInput.add(arguments(folderPattern.folders, !folderPattern.isMainFolder)); } Stream doNotIncludeTestsDataPoints = crossProduct(do_not_include_tests(), includeMainFolderInput); diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/NormalizedResourceNameTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/NormalizedResourceNameTest.java index 0a18b73f28..2042b146d4 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/NormalizedResourceNameTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/NormalizedResourceNameTest.java @@ -6,23 +6,23 @@ import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; -import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class NormalizedResourceNameTest { static Stream resource_name_starts_with_cases() { return Stream.of( - $("com", "com", true), - $("com/foo", "com", true), - $("/com/", "/com", true), - $("\\com\\foo", "/com/foo", true), - $("com", "bar", false), - $("com", "co", false), - $("co/m", "co", true), - $("co/m", "co/m", true), - $("some/longer/path/more", "some/longer/path", true), - $("some/longer/path/more", "some/longer", true), - $("some/longer/path/more", "some/longer/p", false) + arguments("com", "com", true), + arguments("com/foo", "com", true), + arguments("/com/", "/com", true), + arguments("\\com\\foo", "/com/foo", true), + arguments("com", "bar", false), + arguments("com", "co", false), + arguments("co/m", "co", true), + arguments("co/m", "co/m", true), + arguments("some/longer/path/more", "some/longer/path", true), + arguments("some/longer/path/more", "some/longer", true), + arguments("some/longer/path/more", "some/longer/p", false) ); } @@ -38,11 +38,11 @@ void resource_name_starts_with_other_resource_name( static Stream names_to_absolute_names() { return Stream.of( - $("", "/"), - $("com", "/com/"), - $("com/foo", "/com/foo/"), - $("Some.class", "/Some.class"), - $("com/Some.class", "/com/Some.class") + arguments("", "/"), + arguments("com", "/com/"), + arguments("com/foo", "/com/foo/"), + arguments("Some.class", "/Some.class"), + arguments("com/Some.class", "/com/Some.class") ); } @@ -56,11 +56,11 @@ void creates_absolute_path(String input, String expectedAbsolutePath) { static Stream names_to_entry_names() { return Stream.of( - $("", ""), - $("/com", "com/"), - $("/com/foo", "com/foo/"), - $("Some.class", "Some.class"), - $("/com/Some.class", "com/Some.class") + arguments("", ""), + arguments("/com", "com/"), + arguments("/com/foo", "com/foo/"), + arguments("Some.class", "Some.class"), + arguments("/com/Some.class", "com/Some.class") ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/core/importer/resolvers/ClassResolverFromClassPathTest.java b/archunit/src/test/java/com/tngtech/archunit/core/importer/resolvers/ClassResolverFromClassPathTest.java index 9daed0dd8b..925a3537d9 100644 --- a/archunit/src/test/java/com/tngtech/archunit/core/importer/resolvers/ClassResolverFromClassPathTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/core/importer/resolvers/ClassResolverFromClassPathTest.java @@ -22,8 +22,8 @@ import static com.tngtech.archunit.core.domain.TestUtils.importClassWithContext; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.params.provider.Arguments.arguments; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; @@ -61,8 +61,8 @@ public void is_resilient_if_URI_cant_be_located() { static Stream urls_with_spaces() throws MalformedURLException, URISyntaxException { return Stream.of( - $(new URL("file:/C:/Some Windows/URL with spaces 123/any.jar"), new URI("file:/C:/Some%20Windows/URL%20with%20spaces%20123/any.jar")), - $(new URL("file:/Some Unix/URL with spaces 123/any.jar"), new URI("file:/Some%20Unix/URL%20with%20spaces%20123/any.jar")) + arguments(new URL("file:/C:/Some Windows/URL with spaces 123/any.jar"), new URI("file:/C:/Some%20Windows/URL%20with%20spaces%20123/any.jar")), + arguments(new URL("file:/Some Unix/URL with spaces 123/any.jar"), new URI("file:/Some%20Unix/URL%20with%20spaces%20123/any.jar")) ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/CompositeArchRuleTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/CompositeArchRuleTest.java index 007afa71ee..5f3d5f8327 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/CompositeArchRuleTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/CompositeArchRuleTest.java @@ -19,9 +19,9 @@ import static com.tngtech.archunit.lang.Priority.HIGH; import static com.tngtech.archunit.lang.Priority.MEDIUM; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes; -import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class CompositeArchRuleTest { private static final boolean SATISFIED = true; @@ -32,10 +32,10 @@ public class CompositeArchRuleTest { static Stream rules_to_AND() { return Stream.of( - $(archRuleThatSucceeds(), archRuleThatSucceeds(), SATISFIED), - $(archRuleThatSucceeds(), archRuleThatFails(), UNSATISFIED), - $(archRuleThatFails(), archRuleThatSucceeds(), UNSATISFIED), - $(archRuleThatFails(), archRuleThatFails(), UNSATISFIED) + arguments(archRuleThatSucceeds(), archRuleThatSucceeds(), SATISFIED), + arguments(archRuleThatSucceeds(), archRuleThatFails(), UNSATISFIED), + arguments(archRuleThatFails(), archRuleThatSucceeds(), UNSATISFIED), + arguments(archRuleThatFails(), archRuleThatFails(), UNSATISFIED) ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/TransformersTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/TransformersTest.java index 1c96405373..2f017f01b3 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/TransformersTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/TransformersTest.java @@ -16,10 +16,10 @@ import org.junit.jupiter.params.provider.MethodSource; import static com.tngtech.archunit.core.domain.TestUtils.importClasses; -import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.Arrays.stream; import static java.util.stream.Collectors.toSet; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class TransformersTest { @Test @@ -33,25 +33,25 @@ public void test_classes() { static Stream members_testcases() { return Stream.of( - $(Transformers.members(), + arguments(Transformers.members(), Sets.union( createMemberStrings(ClassWithMembers.class, "field1", "field2", "()", "(java.lang.String)", "method1()", "method2()"), createMemberStrings(AnotherClassWithMembers.class, "field3", "()", "method3()"))), - $(Transformers.fields(), + arguments(Transformers.fields(), Sets.union( createMemberStrings(ClassWithMembers.class, "field1", "field2"), createMemberStrings(AnotherClassWithMembers.class, "field3"))), - $(Transformers.codeUnits(), + arguments(Transformers.codeUnits(), Sets.union( createMemberStrings(ClassWithMembers.class, "()", "(java.lang.String)", "method1()", "method2()"), createMemberStrings(AnotherClassWithMembers.class, "()", "method3()"))), - $(Transformers.methods(), + arguments(Transformers.methods(), Sets.union( createMemberStrings(ClassWithMembers.class, "method1()", "method2()"), createMemberStrings(AnotherClassWithMembers.class, "method3()"))), - $(Transformers.constructors(), + arguments(Transformers.constructors(), Sets.union( createMemberStrings(ClassWithMembers.class, "()", "(java.lang.String)"), createMemberStrings(AnotherClassWithMembers.class, "()"))) diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldTest.java index a0887dc947..c75b5b6177 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ClassesShouldTest.java @@ -72,10 +72,10 @@ import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes; import static com.tngtech.archunit.testutil.Assertions.assertThat; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; -import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.Arrays.stream; import static java.util.regex.Pattern.quote; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class ClassesShouldTest { static final String FAILURE_REPORT_NEWLINE_MARKER = "#"; @@ -85,8 +85,8 @@ public class ClassesShouldTest { static Stream haveFullyQualifiedName_rules() { return Stream.of( - $(classes().should().haveFullyQualifiedName(SomeClass.class.getName())), - $(classes().should(ArchConditions.haveFullyQualifiedName(SomeClass.class.getName()))) + arguments(classes().should().haveFullyQualifiedName(SomeClass.class.getName())), + arguments(classes().should(ArchConditions.haveFullyQualifiedName(SomeClass.class.getName()))) ); } @@ -106,8 +106,8 @@ void haveFullyQualifiedName(ArchRule rule) { static Stream notHaveFullyQualifiedName_rules() { return Stream.of( - $(classes().should().notHaveFullyQualifiedName(WrongNamedClass.class.getName())), - $(classes().should(ArchConditions.notHaveFullyQualifiedName(WrongNamedClass.class.getName()))) + arguments(classes().should().notHaveFullyQualifiedName(WrongNamedClass.class.getName())), + arguments(classes().should(ArchConditions.notHaveFullyQualifiedName(WrongNamedClass.class.getName()))) ); } @@ -125,8 +125,8 @@ void notHaveFullyQualifiedName(ArchRule rule) { static Stream haveSimpleName_rules() { return Stream.of( - $(classes().should().haveSimpleName(SomeClass.class.getSimpleName())), - $(classes().should(ArchConditions.haveSimpleName(SomeClass.class.getSimpleName()))) + arguments(classes().should().haveSimpleName(SomeClass.class.getSimpleName())), + arguments(classes().should(ArchConditions.haveSimpleName(SomeClass.class.getSimpleName()))) ); } @@ -147,8 +147,8 @@ void haveSimpleName(ArchRule rule) { static Stream notHaveSimpleName_rules() { return Stream.of( - $(classes().should().notHaveSimpleName(WrongNamedClass.class.getSimpleName())), - $(classes().should(ArchConditions.notHaveSimpleName(WrongNamedClass.class.getSimpleName()))) + arguments(classes().should().notHaveSimpleName(WrongNamedClass.class.getSimpleName())), + arguments(classes().should(ArchConditions.notHaveSimpleName(WrongNamedClass.class.getSimpleName()))) ); } @@ -170,8 +170,8 @@ void notHaveSimpleName(ArchRule rule) { static Stream haveNameMatching_rules() { String regex = containsPartOfRegex(SomeClass.class.getSimpleName()); return Stream.of( - $(classes().should().haveNameMatching(regex), regex), - $(classes().should(ArchConditions.haveNameMatching(regex)), regex) + arguments(classes().should().haveNameMatching(regex), regex), + arguments(classes().should(ArchConditions.haveNameMatching(regex)), regex) ); } @@ -193,8 +193,8 @@ void haveNameMatching(ArchRule rule, String regex) { static Stream haveNameNotMatching_rules() { String regex = containsPartOfRegex(WrongNamedClass.class.getSimpleName()); return Stream.of( - $(classes().should().haveNameNotMatching(regex), regex), - $(classes().should(ArchConditions.haveNameNotMatching(regex)), regex) + arguments(classes().should().haveNameNotMatching(regex), regex), + arguments(classes().should(ArchConditions.haveNameNotMatching(regex)), regex) ); } @@ -217,8 +217,8 @@ static Stream haveSimpleNameStartingWith_rules() { String simpleName = SomeClass.class.getSimpleName(); String prefix = simpleName.substring(0, simpleName.length() - 1); return Stream.of( - $(classes().should().haveSimpleNameStartingWith(prefix), prefix), - $(classes().should(ArchConditions.haveSimpleNameStartingWith(prefix)), prefix) + arguments(classes().should().haveSimpleNameStartingWith(prefix), prefix), + arguments(classes().should(ArchConditions.haveSimpleNameStartingWith(prefix)), prefix) ); } @@ -241,8 +241,8 @@ static Stream haveSimpleNameNotStartingWith_rules() { String simpleName = WrongNamedClass.class.getSimpleName(); String prefix = simpleName.substring(0, simpleName.length() - 1); return Stream.of( - $(classes().should().haveSimpleNameNotStartingWith(prefix), prefix), - $(classes().should(ArchConditions.haveSimpleNameNotStartingWith(prefix)), prefix) + arguments(classes().should().haveSimpleNameNotStartingWith(prefix), prefix), + arguments(classes().should(ArchConditions.haveSimpleNameNotStartingWith(prefix)), prefix) ); } @@ -265,8 +265,8 @@ static Stream haveSimpleNameContaining_rules() { String simpleName = SomeClass.class.getSimpleName(); String infix = simpleName.substring(1, simpleName.length() - 1); return Stream.of( - $(classes().should().haveSimpleNameContaining(infix), infix), - $(classes().should(ArchConditions.haveSimpleNameContaining(infix)), infix) + arguments(classes().should().haveSimpleNameContaining(infix), infix), + arguments(classes().should(ArchConditions.haveSimpleNameContaining(infix)), infix) ); } @@ -289,8 +289,8 @@ static Stream haveSimpleNameNotContaining_rules() { String simpleName = WrongNamedClass.class.getSimpleName(); String infix = simpleName.substring(1, simpleName.length() - 1); return Stream.of( - $(classes().should().haveSimpleNameNotContaining(infix), infix), - $(classes().should(ArchConditions.haveSimpleNameNotContaining(infix)), infix) + arguments(classes().should().haveSimpleNameNotContaining(infix), infix), + arguments(classes().should(ArchConditions.haveSimpleNameNotContaining(infix)), infix) ); } @@ -313,8 +313,8 @@ static Stream haveSimpleNameEndingWith_rules() { String simpleName = SomeClass.class.getSimpleName(); String suffix = simpleName.substring(1); return Stream.of( - $(classes().should().haveSimpleNameEndingWith(suffix), suffix), - $(classes().should(ArchConditions.haveSimpleNameEndingWith(suffix)), suffix) + arguments(classes().should().haveSimpleNameEndingWith(suffix), suffix), + arguments(classes().should(ArchConditions.haveSimpleNameEndingWith(suffix)), suffix) ); } @@ -337,8 +337,8 @@ static Stream haveSimpleNameNotEndingWith_rules() { String simpleName = WrongNamedClass.class.getSimpleName(); String suffix = simpleName.substring(1); return Stream.of( - $(classes().should().haveSimpleNameNotEndingWith(suffix), suffix), - $(classes().should(ArchConditions.haveSimpleNameNotEndingWith(suffix)), suffix) + arguments(classes().should().haveSimpleNameNotEndingWith(suffix), suffix), + arguments(classes().should(ArchConditions.haveSimpleNameNotEndingWith(suffix)), suffix) ); } @@ -360,8 +360,8 @@ void haveSimpleNameNotEndingWith(ArchRule rule, String suffix) { static Stream resideInAPackage_rules() { String thePackage = ArchRule.class.getPackage().getName(); return Stream.of( - $(classes().should().resideInAPackage(thePackage), thePackage), - $(classes().should(ArchConditions.resideInAPackage(thePackage)), thePackage) + arguments(classes().should().resideInAPackage(thePackage), thePackage), + arguments(classes().should(ArchConditions.resideInAPackage(thePackage)), thePackage) ); } @@ -388,10 +388,8 @@ static Stream resideInAnyPackage_rules() { String firstPackage = ArchRule.class.getPackage().getName(); String secondPackage = ArchConfiguration.class.getPackage().getName(); return Stream.of( - $(classes().should().resideInAnyPackage(firstPackage, secondPackage), - new String[]{firstPackage, secondPackage}), - $(classes().should(ArchConditions.resideInAnyPackage(firstPackage, secondPackage)), - new String[]{firstPackage, secondPackage}) + arguments(classes().should().resideInAnyPackage(firstPackage, secondPackage), new String[]{firstPackage, secondPackage}), + arguments(classes().should(ArchConditions.resideInAnyPackage(firstPackage, secondPackage)), new String[]{firstPackage, secondPackage}) ); } @@ -415,8 +413,8 @@ void resideInAnyPackage(ArchRule rule, String... packageIdentifiers) { static Stream resideOutsideOfPackage_rules() { String thePackage = ArchRule.class.getPackage().getName(); return Stream.of( - $(classes().should().resideOutsideOfPackage(thePackage), thePackage), - $(classes().should(ArchConditions.resideOutsideOfPackage(thePackage)), thePackage) + arguments(classes().should().resideOutsideOfPackage(thePackage), thePackage), + arguments(classes().should(ArchConditions.resideOutsideOfPackage(thePackage)), thePackage) ); } @@ -443,10 +441,8 @@ static Stream resideOutsideOfPackages_rules() { String firstPackage = ArchRule.class.getPackage().getName(); String secondPackage = ArchConfiguration.class.getPackage().getName(); return Stream.of( - $(classes().should().resideOutsideOfPackages(firstPackage, secondPackage), - new String[]{firstPackage, secondPackage}), - $(classes().should(ArchConditions.resideOutsideOfPackages(firstPackage, secondPackage)), - new String[]{firstPackage, secondPackage}) + arguments(classes().should().resideOutsideOfPackages(firstPackage, secondPackage), new String[]{firstPackage, secondPackage}), + arguments(classes().should(ArchConditions.resideOutsideOfPackages(firstPackage, secondPackage)), new String[]{firstPackage, secondPackage}) ); } @@ -469,12 +465,12 @@ void resideOutsideOfPackages(ArchRule rule, String... packageIdentifiers) { static Stream visibility_rules() { return Stream.of( - $(classes().should().bePublic(), PUBLIC, PublicClass.class, PrivateClass.class), - $(classes().should(bePublic()), PUBLIC, PublicClass.class, PrivateClass.class), - $(classes().should().beProtected(), PROTECTED, ProtectedClass.class, PrivateClass.class), - $(classes().should(beProtected()), PROTECTED, ProtectedClass.class, PrivateClass.class), - $(classes().should().bePrivate(), PRIVATE, PrivateClass.class, PublicClass.class), - $(classes().should(bePrivate()), PRIVATE, PrivateClass.class, PublicClass.class)); + arguments(classes().should().bePublic(), PUBLIC, PublicClass.class, PrivateClass.class), + arguments(classes().should(bePublic()), PUBLIC, PublicClass.class, PrivateClass.class), + arguments(classes().should().beProtected(), PROTECTED, ProtectedClass.class, PrivateClass.class), + arguments(classes().should(beProtected()), PROTECTED, ProtectedClass.class, PrivateClass.class), + arguments(classes().should().bePrivate(), PRIVATE, PrivateClass.class, PublicClass.class), + arguments(classes().should(bePrivate()), PRIVATE, PrivateClass.class, PublicClass.class)); } @ParameterizedTest @@ -490,12 +486,12 @@ void visibility(ArchRule rule, JavaModifier modifier, Class satisfied, Class< static Stream not_visibility_rules() { return Stream.of( - $(classes().should().notBePublic(), PUBLIC, PrivateClass.class, PublicClass.class), - $(classes().should(notBePublic()), PUBLIC, PrivateClass.class, PublicClass.class), - $(classes().should().notBeProtected(), PROTECTED, PrivateClass.class, ProtectedClass.class), - $(classes().should(notBeProtected()), PROTECTED, PrivateClass.class, ProtectedClass.class), - $(classes().should().notBePrivate(), PRIVATE, PublicClass.class, PrivateClass.class), - $(classes().should(notBePrivate()), PRIVATE, PublicClass.class, PrivateClass.class)); + arguments(classes().should().notBePublic(), PUBLIC, PrivateClass.class, PublicClass.class), + arguments(classes().should(notBePublic()), PUBLIC, PrivateClass.class, PublicClass.class), + arguments(classes().should().notBeProtected(), PROTECTED, PrivateClass.class, ProtectedClass.class), + arguments(classes().should(notBeProtected()), PROTECTED, PrivateClass.class, ProtectedClass.class), + arguments(classes().should().notBePrivate(), PRIVATE, PublicClass.class, PrivateClass.class), + arguments(classes().should(notBePrivate()), PRIVATE, PublicClass.class, PrivateClass.class)); } @ParameterizedTest @@ -511,8 +507,8 @@ void notVisibility(ArchRule rule, JavaModifier modifier, Class satisfied, Cla static Stream package_private_visibility_rules() { return Stream.of( - $(classes().should().bePackagePrivate(), "be package private"), - $(classes().should(bePackagePrivate()), "be package private")); + arguments(classes().should().bePackagePrivate(), "be package private"), + arguments(classes().should(bePackagePrivate()), "be package private")); } @ParameterizedTest @@ -528,8 +524,8 @@ void package_private_visibility(ArchRule rule, String description) { static Stream non_package_private_visibility_rules() { return Stream.of( - $(classes().should().notBePackagePrivate(), "not be package private"), - $(classes().should(notBePackagePrivate()), "not be package private")); + arguments(classes().should().notBePackagePrivate(), "not be package private"), + arguments(classes().should(notBePackagePrivate()), "not be package private")); } @ParameterizedTest @@ -548,14 +544,10 @@ void non_package_private_visibility(ArchRule rule, String description) { static Stream modifiers_rules() { return Stream.of( - $(classes().should().haveModifier(PUBLIC), "", PUBLIC, - PublicClass.class, PrivateClass.class), - $(classes().should(haveModifier(PUBLIC)), "", PUBLIC, - PublicClass.class, PrivateClass.class), - $(classes().should().notHaveModifier(PUBLIC), "not ", PUBLIC, - PrivateClass.class, PublicClass.class), - $(classes().should(notHaveModifier(PUBLIC)), "not ", PUBLIC, - PrivateClass.class, PublicClass.class)); + arguments(classes().should().haveModifier(PUBLIC), "", PUBLIC, PublicClass.class, PrivateClass.class), + arguments(classes().should(haveModifier(PUBLIC)), "", PUBLIC, PublicClass.class, PrivateClass.class), + arguments(classes().should().notHaveModifier(PUBLIC), "not ", PUBLIC, PrivateClass.class, PublicClass.class), + arguments(classes().should(notHaveModifier(PUBLIC)), "not ", PUBLIC, PrivateClass.class, PublicClass.class)); } @ParameterizedTest @@ -573,18 +565,12 @@ void modifiers(ArchRule rule, String havePrefix, JavaModifier modifier, static Stream annotated_rules() { return Stream.of( - $(classes().should().beAnnotatedWith(RuntimeRetentionAnnotation.class), - SomeAnnotatedClass.class, String.class), - $(classes().should(ArchConditions.beAnnotatedWith(RuntimeRetentionAnnotation.class)), - SomeAnnotatedClass.class, String.class), - $(classes().should().beAnnotatedWith(RuntimeRetentionAnnotation.class.getName()), - SomeAnnotatedClass.class, String.class), - $(classes().should(ArchConditions.beAnnotatedWith(RuntimeRetentionAnnotation.class.getName())), - SomeAnnotatedClass.class, String.class), - $(classes().should().beAnnotatedWith(annotation(RuntimeRetentionAnnotation.class)), - SomeAnnotatedClass.class, String.class), - $(classes().should(ArchConditions.beAnnotatedWith(annotation(RuntimeRetentionAnnotation.class))), - SomeAnnotatedClass.class, String.class)); + arguments(classes().should().beAnnotatedWith(RuntimeRetentionAnnotation.class), SomeAnnotatedClass.class, String.class), + arguments(classes().should(ArchConditions.beAnnotatedWith(RuntimeRetentionAnnotation.class)), SomeAnnotatedClass.class, String.class), + arguments(classes().should().beAnnotatedWith(RuntimeRetentionAnnotation.class.getName()), SomeAnnotatedClass.class, String.class), + arguments(classes().should(ArchConditions.beAnnotatedWith(RuntimeRetentionAnnotation.class.getName())), SomeAnnotatedClass.class, String.class), + arguments(classes().should().beAnnotatedWith(annotation(RuntimeRetentionAnnotation.class)), SomeAnnotatedClass.class, String.class), + arguments(classes().should(ArchConditions.beAnnotatedWith(annotation(RuntimeRetentionAnnotation.class))), SomeAnnotatedClass.class, String.class)); } @ParameterizedTest @@ -615,18 +601,12 @@ public void beAnnotatedWith_Retention_Source_is_rejected() { static Stream notAnnotated_rules() { return Stream.of( - $(classes().should().notBeAnnotatedWith(RuntimeRetentionAnnotation.class), - String.class, SomeAnnotatedClass.class), - $(classes().should(ArchConditions.notBeAnnotatedWith(RuntimeRetentionAnnotation.class)), - String.class, SomeAnnotatedClass.class), - $(classes().should().notBeAnnotatedWith(RuntimeRetentionAnnotation.class.getName()), - String.class, SomeAnnotatedClass.class), - $(classes().should(ArchConditions.notBeAnnotatedWith(RuntimeRetentionAnnotation.class.getName())), - String.class, SomeAnnotatedClass.class), - $(classes().should().notBeAnnotatedWith(annotation(RuntimeRetentionAnnotation.class)), - String.class, SomeAnnotatedClass.class), - $(classes().should(ArchConditions.notBeAnnotatedWith(annotation(RuntimeRetentionAnnotation.class))), - String.class, SomeAnnotatedClass.class)); + arguments(classes().should().notBeAnnotatedWith(RuntimeRetentionAnnotation.class), String.class, SomeAnnotatedClass.class), + arguments(classes().should(ArchConditions.notBeAnnotatedWith(RuntimeRetentionAnnotation.class)), String.class, SomeAnnotatedClass.class), + arguments(classes().should().notBeAnnotatedWith(RuntimeRetentionAnnotation.class.getName()), String.class, SomeAnnotatedClass.class), + arguments(classes().should(ArchConditions.notBeAnnotatedWith(RuntimeRetentionAnnotation.class.getName())), String.class, SomeAnnotatedClass.class), + arguments(classes().should().notBeAnnotatedWith(annotation(RuntimeRetentionAnnotation.class)), String.class, SomeAnnotatedClass.class), + arguments(classes().should(ArchConditions.notBeAnnotatedWith(annotation(RuntimeRetentionAnnotation.class))), String.class, SomeAnnotatedClass.class)); } @ParameterizedTest @@ -645,18 +625,12 @@ void notAnnotatedWith(ArchRule rule, Class correctClass, Class wrongClass) static Stream metaAnnotated_rules() { return Stream.of( - $(classes().should().beMetaAnnotatedWith(SomeMetaAnnotation.class), - SomeAnnotatedClass.class, String.class), - $(classes().should(ArchConditions.beMetaAnnotatedWith(SomeMetaAnnotation.class)), - SomeAnnotatedClass.class, String.class), - $(classes().should().beMetaAnnotatedWith(SomeMetaAnnotation.class.getName()), - SomeAnnotatedClass.class, String.class), - $(classes().should(ArchConditions.beMetaAnnotatedWith(SomeMetaAnnotation.class.getName())), - SomeAnnotatedClass.class, String.class), - $(classes().should().beMetaAnnotatedWith(annotation(SomeMetaAnnotation.class)), - SomeAnnotatedClass.class, String.class), - $(classes().should(ArchConditions.beMetaAnnotatedWith(annotation(SomeMetaAnnotation.class))), - SomeAnnotatedClass.class, String.class)); + arguments(classes().should().beMetaAnnotatedWith(SomeMetaAnnotation.class), SomeAnnotatedClass.class, String.class), + arguments(classes().should(ArchConditions.beMetaAnnotatedWith(SomeMetaAnnotation.class)), SomeAnnotatedClass.class, String.class), + arguments(classes().should().beMetaAnnotatedWith(SomeMetaAnnotation.class.getName()), SomeAnnotatedClass.class, String.class), + arguments(classes().should(ArchConditions.beMetaAnnotatedWith(SomeMetaAnnotation.class.getName())), SomeAnnotatedClass.class, String.class), + arguments(classes().should().beMetaAnnotatedWith(annotation(SomeMetaAnnotation.class)), SomeAnnotatedClass.class, String.class), + arguments(classes().should(ArchConditions.beMetaAnnotatedWith(annotation(SomeMetaAnnotation.class))), SomeAnnotatedClass.class, String.class)); } @ParameterizedTest @@ -675,18 +649,12 @@ void metaAnnotatedWith(ArchRule rule, Class correctClass, Class wrongClass static Stream notMetaAnnotated_rules() { return Stream.of( - $(classes().should().notBeMetaAnnotatedWith(SomeMetaAnnotation.class), - String.class, SomeAnnotatedClass.class), - $(classes().should(ArchConditions.notBeMetaAnnotatedWith(SomeMetaAnnotation.class)), - String.class, SomeAnnotatedClass.class), - $(classes().should().notBeMetaAnnotatedWith(SomeMetaAnnotation.class.getName()), - String.class, SomeAnnotatedClass.class), - $(classes().should(ArchConditions.notBeMetaAnnotatedWith(SomeMetaAnnotation.class.getName())), - String.class, SomeAnnotatedClass.class), - $(classes().should().notBeMetaAnnotatedWith(annotation(SomeMetaAnnotation.class)), - String.class, SomeAnnotatedClass.class), - $(classes().should(ArchConditions.notBeMetaAnnotatedWith(annotation(SomeMetaAnnotation.class))), - String.class, SomeAnnotatedClass.class)); + arguments(classes().should().notBeMetaAnnotatedWith(SomeMetaAnnotation.class), String.class, SomeAnnotatedClass.class), + arguments(classes().should(ArchConditions.notBeMetaAnnotatedWith(SomeMetaAnnotation.class)), String.class, SomeAnnotatedClass.class), + arguments(classes().should().notBeMetaAnnotatedWith(SomeMetaAnnotation.class.getName()), String.class, SomeAnnotatedClass.class), + arguments(classes().should(ArchConditions.notBeMetaAnnotatedWith(SomeMetaAnnotation.class.getName())), String.class, SomeAnnotatedClass.class), + arguments(classes().should().notBeMetaAnnotatedWith(annotation(SomeMetaAnnotation.class)), String.class, SomeAnnotatedClass.class), + arguments(classes().should(ArchConditions.notBeMetaAnnotatedWith(annotation(SomeMetaAnnotation.class))), String.class, SomeAnnotatedClass.class)); } @ParameterizedTest @@ -717,12 +685,12 @@ public void notBeAnnotatedWith_Retention_Source_is_rejected() { static Stream implement_satisfied_rules() { return Stream.of( - $(classes().should().implement(Collection.class), ArrayList.class), - $(classes().should(ArchConditions.implement(Collection.class)), ArrayList.class), - $(classes().should().implement(Collection.class.getName()), ArrayList.class), - $(classes().should(ArchConditions.implement(Collection.class.getName())), ArrayList.class), - $(classes().should().implement(name(Collection.class.getName()).as(Collection.class.getName())), ArrayList.class), - $(classes().should(ArchConditions.implement(name(Collection.class.getName()).as(Collection.class.getName()))), ArrayList.class)); + arguments(classes().should().implement(Collection.class), ArrayList.class), + arguments(classes().should(ArchConditions.implement(Collection.class)), ArrayList.class), + arguments(classes().should().implement(Collection.class.getName()), ArrayList.class), + arguments(classes().should(ArchConditions.implement(Collection.class.getName())), ArrayList.class), + arguments(classes().should().implement(name(Collection.class.getName()).as(Collection.class.getName())), ArrayList.class), + arguments(classes().should(ArchConditions.implement(name(Collection.class.getName()).as(Collection.class.getName()))), ArrayList.class)); } @ParameterizedTest @@ -750,18 +718,12 @@ static List implement_not_satisfied_rules() { private static List implementNotSatisfiedCases(Class classToCheckAgainst, Class violating) { return ImmutableList.of( - $(classes().should().implement(classToCheckAgainst), - classToCheckAgainst, violating), - $(classes().should(ArchConditions.implement(classToCheckAgainst)), - classToCheckAgainst, violating), - $(classes().should().implement(classToCheckAgainst.getName()), - classToCheckAgainst, violating), - $(classes().should(ArchConditions.implement(classToCheckAgainst.getName())), - classToCheckAgainst, violating), - $(classes().should().implement(name(classToCheckAgainst.getName()).as(classToCheckAgainst.getName())), - classToCheckAgainst, violating), - $(classes().should(ArchConditions.implement(name(classToCheckAgainst.getName()).as(classToCheckAgainst.getName()))), - classToCheckAgainst, violating)); + arguments(classes().should().implement(classToCheckAgainst), classToCheckAgainst, violating), + arguments(classes().should(ArchConditions.implement(classToCheckAgainst)), classToCheckAgainst, violating), + arguments(classes().should().implement(classToCheckAgainst.getName()), classToCheckAgainst, violating), + arguments(classes().should(ArchConditions.implement(classToCheckAgainst.getName())), classToCheckAgainst, violating), + arguments(classes().should().implement(name(classToCheckAgainst.getName()).as(classToCheckAgainst.getName())), classToCheckAgainst, violating), + arguments(classes().should(ArchConditions.implement(name(classToCheckAgainst.getName()).as(classToCheckAgainst.getName()))), classToCheckAgainst, violating)); } @ParameterizedTest @@ -779,13 +741,12 @@ void implement_not_satisfied(ArchRule rule, Class classToCheckAgainst, Class< static Stream notImplement_rules() { return Stream.of( - $(classes().should().notImplement(Collection.class), List.class, ArrayList.class), - $(classes().should(ArchConditions.notImplement(Collection.class)), List.class, ArrayList.class), - $(classes().should().notImplement(Collection.class.getName()), List.class, ArrayList.class), - $(classes().should(ArchConditions.notImplement(Collection.class.getName())), List.class, ArrayList.class), - $(classes().should().notImplement(name(Collection.class.getName()).as(Collection.class.getName())), List.class, ArrayList.class), - $(classes().should(ArchConditions.notImplement(name(Collection.class.getName()).as(Collection.class.getName()))), - List.class, ArrayList.class)); + arguments(classes().should().notImplement(Collection.class), List.class, ArrayList.class), + arguments(classes().should(ArchConditions.notImplement(Collection.class)), List.class, ArrayList.class), + arguments(classes().should().notImplement(Collection.class.getName()), List.class, ArrayList.class), + arguments(classes().should(ArchConditions.notImplement(Collection.class.getName())), List.class, ArrayList.class), + arguments(classes().should().notImplement(name(Collection.class.getName()).as(Collection.class.getName())), List.class, ArrayList.class), + arguments(classes().should(ArchConditions.notImplement(name(Collection.class.getName()).as(Collection.class.getName()))), List.class, ArrayList.class)); } @ParameterizedTest @@ -811,13 +772,12 @@ public void notImplement_rejects_non_interface_types() { static Stream assignableTo_rules() { return Stream.of( - $(classes().should().beAssignableTo(Collection.class), List.class, String.class), - $(classes().should(ArchConditions.beAssignableTo(Collection.class)), List.class, String.class), - $(classes().should().beAssignableTo(Collection.class.getName()), List.class, String.class), - $(classes().should(ArchConditions.beAssignableTo(Collection.class.getName())), List.class, String.class), - $(classes().should().beAssignableTo(name(Collection.class.getName()).as(Collection.class.getName())), List.class, String.class), - $(classes().should(ArchConditions.beAssignableTo(name(Collection.class.getName()).as(Collection.class.getName()))), - List.class, String.class)); + arguments(classes().should().beAssignableTo(Collection.class), List.class, String.class), + arguments(classes().should(ArchConditions.beAssignableTo(Collection.class)), List.class, String.class), + arguments(classes().should().beAssignableTo(Collection.class.getName()), List.class, String.class), + arguments(classes().should(ArchConditions.beAssignableTo(Collection.class.getName())), List.class, String.class), + arguments(classes().should().beAssignableTo(name(Collection.class.getName()).as(Collection.class.getName())), List.class, String.class), + arguments(classes().should(ArchConditions.beAssignableTo(name(Collection.class.getName()).as(Collection.class.getName()))), List.class, String.class)); } @ParameterizedTest @@ -836,13 +796,12 @@ void assignableTo(ArchRule rule, Class satisfied, Class violated) { static Stream notAssignableTo_rules() { return Stream.of( - $(classes().should().notBeAssignableTo(Collection.class), String.class, List.class), - $(classes().should(ArchConditions.notBeAssignableTo(Collection.class)), String.class, List.class), - $(classes().should().notBeAssignableTo(Collection.class.getName()), String.class, List.class), - $(classes().should(ArchConditions.notBeAssignableTo(Collection.class.getName())), String.class, List.class), - $(classes().should().notBeAssignableTo(name(Collection.class.getName()).as(Collection.class.getName())), String.class, List.class), - $(classes().should(ArchConditions.notBeAssignableTo(name(Collection.class.getName()).as(Collection.class.getName()))), - String.class, List.class)); + arguments(classes().should().notBeAssignableTo(Collection.class), String.class, List.class), + arguments(classes().should(ArchConditions.notBeAssignableTo(Collection.class)), String.class, List.class), + arguments(classes().should().notBeAssignableTo(Collection.class.getName()), String.class, List.class), + arguments(classes().should(ArchConditions.notBeAssignableTo(Collection.class.getName())), String.class, List.class), + arguments(classes().should().notBeAssignableTo(name(Collection.class.getName()).as(Collection.class.getName())), String.class, List.class), + arguments(classes().should(ArchConditions.notBeAssignableTo(name(Collection.class.getName()).as(Collection.class.getName()))), String.class, List.class)); } @ParameterizedTest @@ -861,13 +820,12 @@ void notAssignableTo(ArchRule rule, Class satisfied, Class violated) { static Stream assignableFrom_rules() { return Stream.of( - $(classes().should().beAssignableFrom(List.class), Collection.class, String.class), - $(classes().should(ArchConditions.beAssignableFrom(List.class)), Collection.class, String.class), - $(classes().should().beAssignableFrom(List.class.getName()), Collection.class, String.class), - $(classes().should(ArchConditions.beAssignableFrom(List.class.getName())), Collection.class, String.class), - $(classes().should().beAssignableFrom(name(List.class.getName()).as(List.class.getName())), Collection.class, String.class), - $(classes().should(ArchConditions.beAssignableFrom(name(List.class.getName()).as(List.class.getName()))), - Collection.class, String.class)); + arguments(classes().should().beAssignableFrom(List.class), Collection.class, String.class), + arguments(classes().should(ArchConditions.beAssignableFrom(List.class)), Collection.class, String.class), + arguments(classes().should().beAssignableFrom(List.class.getName()), Collection.class, String.class), + arguments(classes().should(ArchConditions.beAssignableFrom(List.class.getName())), Collection.class, String.class), + arguments(classes().should().beAssignableFrom(name(List.class.getName()).as(List.class.getName())), Collection.class, String.class), + arguments(classes().should(ArchConditions.beAssignableFrom(name(List.class.getName()).as(List.class.getName()))), Collection.class, String.class)); } @ParameterizedTest @@ -886,13 +844,12 @@ void assignableFrom(ArchRule rule, Class satisfied, Class violated) { static Stream notAssignableFrom_rules() { return Stream.of( - $(classes().should().notBeAssignableFrom(List.class), String.class, Collection.class), - $(classes().should(ArchConditions.notBeAssignableFrom(List.class)), String.class, Collection.class), - $(classes().should().notBeAssignableFrom(List.class.getName()), String.class, Collection.class), - $(classes().should(ArchConditions.notBeAssignableFrom(List.class.getName())), String.class, Collection.class), - $(classes().should().notBeAssignableFrom(name(List.class.getName()).as(List.class.getName())), String.class, Collection.class), - $(classes().should(ArchConditions.notBeAssignableFrom(name(List.class.getName()).as(List.class.getName()))), - String.class, Collection.class)); + arguments(classes().should().notBeAssignableFrom(List.class), String.class, Collection.class), + arguments(classes().should(ArchConditions.notBeAssignableFrom(List.class)), String.class, Collection.class), + arguments(classes().should().notBeAssignableFrom(List.class.getName()), String.class, Collection.class), + arguments(classes().should(ArchConditions.notBeAssignableFrom(List.class.getName())), String.class, Collection.class), + arguments(classes().should().notBeAssignableFrom(name(List.class.getName()).as(List.class.getName())), String.class, Collection.class), + arguments(classes().should(ArchConditions.notBeAssignableFrom(name(List.class.getName()).as(List.class.getName()))), String.class, Collection.class)); } @ParameterizedTest @@ -911,18 +868,18 @@ void notAssignableFrom(ArchRule rule, Class satisfied, Class violated) { static Stream accessField_rules() { return Stream.of( - $(classes().should().getField(ClassWithField.class, "field"), "get", "gets"), - $(classes().should(ArchConditions.getField(ClassWithField.class, "field")), "get", "gets"), - $(classes().should().getField(ClassWithField.class.getName(), "field"), "get", "gets"), - $(classes().should(ArchConditions.getField(ClassWithField.class.getName(), "field")), "get", "gets"), - $(classes().should().setField(ClassWithField.class, "field"), "set", "sets"), - $(classes().should(ArchConditions.setField(ClassWithField.class, "field")), "set", "sets"), - $(classes().should().setField(ClassWithField.class.getName(), "field"), "set", "sets"), - $(classes().should(ArchConditions.setField(ClassWithField.class.getName(), "field")), "set", "sets"), - $(classes().should().accessField(ClassWithField.class, "field"), "access", "(gets|sets)"), - $(classes().should(ArchConditions.accessField(ClassWithField.class, "field")), "access", "(gets|sets)"), - $(classes().should().accessField(ClassWithField.class.getName(), "field"), "access", "(gets|sets)"), - $(classes().should(ArchConditions.accessField(ClassWithField.class.getName(), "field")), "access", "(gets|sets)") + arguments(classes().should().getField(ClassWithField.class, "field"), "get", "gets"), + arguments(classes().should(ArchConditions.getField(ClassWithField.class, "field")), "get", "gets"), + arguments(classes().should().getField(ClassWithField.class.getName(), "field"), "get", "gets"), + arguments(classes().should(ArchConditions.getField(ClassWithField.class.getName(), "field")), "get", "gets"), + arguments(classes().should().setField(ClassWithField.class, "field"), "set", "sets"), + arguments(classes().should(ArchConditions.setField(ClassWithField.class, "field")), "set", "sets"), + arguments(classes().should().setField(ClassWithField.class.getName(), "field"), "set", "sets"), + arguments(classes().should(ArchConditions.setField(ClassWithField.class.getName(), "field")), "set", "sets"), + arguments(classes().should().accessField(ClassWithField.class, "field"), "access", "(gets|sets)"), + arguments(classes().should(ArchConditions.accessField(ClassWithField.class, "field")), "access", "(gets|sets)"), + arguments(classes().should().accessField(ClassWithField.class.getName(), "field"), "access", "(gets|sets)"), + arguments(classes().should(ArchConditions.accessField(ClassWithField.class.getName(), "field")), "access", "(gets|sets)") ); } @@ -945,12 +902,12 @@ void accessField(ArchRule rule, String accessTypePlural, String accessTypeSingul static Stream accessFieldWhere_rules() { return Stream.of( - $(classes().should().getFieldWhere(accessTargetIs(ClassWithField.class)), "get", "gets"), - $(classes().should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class))), "get", "gets"), - $(classes().should().setFieldWhere(accessTargetIs(ClassWithField.class)), "set", "sets"), - $(classes().should(ArchConditions.setFieldWhere(accessTargetIs(ClassWithField.class))), "set", "sets"), - $(classes().should().accessFieldWhere(accessTargetIs(ClassWithField.class)), "access", "(gets|sets)"), - $(classes().should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class))), "access", "(gets|sets)") + arguments(classes().should().getFieldWhere(accessTargetIs(ClassWithField.class)), "get", "gets"), + arguments(classes().should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class))), "get", "gets"), + arguments(classes().should().setFieldWhere(accessTargetIs(ClassWithField.class)), "set", "sets"), + arguments(classes().should(ArchConditions.setFieldWhere(accessTargetIs(ClassWithField.class))), "set", "sets"), + arguments(classes().should().accessFieldWhere(accessTargetIs(ClassWithField.class)), "access", "(gets|sets)"), + arguments(classes().should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class))), "access", "(gets|sets)") ); } @@ -1028,8 +985,8 @@ void callMethod(ArchRule rule) { static Stream callMethodWhere_rules() { return Stream.of( - $(classes().should().callMethodWhere(callTargetIs(ClassWithMethod.class))), - $(classes().should(ArchConditions.callMethodWhere(callTargetIs(ClassWithMethod.class)))) + arguments(classes().should().callMethodWhere(callTargetIs(ClassWithMethod.class))), + arguments(classes().should(ArchConditions.callMethodWhere(callTargetIs(ClassWithMethod.class)))) ); } @@ -1055,8 +1012,8 @@ void callMethodWhere(ArchRule rule) { static Stream onlyCallMethodsThat_rules() { return Stream.of( - $(classes().should().onlyCallMethodsThat(are(declaredIn(ClassWithMethod.class)))), - $(classes().should(ArchConditions.onlyCallMethodsThat(are(declaredIn(ClassWithMethod.class))))) + arguments(classes().should().onlyCallMethodsThat(are(declaredIn(ClassWithMethod.class)))), + arguments(classes().should(ArchConditions.onlyCallMethodsThat(are(declaredIn(ClassWithMethod.class))))) ); } @@ -1082,10 +1039,10 @@ void onlyCallMethodsThat(ArchRule rule) { static Stream callConstructor_rules() { return Stream.of( - $(classes().should().callConstructor(ClassWithConstructor.class, String.class)), - $(classes().should(ArchConditions.callConstructor(ClassWithConstructor.class, String.class))), - $(classes().should().callConstructor(ClassWithConstructor.class.getName(), String.class.getName())), - $(classes().should(ArchConditions.callConstructor(ClassWithConstructor.class.getName(), String.class.getName()))) + arguments(classes().should().callConstructor(ClassWithConstructor.class, String.class)), + arguments(classes().should(ArchConditions.callConstructor(ClassWithConstructor.class, String.class))), + arguments(classes().should().callConstructor(ClassWithConstructor.class.getName(), String.class.getName())), + arguments(classes().should(ArchConditions.callConstructor(ClassWithConstructor.class.getName(), String.class.getName()))) ); } @@ -1108,8 +1065,8 @@ void callConstructor(ArchRule rule) { static Stream callConstructorWhere_rules() { return Stream.of( - $(classes().should().callConstructorWhere(callTargetIs(ClassWithConstructor.class))), - $(classes().should(ArchConditions.callConstructorWhere(callTargetIs(ClassWithConstructor.class)))) + arguments(classes().should().callConstructorWhere(callTargetIs(ClassWithConstructor.class))), + arguments(classes().should(ArchConditions.callConstructorWhere(callTargetIs(ClassWithConstructor.class)))) ); } @@ -1132,8 +1089,8 @@ void callConstructorWhere(ArchRule rule) { static Stream onlyCallConstructorsThat_rules() { return Stream.of( - $(classes().should().onlyCallConstructorsThat(are(declaredIn(ClassWithConstructor.class)))), - $(classes().should(ArchConditions.onlyCallConstructorsThat(are(declaredIn(ClassWithConstructor.class))))) + arguments(classes().should().onlyCallConstructorsThat(are(declaredIn(ClassWithConstructor.class)))), + arguments(classes().should(ArchConditions.onlyCallConstructorsThat(are(declaredIn(ClassWithConstructor.class))))) ); } @@ -1159,8 +1116,8 @@ void onlyCallConstructorsThat(ArchRule rule) { static Stream accessTargetWhere_rules() { return Stream.of( - $(classes().should().accessTargetWhere(accessTargetIs(ClassWithFieldMethodAndConstructor.class))), - $(classes().should(ArchConditions.accessTargetWhere(accessTargetIs(ClassWithFieldMethodAndConstructor.class)))) + arguments(classes().should().accessTargetWhere(accessTargetIs(ClassWithFieldMethodAndConstructor.class))), + arguments(classes().should(ArchConditions.accessTargetWhere(accessTargetIs(ClassWithFieldMethodAndConstructor.class)))) ); } @@ -1190,8 +1147,8 @@ void accessTargetWhere(ArchRule rule) { static Stream callCodeUnitWhere_rules() { return Stream.of( - $(classes().should().callCodeUnitWhere(accessTargetIs(ClassWithFieldMethodAndConstructor.class))), - $(classes().should(ArchConditions.callCodeUnitWhere(accessTargetIs(ClassWithFieldMethodAndConstructor.class)))) + arguments(classes().should().callCodeUnitWhere(accessTargetIs(ClassWithFieldMethodAndConstructor.class))), + arguments(classes().should(ArchConditions.callCodeUnitWhere(accessTargetIs(ClassWithFieldMethodAndConstructor.class)))) ); } @@ -1221,8 +1178,8 @@ void callCodeUnitWhere(ArchRule rule) { static Stream onlyCallCodeUnitsThat_rules() { return Stream.of( - $(classes().should().onlyCallCodeUnitsThat(are(declaredIn(ClassWithFieldMethodAndConstructor.class)))), - $(classes().should(ArchConditions.onlyCallCodeUnitsThat(are(declaredIn(ClassWithFieldMethodAndConstructor.class))))) + arguments(classes().should().onlyCallCodeUnitsThat(are(declaredIn(ClassWithFieldMethodAndConstructor.class)))), + arguments(classes().should(ArchConditions.onlyCallCodeUnitsThat(are(declaredIn(ClassWithFieldMethodAndConstructor.class))))) ); } @@ -1255,8 +1212,8 @@ void onlyCallCodeUnitsThat(ArchRule rule) { static Stream onlyAccessMembersThat_rules() { return Stream.of( - $(classes().should().onlyAccessMembersThat(are(declaredIn(ClassWithFieldMethodAndConstructor.class)))), - $(classes().should(ArchConditions.onlyAccessMembersThat(are(declaredIn(ClassWithFieldMethodAndConstructor.class))))) + arguments(classes().should().onlyAccessMembersThat(are(declaredIn(ClassWithFieldMethodAndConstructor.class)))), + arguments(classes().should(ArchConditions.onlyAccessMembersThat(are(declaredIn(ClassWithFieldMethodAndConstructor.class))))) ); } @@ -1289,8 +1246,8 @@ void onlyAccessMembersThat(ArchRule rule) { static Stream beInterfaces_rules() { return Stream.of( - $(classes().should().beInterfaces(), Collection.class, String.class), - $(classes().should(ArchConditions.beInterfaces()), Collection.class, String.class)); + arguments(classes().should().beInterfaces(), Collection.class, String.class), + arguments(classes().should(ArchConditions.beInterfaces()), Collection.class, String.class)); } @ParameterizedTest @@ -1308,8 +1265,8 @@ void beInterfaces(ArchRule rule, Class satisfied, Class violated) { static Stream notBeInterfaces_rules() { return Stream.of( - $(classes().should().notBeInterfaces(), String.class, Collection.class), - $(classes().should(ArchConditions.notBeInterfaces()), String.class, Collection.class)); + arguments(classes().should().notBeInterfaces(), String.class, Collection.class), + arguments(classes().should(ArchConditions.notBeInterfaces()), String.class, Collection.class)); } @ParameterizedTest @@ -1327,8 +1284,8 @@ void notBeInterfaces(ArchRule rule, Class satisfied, Class violated) { static Stream beEnums_rules() { return Stream.of( - $(classes().should().beEnums(), StandardCopyOption.class, String.class), - $(classes().should(ArchConditions.beEnums()), StandardCopyOption.class, String.class)); + arguments(classes().should().beEnums(), StandardCopyOption.class, String.class), + arguments(classes().should(ArchConditions.beEnums()), StandardCopyOption.class, String.class)); } @ParameterizedTest @@ -1346,8 +1303,8 @@ void beEnums(ArchRule rule, Class satisfied, Class violated) { static Stream notBeEnums_rules() { return Stream.of( - $(classes().should().notBeEnums(), String.class, StandardCopyOption.class), - $(classes().should(ArchConditions.notBeEnums()), String.class, StandardCopyOption.class)); + arguments(classes().should().notBeEnums(), String.class, StandardCopyOption.class), + arguments(classes().should(ArchConditions.notBeEnums()), String.class, StandardCopyOption.class)); } @ParameterizedTest @@ -1368,8 +1325,8 @@ static Stream beTopLevelClasses_rules() { Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; return Stream.of( - $(classes().should().beTopLevelClasses(), topLevelClass, staticNestedClass), - $(classes().should(ArchConditions.beTopLevelClasses()), topLevelClass, staticNestedClass) + arguments(classes().should().beTopLevelClasses(), topLevelClass, staticNestedClass), + arguments(classes().should(ArchConditions.beTopLevelClasses()), topLevelClass, staticNestedClass) ); } @@ -1389,8 +1346,8 @@ static Stream notBeTopLevelClasses_rules() { Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; return Stream.of( - $(classes().should().notBeTopLevelClasses(), staticNestedClass, topLevelClass), - $(classes().should(ArchConditions.notBeTopLevelClasses()), staticNestedClass, topLevelClass) + arguments(classes().should().notBeTopLevelClasses(), staticNestedClass, topLevelClass), + arguments(classes().should(ArchConditions.notBeTopLevelClasses()), staticNestedClass, topLevelClass) ); } @@ -1410,8 +1367,8 @@ static Stream beNestedClasses_rules() { Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; return Stream.of( - $(classes().should().beNestedClasses(), staticNestedClass, topLevelClass), - $(classes().should(ArchConditions.beNestedClasses()), staticNestedClass, topLevelClass) + arguments(classes().should().beNestedClasses(), staticNestedClass, topLevelClass), + arguments(classes().should(ArchConditions.beNestedClasses()), staticNestedClass, topLevelClass) ); } @@ -1431,8 +1388,8 @@ static Stream notBeNestedClasses_rules() { Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; return Stream.of( - $(classes().should().notBeNestedClasses(), topLevelClass, staticNestedClass), - $(classes().should(ArchConditions.notBeNestedClasses()), topLevelClass, staticNestedClass) + arguments(classes().should().notBeNestedClasses(), topLevelClass, staticNestedClass), + arguments(classes().should(ArchConditions.notBeNestedClasses()), topLevelClass, staticNestedClass) ); } @@ -1452,8 +1409,8 @@ static Stream beMemberClasses_rules() { Class anonymousClass = NestedClassWithSomeMoreClasses.getAnonymousClass(); return Stream.of( - $(classes().should().beMemberClasses(), staticNestedClass, anonymousClass), - $(classes().should(ArchConditions.beMemberClasses()), staticNestedClass, anonymousClass) + arguments(classes().should().beMemberClasses(), staticNestedClass, anonymousClass), + arguments(classes().should(ArchConditions.beMemberClasses()), staticNestedClass, anonymousClass) ); } @@ -1473,8 +1430,8 @@ static Stream notBeMemberClasses_rules() { Class anonymousClass = NestedClassWithSomeMoreClasses.getAnonymousClass(); return Stream.of( - $(classes().should().notBeMemberClasses(), anonymousClass, staticNestedClass), - $(classes().should(ArchConditions.notBeMemberClasses()), anonymousClass, staticNestedClass) + arguments(classes().should().notBeMemberClasses(), anonymousClass, staticNestedClass), + arguments(classes().should(ArchConditions.notBeMemberClasses()), anonymousClass, staticNestedClass) ); } @@ -1494,8 +1451,8 @@ static Stream beInnerClasses_rules() { Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; return Stream.of( - $(classes().should().beInnerClasses(), innerMemberClass, staticNestedClass), - $(classes().should(ArchConditions.beInnerClasses()), innerMemberClass, staticNestedClass) + arguments(classes().should().beInnerClasses(), innerMemberClass, staticNestedClass), + arguments(classes().should(ArchConditions.beInnerClasses()), innerMemberClass, staticNestedClass) ); } @@ -1515,8 +1472,8 @@ static Stream notBeInnerClasses_rules() { Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; return Stream.of( - $(classes().should().notBeInnerClasses(), staticNestedClass, nonStaticNestedClass), - $(classes().should(ArchConditions.notBeInnerClasses()), staticNestedClass, nonStaticNestedClass) + arguments(classes().should().notBeInnerClasses(), staticNestedClass, nonStaticNestedClass), + arguments(classes().should(ArchConditions.notBeInnerClasses()), staticNestedClass, nonStaticNestedClass) ); } @@ -1536,8 +1493,8 @@ static Stream beAnonymousClasses_rules() { Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; return Stream.of( - $(classes().should().beAnonymousClasses(), anonymousClass, staticNestedClass), - $(classes().should(ArchConditions.beAnonymousClasses()), anonymousClass, staticNestedClass) + arguments(classes().should().beAnonymousClasses(), anonymousClass, staticNestedClass), + arguments(classes().should(ArchConditions.beAnonymousClasses()), anonymousClass, staticNestedClass) ); } @@ -1557,8 +1514,8 @@ static Stream notBeAnonymousClasses_rules() { Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; return Stream.of( - $(classes().should().notBeAnonymousClasses(), staticNestedClass, anonymousClass), - $(classes().should(ArchConditions.notBeAnonymousClasses()), staticNestedClass, anonymousClass) + arguments(classes().should().notBeAnonymousClasses(), staticNestedClass, anonymousClass), + arguments(classes().should(ArchConditions.notBeAnonymousClasses()), staticNestedClass, anonymousClass) ); } @@ -1578,8 +1535,8 @@ static Stream beLocalClasses_rules() { Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; return Stream.of( - $(classes().should().beLocalClasses(), localClass, staticNestedClass), - $(classes().should(ArchConditions.beLocalClasses()), localClass, staticNestedClass) + arguments(classes().should().beLocalClasses(), localClass, staticNestedClass), + arguments(classes().should(ArchConditions.beLocalClasses()), localClass, staticNestedClass) ); } @@ -1599,8 +1556,8 @@ static Stream notBeLocalClasses_rules() { Class staticNestedClass = NestedClassWithSomeMoreClasses.StaticNestedClass.class; return Stream.of( - $(classes().should().notBeLocalClasses(), staticNestedClass, localClass), - $(classes().should(ArchConditions.notBeLocalClasses()), staticNestedClass, localClass) + arguments(classes().should().notBeLocalClasses(), staticNestedClass, localClass), + arguments(classes().should(ArchConditions.notBeLocalClasses()), staticNestedClass, localClass) ); } @@ -1631,10 +1588,10 @@ public void containNumberOfElements_fails_on_mismatching_predicate() { static Stream beClass_rules() { return Stream.of( - $(classes().should().be(String.class), String.class, Collection.class), - $(classes().should().be(String.class.getName()), String.class, Collection.class), - $(classes().should(ArchConditions.be(String.class)), String.class, Collection.class), - $(classes().should(ArchConditions.be(String.class.getName())), String.class, Collection.class)); + arguments(classes().should().be(String.class), String.class, Collection.class), + arguments(classes().should().be(String.class.getName()), String.class, Collection.class), + arguments(classes().should(ArchConditions.be(String.class)), String.class, Collection.class), + arguments(classes().should(ArchConditions.be(String.class.getName())), String.class, Collection.class)); } @ParameterizedTest @@ -1653,10 +1610,10 @@ void beClass(ArchRule rule, Class satisfied, Class violated) { static Stream notBeClass_rules() { return Stream.of( - $(classes().should().notBe(Collection.class), String.class, Collection.class), - $(classes().should().notBe(Collection.class.getName()), String.class, Collection.class), - $(classes().should(ArchConditions.notBe(Collection.class)), String.class, Collection.class), - $(classes().should(ArchConditions.notBe(Collection.class.getName())), String.class, Collection.class)); + arguments(classes().should().notBe(Collection.class), String.class, Collection.class), + arguments(classes().should().notBe(Collection.class.getName()), String.class, Collection.class), + arguments(classes().should(ArchConditions.notBe(Collection.class)), String.class, Collection.class), + arguments(classes().should(ArchConditions.notBe(Collection.class.getName())), String.class, Collection.class)); } @ParameterizedTest @@ -1675,16 +1632,16 @@ void notBeClass(ArchRule rule, Class satisfied, Class violated) { static Stream onlyAccessRules_rules() { return Stream.of( - $(classes().should().onlyCallMethodsThat(are(not(declaredIn(ClassWithMethod.class)))), ClassCallingMethod.class), - $(classes().should(ArchConditions.onlyCallMethodsThat(are(not(declaredIn(ClassWithMethod.class))))), ClassCallingMethod.class), - $(classes().should().onlyCallConstructorsThat(are(not(declaredIn(ClassWithConstructor.class)))), ClassCallingConstructor.class), - $(classes().should(ArchConditions.onlyCallConstructorsThat(are(not(declaredIn(ClassWithConstructor.class))))), ClassCallingConstructor.class), - $(classes().should().onlyCallCodeUnitsThat(are(not(declaredIn(ClassWithMethod.class)))), ClassCallingMethod.class), - $(classes().should(ArchConditions.onlyCallCodeUnitsThat(are(not(declaredIn(ClassWithMethod.class))))), ClassCallingMethod.class), - $(classes().should().onlyAccessFieldsThat(are(not(declaredIn(ClassWithField.class)))), ClassAccessingField.class), - $(classes().should(ArchConditions.onlyAccessFieldsThat(are(not(declaredIn(ClassWithField.class))))), ClassAccessingField.class), - $(classes().should().onlyAccessMembersThat(are(not(declaredIn(ClassWithField.class)))), ClassAccessingField.class), - $(classes().should(ArchConditions.onlyAccessMembersThat(are(not(declaredIn(ClassWithField.class))))), ClassAccessingField.class)); + arguments(classes().should().onlyCallMethodsThat(are(not(declaredIn(ClassWithMethod.class)))), ClassCallingMethod.class), + arguments(classes().should(ArchConditions.onlyCallMethodsThat(are(not(declaredIn(ClassWithMethod.class))))), ClassCallingMethod.class), + arguments(classes().should().onlyCallConstructorsThat(are(not(declaredIn(ClassWithConstructor.class)))), ClassCallingConstructor.class), + arguments(classes().should(ArchConditions.onlyCallConstructorsThat(are(not(declaredIn(ClassWithConstructor.class))))), ClassCallingConstructor.class), + arguments(classes().should().onlyCallCodeUnitsThat(are(not(declaredIn(ClassWithMethod.class)))), ClassCallingMethod.class), + arguments(classes().should(ArchConditions.onlyCallCodeUnitsThat(are(not(declaredIn(ClassWithMethod.class))))), ClassCallingMethod.class), + arguments(classes().should().onlyAccessFieldsThat(are(not(declaredIn(ClassWithField.class)))), ClassAccessingField.class), + arguments(classes().should(ArchConditions.onlyAccessFieldsThat(are(not(declaredIn(ClassWithField.class))))), ClassAccessingField.class), + arguments(classes().should().onlyAccessMembersThat(are(not(declaredIn(ClassWithField.class)))), ClassAccessingField.class), + arguments(classes().should(ArchConditions.onlyAccessMembersThat(are(not(declaredIn(ClassWithField.class))))), ClassAccessingField.class)); } @ParameterizedTest diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/CodeUnitsShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/CodeUnitsShouldTest.java index 2b92b3d0e8..2a2efd89ab 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/CodeUnitsShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/CodeUnitsShouldTest.java @@ -56,8 +56,8 @@ import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.assertViolation; import static com.tngtech.archunit.lang.syntax.elements.MembersShouldTest.parseMembers; import static com.tngtech.archunit.testutil.Assertions.assertThat; -import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.regex.Pattern.quote; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class CodeUnitsShouldTest { @@ -126,43 +126,43 @@ public void check(JavaConstructor constructor, ConditionEvents events) { static Stream restricted_parameter_types_rules() { return Stream.of( - $(codeUnits().should().haveRawParameterTypes(String.class), + arguments(codeUnits().should().haveRawParameterTypes(String.class), union(allMethodsExcept(METHOD_ONE_ARG), allConstructorsExcept(CONSTRUCTOR_ONE_ARG))), - $(codeUnits().should().haveRawParameterTypes(String.class.getName()), + arguments(codeUnits().should().haveRawParameterTypes(String.class.getName()), union(allMethodsExcept(METHOD_ONE_ARG), allConstructorsExcept(CONSTRUCTOR_ONE_ARG))), - $(codeUnits().should().haveRawParameterTypes(oneParameterOfType(String.class)), + arguments(codeUnits().should().haveRawParameterTypes(oneParameterOfType(String.class)), union(allMethodsExcept(METHOD_ONE_ARG), allConstructorsExcept(CONSTRUCTOR_ONE_ARG))), - $(codeUnits().should().notHaveRawParameterTypes(String.class), + arguments(codeUnits().should().notHaveRawParameterTypes(String.class), ImmutableSet.of(METHOD_ONE_ARG, CONSTRUCTOR_ONE_ARG)), - $(codeUnits().should().notHaveRawParameterTypes(String.class.getName()), + arguments(codeUnits().should().notHaveRawParameterTypes(String.class.getName()), ImmutableSet.of(METHOD_ONE_ARG, CONSTRUCTOR_ONE_ARG)), - $(codeUnits().should().notHaveRawParameterTypes(oneParameterOfType(String.class)), + arguments(codeUnits().should().notHaveRawParameterTypes(oneParameterOfType(String.class)), ImmutableSet.of(METHOD_ONE_ARG, CONSTRUCTOR_ONE_ARG)), - $(methods().should().haveRawParameterTypes(String.class), + arguments(methods().should().haveRawParameterTypes(String.class), allMethodsExcept(METHOD_ONE_ARG)), - $(methods().should().haveRawParameterTypes(String.class.getName()), + arguments(methods().should().haveRawParameterTypes(String.class.getName()), allMethodsExcept(METHOD_ONE_ARG)), - $(methods().should().haveRawParameterTypes(oneParameterOfType(String.class)), + arguments(methods().should().haveRawParameterTypes(oneParameterOfType(String.class)), allMethodsExcept(METHOD_ONE_ARG)), - $(methods().should().notHaveRawParameterTypes(String.class), + arguments(methods().should().notHaveRawParameterTypes(String.class), ImmutableSet.of(METHOD_ONE_ARG)), - $(methods().should().notHaveRawParameterTypes(String.class.getName()), + arguments(methods().should().notHaveRawParameterTypes(String.class.getName()), ImmutableSet.of(METHOD_ONE_ARG)), - $(methods().should().notHaveRawParameterTypes(oneParameterOfType(String.class)), + arguments(methods().should().notHaveRawParameterTypes(oneParameterOfType(String.class)), ImmutableSet.of(METHOD_ONE_ARG)), - $(constructors().should().haveRawParameterTypes(String.class), + arguments(constructors().should().haveRawParameterTypes(String.class), allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), - $(constructors().should().haveRawParameterTypes(String.class.getName()), + arguments(constructors().should().haveRawParameterTypes(String.class.getName()), allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), - $(constructors().should().haveRawParameterTypes(oneParameterOfType(String.class)), + arguments(constructors().should().haveRawParameterTypes(oneParameterOfType(String.class)), allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), - $(constructors().should().notHaveRawParameterTypes(String.class), + arguments(constructors().should().notHaveRawParameterTypes(String.class), ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), - $(constructors().should().notHaveRawParameterTypes(String.class.getName()), + arguments(constructors().should().notHaveRawParameterTypes(String.class.getName()), ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), - $(constructors().should().notHaveRawParameterTypes(oneParameterOfType(String.class)), + arguments(constructors().should().notHaveRawParameterTypes(oneParameterOfType(String.class)), ImmutableSet.of(CONSTRUCTOR_ONE_ARG)) ); } @@ -178,43 +178,43 @@ void parameter_types_predicates(ArchRule rule, Collection expectedMember static Stream restricted_return_type_rules() { return Stream.of( - $(codeUnits().should().haveRawReturnType(String.class), + arguments(codeUnits().should().haveRawReturnType(String.class), union(allMethodsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS), ALL_CONSTRUCTOR_DESCRIPTIONS)), - $(codeUnits().should().haveRawReturnType(String.class.getName()), + arguments(codeUnits().should().haveRawReturnType(String.class.getName()), union(allMethodsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS), ALL_CONSTRUCTOR_DESCRIPTIONS)), - $(codeUnits().should().haveRawReturnType(equivalentTo(String.class)), + arguments(codeUnits().should().haveRawReturnType(equivalentTo(String.class)), union(allMethodsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS), ALL_CONSTRUCTOR_DESCRIPTIONS)), - $(codeUnits().should().notHaveRawReturnType(String.class), + arguments(codeUnits().should().notHaveRawReturnType(String.class), ImmutableSet.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(codeUnits().should().notHaveRawReturnType(String.class.getName()), + arguments(codeUnits().should().notHaveRawReturnType(String.class.getName()), ImmutableSet.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(codeUnits().should().notHaveRawReturnType(equivalentTo(String.class)), + arguments(codeUnits().should().notHaveRawReturnType(equivalentTo(String.class)), ImmutableSet.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(methods().should().haveRawReturnType(String.class), + arguments(methods().should().haveRawReturnType(String.class), allMethodsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(methods().should().haveRawReturnType(String.class.getName()), + arguments(methods().should().haveRawReturnType(String.class.getName()), allMethodsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(methods().should().haveRawReturnType(equivalentTo(String.class)), + arguments(methods().should().haveRawReturnType(equivalentTo(String.class)), allMethodsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(methods().should().notHaveRawReturnType(String.class), + arguments(methods().should().notHaveRawReturnType(String.class), ImmutableSet.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(methods().should().notHaveRawReturnType(String.class.getName()), + arguments(methods().should().notHaveRawReturnType(String.class.getName()), ImmutableSet.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(methods().should().notHaveRawReturnType(equivalentTo(String.class)), + arguments(methods().should().notHaveRawReturnType(equivalentTo(String.class)), ImmutableSet.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(constructors().should().haveRawReturnType(String.class), + arguments(constructors().should().haveRawReturnType(String.class), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(constructors().should().haveRawReturnType(String.class.getName()), + arguments(constructors().should().haveRawReturnType(String.class.getName()), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(constructors().should().haveRawReturnType(equivalentTo(String.class)), + arguments(constructors().should().haveRawReturnType(equivalentTo(String.class)), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(constructors().should().notHaveRawReturnType(String.class), + arguments(constructors().should().notHaveRawReturnType(String.class), Collections.emptySet()), - $(constructors().should().notHaveRawReturnType(String.class.getName()), + arguments(constructors().should().notHaveRawReturnType(String.class.getName()), Collections.emptySet()), - $(constructors().should().notHaveRawReturnType(equivalentTo(String.class)), + arguments(constructors().should().notHaveRawReturnType(equivalentTo(String.class)), Collections.emptySet()) ); } @@ -230,44 +230,32 @@ void return_type_predicates(ArchRule rule, Collection expectedMembers) { static Stream restricted_throwable_type_rules() { return Stream.of( - $(codeUnits().should().declareThrowableOfType(FirstException.class), + arguments(codeUnits().should().declareThrowableOfType(FirstException.class), ImmutableSet.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS, CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), - $(codeUnits().should().declareThrowableOfType(FirstException.class.getName()), + arguments(codeUnits().should().declareThrowableOfType(FirstException.class.getName()), ImmutableSet.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS, CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), - $(codeUnits().should().declareThrowableOfType(equivalentTo(FirstException.class)), + arguments(codeUnits().should().declareThrowableOfType(equivalentTo(FirstException.class)), ImmutableSet.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS, CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), - $(codeUnits().should().notDeclareThrowableOfType(FirstException.class), + arguments(codeUnits().should().notDeclareThrowableOfType(FirstException.class), allCodeUnitsExcept(METHOD_TWO_ARGS, METHOD_FOUR_ARGS, CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), - $(codeUnits().should().notDeclareThrowableOfType(FirstException.class.getName()), + arguments(codeUnits().should().notDeclareThrowableOfType(FirstException.class.getName()), allCodeUnitsExcept(METHOD_TWO_ARGS, METHOD_FOUR_ARGS, CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), - $(codeUnits().should().notDeclareThrowableOfType(equivalentTo(FirstException.class)), + arguments(codeUnits().should().notDeclareThrowableOfType(equivalentTo(FirstException.class)), allCodeUnitsExcept(METHOD_TWO_ARGS, METHOD_FOUR_ARGS, CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), - $(methods().should().declareThrowableOfType(FirstException.class), - ImmutableSet.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), - $(methods().should().declareThrowableOfType(FirstException.class.getName()), - ImmutableSet.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), - $(methods().should().declareThrowableOfType(equivalentTo(FirstException.class)), - ImmutableSet.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), - $(methods().should().notDeclareThrowableOfType(FirstException.class), - allMethodsExcept(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), - $(methods().should().notDeclareThrowableOfType(FirstException.class.getName()), - allMethodsExcept(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), - $(methods().should().notDeclareThrowableOfType(equivalentTo(FirstException.class)), - allMethodsExcept(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), - - $(constructors().should().declareThrowableOfType(FirstException.class), - ImmutableSet.of(CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), - $(constructors().should().declareThrowableOfType(FirstException.class.getName()), - ImmutableSet.of(CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), - $(constructors().should().declareThrowableOfType(equivalentTo(FirstException.class)), - ImmutableSet.of(CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), - $(constructors().should().notDeclareThrowableOfType(FirstException.class), - allConstructorsExcept(CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), - $(constructors().should().notDeclareThrowableOfType(FirstException.class.getName()), - allConstructorsExcept(CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), - $(constructors().should().notDeclareThrowableOfType(equivalentTo(FirstException.class)), - allConstructorsExcept(CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)) + arguments(methods().should().declareThrowableOfType(FirstException.class), ImmutableSet.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), + arguments(methods().should().declareThrowableOfType(FirstException.class.getName()), ImmutableSet.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), + arguments(methods().should().declareThrowableOfType(equivalentTo(FirstException.class)), ImmutableSet.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), + arguments(methods().should().notDeclareThrowableOfType(FirstException.class), allMethodsExcept(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), + arguments(methods().should().notDeclareThrowableOfType(FirstException.class.getName()), allMethodsExcept(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), + arguments(methods().should().notDeclareThrowableOfType(equivalentTo(FirstException.class)), allMethodsExcept(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), + + arguments(constructors().should().declareThrowableOfType(FirstException.class), ImmutableSet.of(CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), + arguments(constructors().should().declareThrowableOfType(FirstException.class.getName()), ImmutableSet.of(CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), + arguments(constructors().should().declareThrowableOfType(equivalentTo(FirstException.class)), ImmutableSet.of(CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), + arguments(constructors().should().notDeclareThrowableOfType(FirstException.class), allConstructorsExcept(CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), + arguments(constructors().should().notDeclareThrowableOfType(FirstException.class.getName()), allConstructorsExcept(CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)), + arguments(constructors().should().notDeclareThrowableOfType(equivalentTo(FirstException.class)), allConstructorsExcept(CONSTRUCTOR_TWO_ARGS, CONSTRUCTOR_FOUR_ARGS)) ); } @@ -282,9 +270,9 @@ void throwable_type_predicates(ArchRule rule, Collection expectedMembers static Stream restricted_constructor_calls_by_classes_rules() { return Stream.of( - $(constructors().should(onlyBeCalledByClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)))), - $(constructors().should().onlyBeCalled().byClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class))), - $(constructors().should().onlyBeCalled().byClassesThat().belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)) + arguments(constructors().should(onlyBeCalledByClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)))), + arguments(constructors().should().onlyBeCalled().byClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class))), + arguments(constructors().should().onlyBeCalled().byClassesThat().belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)) ); } @@ -305,9 +293,9 @@ void restricted_constructor_calls_by_classes_predicate(ArchRule rule) { static Stream restricted_method_calls_by_classes_rules() { return Stream.of( - $(methods().should(onlyBeCalledByClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)))), - $(methods().should().onlyBeCalled().byClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class))), - $(methods().should().onlyBeCalled().byClassesThat().belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)) + arguments(methods().should(onlyBeCalledByClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)))), + arguments(methods().should().onlyBeCalled().byClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class))), + arguments(methods().should().onlyBeCalled().byClassesThat().belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)) ); } @@ -328,9 +316,9 @@ void restricted_method_calls_by_classes_predicate(ArchRule rule) { static Stream restricted_code_unit_calls_by_classes_rules() { return Stream.of( - $(codeUnits().should(onlyBeCalledByClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)))), - $(codeUnits().should().onlyBeCalled().byClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class))), - $(codeUnits().should().onlyBeCalled().byClassesThat().belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)) + arguments(codeUnits().should(onlyBeCalledByClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)))), + arguments(codeUnits().should().onlyBeCalled().byClassesThat(belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class))), + arguments(codeUnits().should().onlyBeCalled().byClassesThat().belongToAnyOf(ClassCorrectlyCallingMethodAndConstructor.class)) ); } @@ -356,8 +344,8 @@ void restricted_code_units_calls_by_classes_predicate(ArchRule rule) { static Stream restricted_code_unit_calls_by_methods_rules() { return Stream.of( - $(codeUnits().should(onlyBeCalledByMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), - $(codeUnits().should().onlyBeCalled().byMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) + arguments(codeUnits().should(onlyBeCalledByMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), + arguments(codeUnits().should().onlyBeCalled().byMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } @@ -393,8 +381,8 @@ void restricted_code_units_calls_by_methods_predicate(ArchRule rule) { static Stream restricted_code_unit_calls_by_constructors_rules() { return Stream.of( - $(codeUnits().should(onlyBeCalledByConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), - $(codeUnits().should().onlyBeCalled().byConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) + arguments(codeUnits().should(onlyBeCalledByConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), + arguments(codeUnits().should().onlyBeCalled().byConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } @@ -430,8 +418,8 @@ void restricted_code_units_calls_by_constructors_predicate(ArchRule rule) { static Stream restricted_code_unit_calls_by_code_units_rules() { return Stream.of( - $(codeUnits().should(onlyBeCalledByCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), - $(codeUnits().should().onlyBeCalled().byCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) + arguments(codeUnits().should(onlyBeCalledByCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), + arguments(codeUnits().should().onlyBeCalled().byCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } @@ -457,8 +445,8 @@ void restricted_code_units_calls_by_code_units_predicate(ArchRule rule) { static Stream restricted_methods_calls_by_methods_rules() { return Stream.of( - $(methods().should(onlyBeCalledByMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), - $(methods().should().onlyBeCalled().byMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) + arguments(methods().should(onlyBeCalledByMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), + arguments(methods().should().onlyBeCalled().byMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } @@ -484,8 +472,8 @@ void restricted_methods_calls_by_methods_predicate(ArchRule rule) { static Stream restricted_methods_calls_by_constructors_rules() { return Stream.of( - $(methods().should(onlyBeCalledByConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), - $(methods().should().onlyBeCalled().byConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) + arguments(methods().should(onlyBeCalledByConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), + arguments(methods().should().onlyBeCalled().byConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } @@ -511,8 +499,8 @@ void restricted_methods_calls_by_constructors_predicate(ArchRule rule) { static Stream restricted_methods_calls_by_code_units_rules() { return Stream.of( - $(methods().should(onlyBeCalledByCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), - $(methods().should().onlyBeCalled().byCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) + arguments(methods().should(onlyBeCalledByCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), + arguments(methods().should().onlyBeCalled().byCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } @@ -533,8 +521,8 @@ void restricted_methods_calls_by_code_units_predicate(ArchRule rule) { static Stream restricted_constructors_calls_by_methods_rules() { return Stream.of( - $(constructors().should(onlyBeCalledByMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), - $(constructors().should().onlyBeCalled().byMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) + arguments(constructors().should(onlyBeCalledByMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), + arguments(constructors().should().onlyBeCalled().byMethodsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } @@ -560,8 +548,8 @@ void restricted_constructors_calls_by_methods_predicate(ArchRule rule) { static Stream restricted_constructors_calls_by_constructors_rules() { return Stream.of( - $(constructors().should(onlyBeCalledByConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), - $(constructors().should().onlyBeCalled().byConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) + arguments(constructors().should(onlyBeCalledByConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))), + arguments(constructors().should().onlyBeCalled().byConstructorsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))) ); } @@ -587,8 +575,8 @@ void restricted_constructors_calls_by_constructors_predicate(ArchRule rule) { static Stream restricted_constructors_calls_by_code_units_rules() { return Stream.of( - $(constructors().should().onlyBeCalled().byCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))), - $(constructors().should(onlyBeCalledByCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))) + arguments(constructors().should().onlyBeCalled().byCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class))), + arguments(constructors().should(onlyBeCalledByCodeUnitsThat(declaredIn(ClassCorrectlyCallingMethodAndConstructor.class)))) ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/FieldsShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/FieldsShouldTest.java index e556455277..a1dee58b36 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/FieldsShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/FieldsShouldTest.java @@ -26,9 +26,9 @@ import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.assertViolation; import static com.tngtech.archunit.lang.syntax.elements.MembersShouldTest.parseMembers; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; -import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.regex.Pattern.quote; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class FieldsShouldTest { @@ -51,16 +51,16 @@ public void complex_field_syntax() { static Stream restricted_property_rule_ends() { return Stream.of( - $(fields().should().haveRawType(String.class), ImmutableList.of(FIELD_B, FIELD_C, FIELD_D)), - $(fields().should().haveRawType(String.class.getName()), ImmutableList.of(FIELD_B, FIELD_C, FIELD_D)), - $(fields().should().haveRawType(equivalentTo(String.class).as(String.class.getName())), ImmutableList.of(FIELD_B, FIELD_C, FIELD_D)), - $(fields().should().notHaveRawType(String.class), ImmutableList.of(FIELD_A)), - $(fields().should().notHaveRawType(String.class.getName()), ImmutableList.of(FIELD_A)), - $(fields().should().notHaveRawType(equivalentTo(String.class).as(String.class.getName())), ImmutableList.of(FIELD_A)), - $(fields().should().beFinal(), ImmutableList.of(FIELD_C, FIELD_D)), - $(fields().should().notBeFinal(), ImmutableList.of(FIELD_A, FIELD_B)), - $(fields().should().beStatic(), ImmutableList.of(FIELD_A, FIELD_C)), - $(fields().should().notBeStatic(), ImmutableList.of(FIELD_B, FIELD_D)) + arguments(fields().should().haveRawType(String.class), ImmutableList.of(FIELD_B, FIELD_C, FIELD_D)), + arguments(fields().should().haveRawType(String.class.getName()), ImmutableList.of(FIELD_B, FIELD_C, FIELD_D)), + arguments(fields().should().haveRawType(equivalentTo(String.class).as(String.class.getName())), ImmutableList.of(FIELD_B, FIELD_C, FIELD_D)), + arguments(fields().should().notHaveRawType(String.class), ImmutableList.of(FIELD_A)), + arguments(fields().should().notHaveRawType(String.class.getName()), ImmutableList.of(FIELD_A)), + arguments(fields().should().notHaveRawType(equivalentTo(String.class).as(String.class.getName())), ImmutableList.of(FIELD_A)), + arguments(fields().should().beFinal(), ImmutableList.of(FIELD_C, FIELD_D)), + arguments(fields().should().notBeFinal(), ImmutableList.of(FIELD_A, FIELD_B)), + arguments(fields().should().beStatic(), ImmutableList.of(FIELD_A, FIELD_C)), + arguments(fields().should().notBeStatic(), ImmutableList.of(FIELD_B, FIELD_D)) ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassShouldTest.java index 152acac74b..4ea868e9f8 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassShouldTest.java @@ -33,8 +33,8 @@ import static com.tngtech.archunit.lang.syntax.elements.ClassesShouldTest.singleLineFailureReportOf; import static com.tngtech.archunit.testutil.Assertions.assertThat; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; -import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.regex.Pattern.quote; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class GivenClassShouldTest { @@ -42,13 +42,13 @@ public class GivenClassShouldTest { static Stream theClass_should_haveFullyQualifiedName_rules() { return Stream.of( - $(theClass(SomeClass.class).should().haveFullyQualifiedName(SomeClass.class.getName()), + arguments(theClass(SomeClass.class).should().haveFullyQualifiedName(SomeClass.class.getName()), theClass(SomeClass.class).should().notHaveFullyQualifiedName(SomeClass.class.getName())), - $(theClass(SomeClass.class).should(ArchConditions.haveFullyQualifiedName(SomeClass.class.getName())), + arguments(theClass(SomeClass.class).should(ArchConditions.haveFullyQualifiedName(SomeClass.class.getName())), theClass(SomeClass.class).should(ArchConditions.notHaveFullyQualifiedName(SomeClass.class.getName()))), - $(theClass(SomeClass.class.getName()).should().haveFullyQualifiedName(SomeClass.class.getName()), + arguments(theClass(SomeClass.class.getName()).should().haveFullyQualifiedName(SomeClass.class.getName()), theClass(SomeClass.class.getName()).should().notHaveFullyQualifiedName(SomeClass.class.getName())), - $(theClass(SomeClass.class.getName()).should(ArchConditions.haveFullyQualifiedName(SomeClass.class.getName())), + arguments(theClass(SomeClass.class.getName()).should(ArchConditions.haveFullyQualifiedName(SomeClass.class.getName())), theClass(SomeClass.class.getName()).should(ArchConditions.notHaveFullyQualifiedName(SomeClass.class.getName()))) ); } @@ -71,13 +71,13 @@ void theClass_should_haveFullyQualifiedName(ArchRule satisfiedRule, ArchRule uns static Stream noClass_should_haveFullyQualifiedName_rules() { return Stream.of( - $(noClass(SomeClass.class).should().notHaveFullyQualifiedName(SomeClass.class.getName()), + arguments(noClass(SomeClass.class).should().notHaveFullyQualifiedName(SomeClass.class.getName()), noClass(SomeClass.class).should().haveFullyQualifiedName(SomeClass.class.getName())), - $(noClass(SomeClass.class).should(ArchConditions.notHaveFullyQualifiedName(SomeClass.class.getName())), + arguments(noClass(SomeClass.class).should(ArchConditions.notHaveFullyQualifiedName(SomeClass.class.getName())), noClass(SomeClass.class).should(ArchConditions.haveFullyQualifiedName(SomeClass.class.getName()))), - $(noClass(SomeClass.class.getName()).should().notHaveFullyQualifiedName(SomeClass.class.getName()), + arguments(noClass(SomeClass.class.getName()).should().notHaveFullyQualifiedName(SomeClass.class.getName()), noClass(SomeClass.class.getName()).should().haveFullyQualifiedName(SomeClass.class.getName())), - $(noClass(SomeClass.class.getName()).should(ArchConditions.notHaveFullyQualifiedName(SomeClass.class.getName())), + arguments(noClass(SomeClass.class.getName()).should(ArchConditions.notHaveFullyQualifiedName(SomeClass.class.getName())), noClass(SomeClass.class.getName()).should(ArchConditions.haveFullyQualifiedName(SomeClass.class.getName()))) ); } @@ -99,13 +99,13 @@ void noClass_should_haveFullyQualifiedName(ArchRule satisfiedRule, ArchRule unsa static Stream theClass_should_haveSimpleName_rules() { return Stream.of( - $(theClass(SomeClass.class).should().haveSimpleName(SomeClass.class.getSimpleName()), + arguments(theClass(SomeClass.class).should().haveSimpleName(SomeClass.class.getSimpleName()), theClass(SomeClass.class).should().notHaveSimpleName(SomeClass.class.getSimpleName())), - $(theClass(SomeClass.class).should(ArchConditions.haveSimpleName(SomeClass.class.getSimpleName())), + arguments(theClass(SomeClass.class).should(ArchConditions.haveSimpleName(SomeClass.class.getSimpleName())), theClass(SomeClass.class).should(ArchConditions.notHaveSimpleName(SomeClass.class.getSimpleName()))), - $(theClass(SomeClass.class.getName()).should().haveSimpleName(SomeClass.class.getSimpleName()), + arguments(theClass(SomeClass.class.getName()).should().haveSimpleName(SomeClass.class.getSimpleName()), theClass(SomeClass.class.getName()).should().notHaveSimpleName(SomeClass.class.getSimpleName())), - $(theClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleName(SomeClass.class.getSimpleName())), + arguments(theClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleName(SomeClass.class.getSimpleName())), theClass(SomeClass.class.getName()).should(ArchConditions.notHaveSimpleName(SomeClass.class.getSimpleName()))) ); } @@ -127,13 +127,13 @@ void haveSimpleName(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { static Stream noClass_should_haveSimpleName_rules() { return Stream.of( - $(noClass(SomeClass.class).should().notHaveSimpleName(SomeClass.class.getSimpleName()), + arguments(noClass(SomeClass.class).should().notHaveSimpleName(SomeClass.class.getSimpleName()), noClass(SomeClass.class).should().haveSimpleName(SomeClass.class.getSimpleName())), - $(noClass(SomeClass.class).should(ArchConditions.notHaveSimpleName(SomeClass.class.getSimpleName())), + arguments(noClass(SomeClass.class).should(ArchConditions.notHaveSimpleName(SomeClass.class.getSimpleName())), noClass(SomeClass.class).should(ArchConditions.haveSimpleName(SomeClass.class.getSimpleName()))), - $(noClass(SomeClass.class.getName()).should().notHaveSimpleName(SomeClass.class.getSimpleName()), + arguments(noClass(SomeClass.class.getName()).should().notHaveSimpleName(SomeClass.class.getSimpleName()), noClass(SomeClass.class.getName()).should().haveSimpleName(SomeClass.class.getSimpleName())), - $(noClass(SomeClass.class.getName()).should(ArchConditions.notHaveSimpleName(SomeClass.class.getSimpleName())), + arguments(noClass(SomeClass.class.getName()).should(ArchConditions.notHaveSimpleName(SomeClass.class.getSimpleName())), noClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleName(SomeClass.class.getSimpleName()))) ); } @@ -156,13 +156,13 @@ void noClass_should_haveSimpleName(ArchRule satisfiedRule, ArchRule unsatisfiedR static Stream theClass_should_haveNameMatching_rules() { String regex = containsPartOfRegex(SomeClass.class.getSimpleName()); return Stream.of( - $(theClass(SomeClass.class).should().haveNameMatching(regex), + arguments(theClass(SomeClass.class).should().haveNameMatching(regex), theClass(SomeClass.class).should().haveNameNotMatching(regex)), - $(theClass(SomeClass.class).should(ArchConditions.haveNameMatching(regex)), + arguments(theClass(SomeClass.class).should(ArchConditions.haveNameMatching(regex)), theClass(SomeClass.class).should(ArchConditions.haveNameNotMatching(regex))), - $(theClass(SomeClass.class.getName()).should().haveNameMatching(regex), + arguments(theClass(SomeClass.class.getName()).should().haveNameMatching(regex), theClass(SomeClass.class.getName()).should().haveNameNotMatching(regex)), - $(theClass(SomeClass.class.getName()).should(ArchConditions.haveNameMatching(regex)), + arguments(theClass(SomeClass.class.getName()).should(ArchConditions.haveNameMatching(regex)), theClass(SomeClass.class.getName()).should(ArchConditions.haveNameNotMatching(regex))) ); } @@ -187,13 +187,13 @@ void theClass_should_haveNameMatching(ArchRule satisfiedRule, ArchRule unsatisfi static Stream noClass_should_haveNameMatching_rules() { String regex = containsPartOfRegex(SomeClass.class.getSimpleName()); return Stream.of( - $(noClass(SomeClass.class).should().haveNameNotMatching(regex), + arguments(noClass(SomeClass.class).should().haveNameNotMatching(regex), noClass(SomeClass.class).should().haveNameMatching(regex)), - $(noClass(SomeClass.class).should(ArchConditions.haveNameNotMatching(regex)), + arguments(noClass(SomeClass.class).should(ArchConditions.haveNameNotMatching(regex)), noClass(SomeClass.class).should(ArchConditions.haveNameMatching(regex))), - $(noClass(SomeClass.class.getName()).should().haveNameNotMatching(regex), + arguments(noClass(SomeClass.class.getName()).should().haveNameNotMatching(regex), noClass(SomeClass.class.getName()).should().haveNameMatching(regex)), - $(noClass(SomeClass.class.getName()).should(ArchConditions.haveNameNotMatching(regex)), + arguments(noClass(SomeClass.class.getName()).should(ArchConditions.haveNameNotMatching(regex)), noClass(SomeClass.class.getName()).should(ArchConditions.haveNameMatching(regex))) ); } @@ -219,13 +219,13 @@ static Stream theClass_should_haveSimpleNameStartingWith_rules() { String simpleName = SomeClass.class.getSimpleName(); String prefix = simpleName.substring(0, simpleName.length() - 1); return Stream.of( - $(theClass(SomeClass.class).should().haveSimpleNameStartingWith(prefix), + arguments(theClass(SomeClass.class).should().haveSimpleNameStartingWith(prefix), theClass(SomeClass.class).should().haveSimpleNameNotStartingWith(prefix)), - $(theClass(SomeClass.class).should(ArchConditions.haveSimpleNameStartingWith(prefix)), + arguments(theClass(SomeClass.class).should(ArchConditions.haveSimpleNameStartingWith(prefix)), theClass(SomeClass.class).should(ArchConditions.haveSimpleNameNotStartingWith(prefix))), - $(theClass(SomeClass.class.getName()).should().haveSimpleNameStartingWith(prefix), + arguments(theClass(SomeClass.class.getName()).should().haveSimpleNameStartingWith(prefix), theClass(SomeClass.class.getName()).should().haveSimpleNameNotStartingWith(prefix)), - $(theClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameStartingWith(prefix)), + arguments(theClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameStartingWith(prefix)), theClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameNotStartingWith(prefix))) ); } @@ -251,13 +251,13 @@ static Stream noClass_should_haveSimpleNameStartingWith_rules() { String simpleName = SomeClass.class.getSimpleName(); String prefix = simpleName.substring(0, simpleName.length() - 1); return Stream.of( - $(noClass(SomeClass.class).should().haveSimpleNameNotStartingWith(prefix), + arguments(noClass(SomeClass.class).should().haveSimpleNameNotStartingWith(prefix), noClass(SomeClass.class).should().haveSimpleNameStartingWith(prefix)), - $(noClass(SomeClass.class).should(ArchConditions.haveSimpleNameNotStartingWith(prefix)), + arguments(noClass(SomeClass.class).should(ArchConditions.haveSimpleNameNotStartingWith(prefix)), noClass(SomeClass.class).should(ArchConditions.haveSimpleNameStartingWith(prefix))), - $(noClass(SomeClass.class.getName()).should().haveSimpleNameNotStartingWith(prefix), + arguments(noClass(SomeClass.class.getName()).should().haveSimpleNameNotStartingWith(prefix), noClass(SomeClass.class.getName()).should().haveSimpleNameStartingWith(prefix)), - $(noClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameNotStartingWith(prefix)), + arguments(noClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameNotStartingWith(prefix)), noClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameStartingWith(prefix))) ); } @@ -283,13 +283,13 @@ static Stream theClass_should_haveSimpleNameContaining_rules() { String simpleName = SomeClass.class.getSimpleName(); String infix = simpleName.substring(1, simpleName.length() - 1); return Stream.of( - $(theClass(SomeClass.class).should().haveSimpleNameContaining(infix), + arguments(theClass(SomeClass.class).should().haveSimpleNameContaining(infix), theClass(SomeClass.class).should().haveSimpleNameNotContaining(infix)), - $(theClass(SomeClass.class).should(ArchConditions.haveSimpleNameContaining(infix)), + arguments(theClass(SomeClass.class).should(ArchConditions.haveSimpleNameContaining(infix)), theClass(SomeClass.class).should(ArchConditions.haveSimpleNameNotContaining(infix))), - $(theClass(SomeClass.class.getName()).should().haveSimpleNameContaining(infix), + arguments(theClass(SomeClass.class.getName()).should().haveSimpleNameContaining(infix), theClass(SomeClass.class.getName()).should().haveSimpleNameNotContaining(infix)), - $(theClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameContaining(infix)), + arguments(theClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameContaining(infix)), theClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameNotContaining(infix))) ); } @@ -315,13 +315,13 @@ static Stream noClass_should_haveSimpleNameContaining_rules() { String simpleName = SomeClass.class.getSimpleName(); String infix = simpleName.substring(1, simpleName.length() - 1); return Stream.of( - $(noClass(SomeClass.class).should().haveSimpleNameNotContaining(infix), + arguments(noClass(SomeClass.class).should().haveSimpleNameNotContaining(infix), noClass(SomeClass.class).should().haveSimpleNameContaining(infix)), - $(noClass(SomeClass.class).should(ArchConditions.haveSimpleNameNotContaining(infix)), + arguments(noClass(SomeClass.class).should(ArchConditions.haveSimpleNameNotContaining(infix)), noClass(SomeClass.class).should(ArchConditions.haveSimpleNameContaining(infix))), - $(noClass(SomeClass.class.getName()).should().haveSimpleNameNotContaining(infix), + arguments(noClass(SomeClass.class.getName()).should().haveSimpleNameNotContaining(infix), noClass(SomeClass.class.getName()).should().haveSimpleNameContaining(infix)), - $(noClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameNotContaining(infix)), + arguments(noClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameNotContaining(infix)), noClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameContaining(infix))) ); } @@ -348,13 +348,13 @@ static Stream theClass_should_haveSimpleNameEndingWith_rules() { String suffix = simpleName.substring(1); return Stream.of( - $(theClass(SomeClass.class).should().haveSimpleNameEndingWith(suffix), + arguments(theClass(SomeClass.class).should().haveSimpleNameEndingWith(suffix), theClass(SomeClass.class).should().haveSimpleNameNotEndingWith(suffix)), - $(theClass(SomeClass.class).should(ArchConditions.haveSimpleNameEndingWith(suffix)), + arguments(theClass(SomeClass.class).should(ArchConditions.haveSimpleNameEndingWith(suffix)), theClass(SomeClass.class).should(ArchConditions.haveSimpleNameNotEndingWith(suffix))), - $(theClass(SomeClass.class.getName()).should().haveSimpleNameEndingWith(suffix), + arguments(theClass(SomeClass.class.getName()).should().haveSimpleNameEndingWith(suffix), theClass(SomeClass.class.getName()).should().haveSimpleNameNotEndingWith(suffix)), - $(theClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameEndingWith(suffix)), + arguments(theClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameEndingWith(suffix)), theClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameNotEndingWith(suffix))) ); } @@ -380,13 +380,13 @@ static Stream noClass_should_haveSimpleNameEndingWith_rules() { String simpleName = SomeClass.class.getSimpleName(); String suffix = simpleName.substring(1); return Stream.of( - $(noClass(SomeClass.class).should().haveSimpleNameNotEndingWith(suffix), + arguments(noClass(SomeClass.class).should().haveSimpleNameNotEndingWith(suffix), noClass(SomeClass.class).should().haveSimpleNameEndingWith(suffix)), - $(noClass(SomeClass.class).should(ArchConditions.haveSimpleNameNotEndingWith(suffix)), + arguments(noClass(SomeClass.class).should(ArchConditions.haveSimpleNameNotEndingWith(suffix)), noClass(SomeClass.class).should(ArchConditions.haveSimpleNameEndingWith(suffix))), - $(noClass(SomeClass.class.getName()).should().haveSimpleNameNotEndingWith(suffix), + arguments(noClass(SomeClass.class.getName()).should().haveSimpleNameNotEndingWith(suffix), noClass(SomeClass.class.getName()).should().haveSimpleNameEndingWith(suffix)), - $(noClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameNotEndingWith(suffix)), + arguments(noClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameNotEndingWith(suffix)), noClass(SomeClass.class.getName()).should(ArchConditions.haveSimpleNameEndingWith(suffix))) ); } @@ -411,13 +411,13 @@ void noClass_should_haveSimpleNameEndingWith(ArchRule satisfiedRule, ArchRule un static Stream theClass_should_resideInAPackage_rules() { String thePackage = SomeClass.class.getPackage().getName(); return Stream.of( - $(theClass(SomeClass.class).should().resideInAPackage(thePackage), + arguments(theClass(SomeClass.class).should().resideInAPackage(thePackage), theClass(SomeClass.class).should().resideOutsideOfPackage(thePackage)), - $(theClass(SomeClass.class).should(ArchConditions.resideInAPackage(thePackage)), + arguments(theClass(SomeClass.class).should(ArchConditions.resideInAPackage(thePackage)), theClass(SomeClass.class).should(ArchConditions.resideOutsideOfPackage(thePackage))), - $(theClass(SomeClass.class.getName()).should().resideInAPackage(thePackage), + arguments(theClass(SomeClass.class.getName()).should().resideInAPackage(thePackage), theClass(SomeClass.class.getName()).should().resideOutsideOfPackage(thePackage)), - $(theClass(SomeClass.class.getName()).should(ArchConditions.resideInAPackage(thePackage)), + arguments(theClass(SomeClass.class.getName()).should(ArchConditions.resideInAPackage(thePackage)), theClass(SomeClass.class.getName()).should(ArchConditions.resideOutsideOfPackage(thePackage))) ); } @@ -441,13 +441,13 @@ void theClass_should_resideInAPackage(ArchRule satisfiedRule, ArchRule unsatisfi static Stream noClass_should_resideInAPackage_rules() { String thePackage = SomeClass.class.getPackage().getName(); return Stream.of( - $(noClass(SomeClass.class).should().resideOutsideOfPackage(thePackage), + arguments(noClass(SomeClass.class).should().resideOutsideOfPackage(thePackage), noClass(SomeClass.class).should().resideInAPackage(thePackage)), - $(noClass(SomeClass.class).should(ArchConditions.resideOutsideOfPackage(thePackage)), + arguments(noClass(SomeClass.class).should(ArchConditions.resideOutsideOfPackage(thePackage)), noClass(SomeClass.class).should(ArchConditions.resideInAPackage(thePackage))), - $(noClass(SomeClass.class.getName()).should().resideOutsideOfPackage(thePackage), + arguments(noClass(SomeClass.class.getName()).should().resideOutsideOfPackage(thePackage), noClass(SomeClass.class.getName()).should().resideInAPackage(thePackage)), - $(noClass(SomeClass.class.getName()).should(ArchConditions.resideOutsideOfPackage(thePackage)), + arguments(noClass(SomeClass.class.getName()).should(ArchConditions.resideOutsideOfPackage(thePackage)), noClass(SomeClass.class.getName()).should(ArchConditions.resideInAPackage(thePackage))) ); } @@ -473,13 +473,13 @@ static Stream theClass_should_resideInAnyPackage_rules() { String firstPackage = SomeClass.class.getPackage().getName(); String secondPackage = Object.class.getPackage().getName(); return Stream.of( - $(theClass(SomeClass.class).should().resideInAnyPackage(firstPackage, secondPackage), + arguments(theClass(SomeClass.class).should().resideInAnyPackage(firstPackage, secondPackage), theClass(SomeClass.class).should().resideOutsideOfPackages(firstPackage, secondPackage)), - $(theClass(SomeClass.class).should(ArchConditions.resideInAnyPackage(firstPackage, secondPackage)), + arguments(theClass(SomeClass.class).should(ArchConditions.resideInAnyPackage(firstPackage, secondPackage)), theClass(SomeClass.class).should(ArchConditions.resideOutsideOfPackages(firstPackage, secondPackage))), - $(theClass(SomeClass.class.getName()).should().resideInAnyPackage(firstPackage, secondPackage), + arguments(theClass(SomeClass.class.getName()).should().resideInAnyPackage(firstPackage, secondPackage), theClass(SomeClass.class.getName()).should().resideOutsideOfPackages(firstPackage, secondPackage)), - $(theClass(SomeClass.class.getName()).should(ArchConditions.resideInAnyPackage(firstPackage, secondPackage)), + arguments(theClass(SomeClass.class.getName()).should(ArchConditions.resideInAnyPackage(firstPackage, secondPackage)), theClass(SomeClass.class.getName()).should(ArchConditions.resideOutsideOfPackages(firstPackage, secondPackage))) ); } @@ -510,13 +510,13 @@ static Stream noClass_should_resideInAnyPackage_rules() { String secondPackage = Object.class.getPackage().getName(); return Stream.of( - $(noClass(SomeClass.class).should().resideOutsideOfPackages(firstPackage, secondPackage), + arguments(noClass(SomeClass.class).should().resideOutsideOfPackages(firstPackage, secondPackage), noClass(SomeClass.class).should().resideInAnyPackage(firstPackage, secondPackage)), - $(noClass(SomeClass.class).should(ArchConditions.resideOutsideOfPackages(firstPackage, secondPackage)), + arguments(noClass(SomeClass.class).should(ArchConditions.resideOutsideOfPackages(firstPackage, secondPackage)), noClass(SomeClass.class).should(ArchConditions.resideInAnyPackage(firstPackage, secondPackage))), - $(noClass(SomeClass.class.getName()).should().resideOutsideOfPackages(firstPackage, secondPackage), + arguments(noClass(SomeClass.class.getName()).should().resideOutsideOfPackages(firstPackage, secondPackage), noClass(SomeClass.class.getName()).should().resideInAnyPackage(firstPackage, secondPackage)), - $(noClass(SomeClass.class.getName()).should(ArchConditions.resideOutsideOfPackages(firstPackage, secondPackage)), + arguments(noClass(SomeClass.class.getName()).should(ArchConditions.resideOutsideOfPackages(firstPackage, secondPackage)), noClass(SomeClass.class.getName()).should(ArchConditions.resideInAnyPackage(firstPackage, secondPackage))) ); } @@ -544,13 +544,13 @@ void noClass_should_resideInAnyPackage(ArchRule satisfiedRule, ArchRule unsatisf static Stream theClass_should_bePublic_rules() { return Stream.of( - $(theClass(SomeClass.class).should().bePublic(), + arguments(theClass(SomeClass.class).should().bePublic(), theClass(SomeClass.class).should().notBePublic()), - $(theClass(SomeClass.class).should(ArchConditions.bePublic()), + arguments(theClass(SomeClass.class).should(ArchConditions.bePublic()), theClass(SomeClass.class).should(ArchConditions.notBePublic())), - $(theClass(SomeClass.class.getName()).should().bePublic(), + arguments(theClass(SomeClass.class.getName()).should().bePublic(), theClass(SomeClass.class.getName()).should().notBePublic()), - $(theClass(SomeClass.class.getName()).should(ArchConditions.bePublic()), + arguments(theClass(SomeClass.class.getName()).should(ArchConditions.bePublic()), theClass(SomeClass.class.getName()).should(ArchConditions.notBePublic())) ); } @@ -572,13 +572,13 @@ void theClass_should_bePublic(ArchRule satisfiedRule, ArchRule unsatisfiedRule) static Stream noClass_should_bePublic_rules() { return Stream.of( - $(noClass(SomeClass.class).should().notBePublic(), + arguments(noClass(SomeClass.class).should().notBePublic(), noClass(SomeClass.class).should().bePublic()), - $(noClass(SomeClass.class).should(ArchConditions.notBePublic()), + arguments(noClass(SomeClass.class).should(ArchConditions.notBePublic()), noClass(SomeClass.class).should(ArchConditions.bePublic())), - $(noClass(SomeClass.class.getName()).should().notBePublic(), + arguments(noClass(SomeClass.class.getName()).should().notBePublic(), noClass(SomeClass.class.getName()).should().bePublic()), - $(noClass(SomeClass.class.getName()).should(ArchConditions.notBePublic()), + arguments(noClass(SomeClass.class.getName()).should(ArchConditions.notBePublic()), noClass(SomeClass.class.getName()).should(ArchConditions.bePublic())) ); } @@ -600,13 +600,13 @@ void noClass_should_bePublic(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { static Stream theClass_should_bePrivate_rules() { return Stream.of( - $(theClass(PrivateClass.class).should().bePrivate(), + arguments(theClass(PrivateClass.class).should().bePrivate(), theClass(PrivateClass.class).should().notBePrivate()), - $(theClass(PrivateClass.class).should(ArchConditions.bePrivate()), + arguments(theClass(PrivateClass.class).should(ArchConditions.bePrivate()), theClass(PrivateClass.class).should(ArchConditions.notBePrivate())), - $(theClass(PrivateClass.class.getName()).should().bePrivate(), + arguments(theClass(PrivateClass.class.getName()).should().bePrivate(), theClass(PrivateClass.class.getName()).should().notBePrivate()), - $(theClass(PrivateClass.class.getName()).should(ArchConditions.bePrivate()), + arguments(theClass(PrivateClass.class.getName()).should(ArchConditions.bePrivate()), theClass(PrivateClass.class.getName()).should(ArchConditions.notBePrivate())) ); } @@ -628,13 +628,13 @@ void theClass_should_bePrivate(ArchRule satisfiedRule, ArchRule unsatisfiedRule) static Stream noClass_should_bePrivate_rules() { return Stream.of( - $(noClass(PrivateClass.class).should().notBePrivate(), + arguments(noClass(PrivateClass.class).should().notBePrivate(), noClass(PrivateClass.class).should().bePrivate()), - $(noClass(PrivateClass.class).should(ArchConditions.notBePrivate()), + arguments(noClass(PrivateClass.class).should(ArchConditions.notBePrivate()), noClass(PrivateClass.class).should(ArchConditions.bePrivate())), - $(noClass(PrivateClass.class.getName()).should().notBePrivate(), + arguments(noClass(PrivateClass.class.getName()).should().notBePrivate(), noClass(PrivateClass.class.getName()).should().bePrivate()), - $(noClass(PrivateClass.class.getName()).should(ArchConditions.notBePrivate()), + arguments(noClass(PrivateClass.class.getName()).should(ArchConditions.notBePrivate()), noClass(PrivateClass.class.getName()).should(ArchConditions.bePrivate())) ); } @@ -656,13 +656,13 @@ void noClass_should_bePrivate(ArchRule satisfiedRule, ArchRule unsatisfiedRule) static Stream theClass_should_haveOnlyFinalFields_rules() { return Stream.of( - $(theClass(ClassWithFinalFields.class).should().haveOnlyFinalFields(), + arguments(theClass(ClassWithFinalFields.class).should().haveOnlyFinalFields(), theClass(ClassWithNonFinalFields.class).should().haveOnlyFinalFields()), - $(theClass(ClassWithFinalFields.class).should(ArchConditions.haveOnlyFinalFields()), + arguments(theClass(ClassWithFinalFields.class).should(ArchConditions.haveOnlyFinalFields()), theClass(ClassWithNonFinalFields.class).should(ArchConditions.haveOnlyFinalFields())), - $(theClass(ClassWithFinalFields.class.getName()).should().haveOnlyFinalFields(), + arguments(theClass(ClassWithFinalFields.class.getName()).should().haveOnlyFinalFields(), theClass(ClassWithNonFinalFields.class.getName()).should().haveOnlyFinalFields()), - $(theClass(ClassWithFinalFields.class.getName()).should(ArchConditions.haveOnlyFinalFields()), + arguments(theClass(ClassWithFinalFields.class.getName()).should(ArchConditions.haveOnlyFinalFields()), theClass(ClassWithNonFinalFields.class.getName()).should(ArchConditions.haveOnlyFinalFields())) ); } @@ -686,13 +686,13 @@ void theClass_should_haveOnlyFinalFields(ArchRule satisfiedRule, ArchRule unsati static Stream noClass_should_haveOnlyFinalFields_rules() { return Stream.of( - $(noClass(ClassWithNonFinalFields.class).should().haveOnlyFinalFields(), + arguments(noClass(ClassWithNonFinalFields.class).should().haveOnlyFinalFields(), noClass(ClassWithFinalFields.class).should().haveOnlyFinalFields()), - $(noClass(ClassWithNonFinalFields.class).should(ArchConditions.haveOnlyFinalFields()), + arguments(noClass(ClassWithNonFinalFields.class).should(ArchConditions.haveOnlyFinalFields()), noClass(ClassWithFinalFields.class).should(ArchConditions.haveOnlyFinalFields())), - $(noClass(ClassWithNonFinalFields.class.getName()).should().haveOnlyFinalFields(), + arguments(noClass(ClassWithNonFinalFields.class.getName()).should().haveOnlyFinalFields(), noClass(ClassWithFinalFields.class.getName()).should().haveOnlyFinalFields()), - $(noClass(ClassWithNonFinalFields.class.getName()).should(ArchConditions.haveOnlyFinalFields()), + arguments(noClass(ClassWithNonFinalFields.class.getName()).should(ArchConditions.haveOnlyFinalFields()), noClass(ClassWithFinalFields.class.getName()).should(ArchConditions.haveOnlyFinalFields())) ); } @@ -731,13 +731,13 @@ void classes_should_have_only_private_constructor(ArchRule rule) { static Stream theClass_should_beProtected_rules() { return Stream.of( - $(theClass(ProtectedClass.class).should().beProtected(), + arguments(theClass(ProtectedClass.class).should().beProtected(), theClass(ProtectedClass.class).should().notBeProtected()), - $(theClass(ProtectedClass.class).should(ArchConditions.beProtected()), + arguments(theClass(ProtectedClass.class).should(ArchConditions.beProtected()), theClass(ProtectedClass.class).should(ArchConditions.notBeProtected())), - $(theClass(ProtectedClass.class.getName()).should().beProtected(), + arguments(theClass(ProtectedClass.class.getName()).should().beProtected(), theClass(ProtectedClass.class.getName()).should().notBeProtected()), - $(theClass(ProtectedClass.class.getName()).should(ArchConditions.beProtected()), + arguments(theClass(ProtectedClass.class.getName()).should(ArchConditions.beProtected()), theClass(ProtectedClass.class.getName()).should(ArchConditions.notBeProtected())) ); } @@ -759,13 +759,13 @@ void theClass_should_beProtected(ArchRule satisfiedRule, ArchRule unsatisfiedRul static Stream noClass_should_beProtected_rules() { return Stream.of( - $(noClass(ProtectedClass.class).should().notBeProtected(), + arguments(noClass(ProtectedClass.class).should().notBeProtected(), noClass(ProtectedClass.class).should().beProtected()), - $(noClass(ProtectedClass.class).should(ArchConditions.notBeProtected()), + arguments(noClass(ProtectedClass.class).should(ArchConditions.notBeProtected()), noClass(ProtectedClass.class).should(ArchConditions.beProtected())), - $(noClass(ProtectedClass.class.getName()).should().notBeProtected(), + arguments(noClass(ProtectedClass.class.getName()).should().notBeProtected(), noClass(ProtectedClass.class.getName()).should().beProtected()), - $(noClass(ProtectedClass.class.getName()).should(ArchConditions.notBeProtected()), + arguments(noClass(ProtectedClass.class.getName()).should(ArchConditions.notBeProtected()), noClass(ProtectedClass.class.getName()).should(ArchConditions.beProtected())) ); } @@ -787,13 +787,13 @@ void noClass_should_beProtected(ArchRule satisfiedRule, ArchRule unsatisfiedRule static Stream theClass_should_bePackagePrivate_rules() { return Stream.of( - $(theClass(PackagePrivateClass.class).should().bePackagePrivate(), + arguments(theClass(PackagePrivateClass.class).should().bePackagePrivate(), theClass(PackagePrivateClass.class).should().notBePackagePrivate()), - $(theClass(PackagePrivateClass.class).should(ArchConditions.bePackagePrivate()), + arguments(theClass(PackagePrivateClass.class).should(ArchConditions.bePackagePrivate()), theClass(PackagePrivateClass.class).should(ArchConditions.notBePackagePrivate())), - $(theClass(PackagePrivateClass.class.getName()).should().bePackagePrivate(), + arguments(theClass(PackagePrivateClass.class.getName()).should().bePackagePrivate(), theClass(PackagePrivateClass.class.getName()).should().notBePackagePrivate()), - $(theClass(PackagePrivateClass.class.getName()).should(ArchConditions.bePackagePrivate()), + arguments(theClass(PackagePrivateClass.class.getName()).should(ArchConditions.bePackagePrivate()), theClass(PackagePrivateClass.class.getName()).should(ArchConditions.notBePackagePrivate())) ); } @@ -823,13 +823,13 @@ void theClass_should_bePackagePrivate(ArchRule satisfiedRule, ArchRule unsatisfi static Stream noClass_should_bePackagePrivate_rules() { return Stream.of( - $(noClass(PackagePrivateClass.class).should().notBePackagePrivate(), + arguments(noClass(PackagePrivateClass.class).should().notBePackagePrivate(), noClass(PackagePrivateClass.class).should().bePackagePrivate()), - $(noClass(PackagePrivateClass.class).should(ArchConditions.notBePackagePrivate()), + arguments(noClass(PackagePrivateClass.class).should(ArchConditions.notBePackagePrivate()), noClass(PackagePrivateClass.class).should(ArchConditions.bePackagePrivate())), - $(noClass(PackagePrivateClass.class.getName()).should().notBePackagePrivate(), + arguments(noClass(PackagePrivateClass.class.getName()).should().notBePackagePrivate(), noClass(PackagePrivateClass.class.getName()).should().bePackagePrivate()), - $(noClass(PackagePrivateClass.class.getName()).should(ArchConditions.notBePackagePrivate()), + arguments(noClass(PackagePrivateClass.class.getName()).should(ArchConditions.notBePackagePrivate()), noClass(PackagePrivateClass.class.getName()).should(ArchConditions.bePackagePrivate())) ); } @@ -859,14 +859,14 @@ void noClass_should_bePackagePrivate(ArchRule satisfiedRule, ArchRule unsatisfie static Stream theClass_should_haveModifier_public_rules() { return Stream.of( - $(theClass(PublicClass.class).should().haveModifier(PUBLIC), - theClass(PublicClass.class).should().notHaveModifier(PUBLIC)), - $(theClass(PublicClass.class).should(ArchConditions.haveModifier(PUBLIC)), - theClass(PublicClass.class).should(ArchConditions.notHaveModifier(PUBLIC))), - $(theClass(PublicClass.class.getName()).should().haveModifier(PUBLIC), - theClass(PublicClass.class.getName()).should().notHaveModifier(PUBLIC)), - $(theClass(PublicClass.class.getName()).should(ArchConditions.haveModifier(PUBLIC)), - theClass(PublicClass.class.getName()).should(ArchConditions.notHaveModifier(PUBLIC))) + arguments(theClass(PublicClass.class).should().haveModifier(JavaModifier.PUBLIC), + theClass(PublicClass.class).should().notHaveModifier(JavaModifier.PUBLIC)), + arguments(theClass(PublicClass.class).should(ArchConditions.haveModifier(JavaModifier.PUBLIC)), + theClass(PublicClass.class).should(ArchConditions.notHaveModifier(JavaModifier.PUBLIC))), + arguments(theClass(PublicClass.class.getName()).should().haveModifier(JavaModifier.PUBLIC), + theClass(PublicClass.class.getName()).should().notHaveModifier(JavaModifier.PUBLIC)), + arguments(theClass(PublicClass.class.getName()).should(ArchConditions.haveModifier(JavaModifier.PUBLIC)), + theClass(PublicClass.class.getName()).should(ArchConditions.notHaveModifier(JavaModifier.PUBLIC))) ); } @@ -887,14 +887,14 @@ void theClass_should_haveModifier_public(ArchRule satisfiedRule, ArchRule unsati static Stream noClass_should_haveModifier_public_rules() { return Stream.of( - $(noClass(PublicClass.class).should().notHaveModifier(PUBLIC), - noClass(PublicClass.class).should().haveModifier(PUBLIC)), - $(noClass(PublicClass.class).should(ArchConditions.notHaveModifier(PUBLIC)), - noClass(PublicClass.class).should(ArchConditions.haveModifier(PUBLIC))), - $(noClass(PublicClass.class.getName()).should().notHaveModifier(PUBLIC), - noClass(PublicClass.class.getName()).should().haveModifier(PUBLIC)), - $(noClass(PublicClass.class.getName()).should(ArchConditions.notHaveModifier(PUBLIC)), - noClass(PublicClass.class.getName()).should(ArchConditions.haveModifier(PUBLIC))) + arguments(noClass(PublicClass.class).should().notHaveModifier(JavaModifier.PUBLIC), + noClass(PublicClass.class).should().haveModifier(JavaModifier.PUBLIC)), + arguments(noClass(PublicClass.class).should(ArchConditions.notHaveModifier(JavaModifier.PUBLIC)), + noClass(PublicClass.class).should(ArchConditions.haveModifier(JavaModifier.PUBLIC))), + arguments(noClass(PublicClass.class.getName()).should().notHaveModifier(JavaModifier.PUBLIC), + noClass(PublicClass.class.getName()).should().haveModifier(JavaModifier.PUBLIC)), + arguments(noClass(PublicClass.class.getName()).should(ArchConditions.notHaveModifier(JavaModifier.PUBLIC)), + noClass(PublicClass.class.getName()).should(ArchConditions.haveModifier(JavaModifier.PUBLIC))) ); } @@ -915,13 +915,13 @@ void noClass_should_haveModifier_public(ArchRule satisfiedRule, ArchRule unsatis static Stream theClass_should_beAnnotatedWith_rules() { return Stream.of( - $(theClass(SomeAnnotatedClass.class).should().beAnnotatedWith(RuntimeRetentionAnnotation.class), + arguments(theClass(SomeAnnotatedClass.class).should().beAnnotatedWith(RuntimeRetentionAnnotation.class), theClass(SomeAnnotatedClass.class).should().notBeAnnotatedWith(RuntimeRetentionAnnotation.class)), - $(theClass(SomeAnnotatedClass.class).should(ArchConditions.beAnnotatedWith(RuntimeRetentionAnnotation.class)), + arguments(theClass(SomeAnnotatedClass.class).should(ArchConditions.beAnnotatedWith(RuntimeRetentionAnnotation.class)), theClass(SomeAnnotatedClass.class).should(ArchConditions.notBeAnnotatedWith(RuntimeRetentionAnnotation.class))), - $(theClass(SomeAnnotatedClass.class.getName()).should().beAnnotatedWith(RuntimeRetentionAnnotation.class), + arguments(theClass(SomeAnnotatedClass.class.getName()).should().beAnnotatedWith(RuntimeRetentionAnnotation.class), theClass(SomeAnnotatedClass.class.getName()).should().notBeAnnotatedWith(RuntimeRetentionAnnotation.class)), - $(theClass(SomeAnnotatedClass.class.getName()).should(ArchConditions.beAnnotatedWith(RuntimeRetentionAnnotation.class)), + arguments(theClass(SomeAnnotatedClass.class.getName()).should(ArchConditions.beAnnotatedWith(RuntimeRetentionAnnotation.class)), theClass(SomeAnnotatedClass.class.getName()).should(ArchConditions.notBeAnnotatedWith(RuntimeRetentionAnnotation.class))) ); } @@ -943,13 +943,13 @@ void theClass_should_beAnnotatedWith(ArchRule satisfiedRule, ArchRule unsatisfie static Stream noClass_should_beAnnotatedWith_rules() { return Stream.of( - $(noClass(SomeAnnotatedClass.class).should().notBeAnnotatedWith(RuntimeRetentionAnnotation.class), + arguments(noClass(SomeAnnotatedClass.class).should().notBeAnnotatedWith(RuntimeRetentionAnnotation.class), noClass(SomeAnnotatedClass.class).should().beAnnotatedWith(RuntimeRetentionAnnotation.class)), - $(noClass(SomeAnnotatedClass.class).should(ArchConditions.notBeAnnotatedWith(RuntimeRetentionAnnotation.class)), + arguments(noClass(SomeAnnotatedClass.class).should(ArchConditions.notBeAnnotatedWith(RuntimeRetentionAnnotation.class)), noClass(SomeAnnotatedClass.class).should(ArchConditions.beAnnotatedWith(RuntimeRetentionAnnotation.class))), - $(noClass(SomeAnnotatedClass.class.getName()).should().notBeAnnotatedWith(RuntimeRetentionAnnotation.class), + arguments(noClass(SomeAnnotatedClass.class.getName()).should().notBeAnnotatedWith(RuntimeRetentionAnnotation.class), noClass(SomeAnnotatedClass.class.getName()).should().beAnnotatedWith(RuntimeRetentionAnnotation.class)), - $(noClass(SomeAnnotatedClass.class.getName()).should(ArchConditions.notBeAnnotatedWith(RuntimeRetentionAnnotation.class)), + arguments(noClass(SomeAnnotatedClass.class.getName()).should(ArchConditions.notBeAnnotatedWith(RuntimeRetentionAnnotation.class)), noClass(SomeAnnotatedClass.class.getName()).should(ArchConditions.beAnnotatedWith(RuntimeRetentionAnnotation.class))) ); } @@ -971,13 +971,13 @@ void noClass_should_beAnnotatedWith(ArchRule satisfiedRule, ArchRule unsatisfied static Stream theClass_should_implement_rules() { return Stream.of( - $(theClass(ArrayList.class).should().implement(Collection.class), + arguments(theClass(ArrayList.class).should().implement(Collection.class), theClass(ArrayList.class).should().notImplement(Collection.class)), - $(theClass(ArrayList.class).should(ArchConditions.implement(Collection.class)), + arguments(theClass(ArrayList.class).should(ArchConditions.implement(Collection.class)), theClass(ArrayList.class).should(ArchConditions.notImplement(Collection.class))), - $(theClass(ArrayList.class.getName()).should().implement(Collection.class), + arguments(theClass(ArrayList.class.getName()).should().implement(Collection.class), theClass(ArrayList.class.getName()).should().notImplement(Collection.class)), - $(theClass(ArrayList.class.getName()).should(ArchConditions.implement(Collection.class)), + arguments(theClass(ArrayList.class.getName()).should(ArchConditions.implement(Collection.class)), theClass(ArrayList.class.getName()).should(ArchConditions.notImplement(Collection.class))) ); } @@ -999,13 +999,13 @@ void theClass_should_implement(ArchRule satisfiedRule, ArchRule unsatisfiedRule) static Stream noClass_should_implement_rules() { return Stream.of( - $(noClass(ArrayList.class).should().notImplement(Collection.class), + arguments(noClass(ArrayList.class).should().notImplement(Collection.class), noClass(ArrayList.class).should().implement(Collection.class)), - $(noClass(ArrayList.class).should(ArchConditions.notImplement(Collection.class)), + arguments(noClass(ArrayList.class).should(ArchConditions.notImplement(Collection.class)), noClass(ArrayList.class).should(ArchConditions.implement(Collection.class))), - $(noClass(ArrayList.class.getName()).should().notImplement(Collection.class), + arguments(noClass(ArrayList.class.getName()).should().notImplement(Collection.class), noClass(ArrayList.class.getName()).should().implement(Collection.class)), - $(noClass(ArrayList.class.getName()).should(ArchConditions.notImplement(Collection.class)), + arguments(noClass(ArrayList.class.getName()).should(ArchConditions.notImplement(Collection.class)), noClass(ArrayList.class.getName()).should(ArchConditions.implement(Collection.class))) ); } @@ -1027,13 +1027,13 @@ void noClass_should_implement(ArchRule satisfiedRule, ArchRule unsatisfiedRule) static Stream theClass_should_beAssignableTo_rules() { return Stream.of( - $(theClass(List.class).should().beAssignableTo(Collection.class), + arguments(theClass(List.class).should().beAssignableTo(Collection.class), theClass(List.class).should().notBeAssignableTo(Collection.class)), - $(theClass(List.class).should(ArchConditions.beAssignableTo(Collection.class)), + arguments(theClass(List.class).should(ArchConditions.beAssignableTo(Collection.class)), theClass(List.class).should(ArchConditions.notBeAssignableTo(Collection.class))), - $(theClass(List.class.getName()).should().beAssignableTo(Collection.class), + arguments(theClass(List.class.getName()).should().beAssignableTo(Collection.class), theClass(List.class.getName()).should().notBeAssignableTo(Collection.class)), - $(theClass(List.class.getName()).should(ArchConditions.beAssignableTo(Collection.class)), + arguments(theClass(List.class.getName()).should(ArchConditions.beAssignableTo(Collection.class)), theClass(List.class.getName()).should(ArchConditions.notBeAssignableTo(Collection.class))) ); } @@ -1055,13 +1055,13 @@ void theClass_should_beAssignableTo(ArchRule satisfiedRule, ArchRule unsatisfied static Stream noClass_should_beAssignableTo_rules() { return Stream.of( - $(noClass(List.class).should().notBeAssignableTo(Collection.class), + arguments(noClass(List.class).should().notBeAssignableTo(Collection.class), noClass(List.class).should().beAssignableTo(Collection.class)), - $(noClass(List.class).should(ArchConditions.notBeAssignableTo(Collection.class)), + arguments(noClass(List.class).should(ArchConditions.notBeAssignableTo(Collection.class)), noClass(List.class).should(ArchConditions.beAssignableTo(Collection.class))), - $(noClass(List.class.getName()).should().notBeAssignableTo(Collection.class), + arguments(noClass(List.class.getName()).should().notBeAssignableTo(Collection.class), noClass(List.class.getName()).should().beAssignableTo(Collection.class)), - $(noClass(List.class.getName()).should(ArchConditions.notBeAssignableTo(Collection.class)), + arguments(noClass(List.class.getName()).should(ArchConditions.notBeAssignableTo(Collection.class)), noClass(List.class.getName()).should(ArchConditions.beAssignableTo(Collection.class))) ); } @@ -1083,13 +1083,13 @@ void noClass_should_beAssignableTo(ArchRule satisfiedRule, ArchRule unsatisfiedR static Stream theClass_should_beAssignableFrom_rules() { return Stream.of( - $(theClass(Collection.class).should().beAssignableFrom(List.class), + arguments(theClass(Collection.class).should().beAssignableFrom(List.class), theClass(Collection.class).should().notBeAssignableFrom(List.class)), - $(theClass(Collection.class).should(ArchConditions.beAssignableFrom(List.class)), + arguments(theClass(Collection.class).should(ArchConditions.beAssignableFrom(List.class)), theClass(Collection.class).should(ArchConditions.notBeAssignableFrom(List.class))), - $(theClass(Collection.class.getName()).should().beAssignableFrom(List.class), + arguments(theClass(Collection.class.getName()).should().beAssignableFrom(List.class), theClass(Collection.class.getName()).should().notBeAssignableFrom(List.class)), - $(theClass(Collection.class.getName()).should(ArchConditions.beAssignableFrom(List.class)), + arguments(theClass(Collection.class.getName()).should(ArchConditions.beAssignableFrom(List.class)), theClass(Collection.class.getName()).should(ArchConditions.notBeAssignableFrom(List.class))) ); } @@ -1111,13 +1111,13 @@ void theClass_should_beAssignableFrom(ArchRule satisfiedRule, ArchRule unsatisfi static Stream noClass_should_beAssignableFrom_rules() { return Stream.of( - $(noClass(Collection.class).should().notBeAssignableFrom(List.class), + arguments(noClass(Collection.class).should().notBeAssignableFrom(List.class), noClass(Collection.class).should().beAssignableFrom(List.class)), - $(noClass(Collection.class).should(ArchConditions.notBeAssignableFrom(List.class)), + arguments(noClass(Collection.class).should(ArchConditions.notBeAssignableFrom(List.class)), noClass(Collection.class).should(ArchConditions.beAssignableFrom(List.class))), - $(noClass(Collection.class.getName()).should().notBeAssignableFrom(List.class), + arguments(noClass(Collection.class.getName()).should().notBeAssignableFrom(List.class), noClass(Collection.class.getName()).should().beAssignableFrom(List.class)), - $(noClass(Collection.class.getName()).should(ArchConditions.notBeAssignableFrom(List.class)), + arguments(noClass(Collection.class.getName()).should(ArchConditions.notBeAssignableFrom(List.class)), noClass(Collection.class.getName()).should(ArchConditions.beAssignableFrom(List.class))) ); } @@ -1139,14 +1139,14 @@ void noClass_should_beAssignableFrom(ArchRule satisfiedRule, ArchRule unsatisfie static Stream theClass_should_getField_rules() { return Stream.of( - $(theClass(ClassAccessingField.class).should().getField(ClassWithField.class, "field"), - theClass(ClassAccessingWrongField.class).should().getField(ClassWithField.class, "field")), - $(theClass(ClassAccessingField.class).should(ArchConditions.getField(ClassWithField.class, "field")), - theClass(ClassAccessingWrongField.class).should(ArchConditions.getField(ClassWithField.class, "field"))), - $(theClass(ClassAccessingField.class.getName()).should().getField(ClassWithField.class, "field"), - theClass(ClassAccessingWrongField.class.getName()).should().getField(ClassWithField.class, "field")), - $(theClass(ClassAccessingField.class.getName()).should(ArchConditions.getField(ClassWithField.class, "field")), - theClass(ClassAccessingWrongField.class.getName()).should(ArchConditions.getField(ClassWithField.class, "field"))) + arguments(theClass(ClassAccessingField.class).should().getField(ClassWithField.class, "field"), theClass(ClassAccessingWrongField.class).should().getField(ClassWithField.class, + "field")), + arguments(theClass(ClassAccessingField.class).should(ArchConditions.getField(ClassWithField.class, "field")), theClass(ClassAccessingWrongField.class).should(ArchConditions.getField(ClassWithField.class, + "field"))), + arguments(theClass(ClassAccessingField.class.getName()).should().getField(ClassWithField.class, "field"), theClass(ClassAccessingWrongField.class.getName()).should().getField(ClassWithField.class, + "field")), + arguments(theClass(ClassAccessingField.class.getName()).should(ArchConditions.getField(ClassWithField.class, "field")), theClass(ClassAccessingWrongField.class.getName()).should(ArchConditions.getField(ClassWithField.class, + "field"))) ); } @@ -1166,14 +1166,10 @@ void theClass_should_getField(ArchRule satisfiedRule, ArchRule unsatisfiedRule) static Stream noClass_should_getField_rules() { return Stream.of( - $(noClass(ClassAccessingWrongField.class).should().getField(ClassWithField.class, "field"), - noClass(ClassAccessingField.class).should().getField(ClassWithField.class, "field")), - $(noClass(ClassAccessingWrongField.class).should(ArchConditions.getField(ClassWithField.class, "field")), - noClass(ClassAccessingField.class).should(ArchConditions.getField(ClassWithField.class, "field"))), - $(noClass(ClassAccessingWrongField.class.getName()).should().getField(ClassWithField.class, "field"), - noClass(ClassAccessingField.class.getName()).should().getField(ClassWithField.class, "field")), - $(noClass(ClassAccessingWrongField.class.getName()).should(ArchConditions.getField(ClassWithField.class, "field")), - noClass(ClassAccessingField.class.getName()).should(ArchConditions.getField(ClassWithField.class, "field"))) + arguments(noClass(ClassAccessingWrongField.class).should().getField(ClassWithField.class, "field"), noClass(ClassAccessingField.class).should().getField(ClassWithField.class, "field")), + arguments(noClass(ClassAccessingWrongField.class).should(ArchConditions.getField(ClassWithField.class, "field")), noClass(ClassAccessingField.class).should(ArchConditions.getField(ClassWithField.class, "field"))), + arguments(noClass(ClassAccessingWrongField.class.getName()).should().getField(ClassWithField.class, "field"), noClass(ClassAccessingField.class.getName()).should().getField(ClassWithField.class, "field")), + arguments(noClass(ClassAccessingWrongField.class.getName()).should(ArchConditions.getField(ClassWithField.class, "field")), noClass(ClassAccessingField.class.getName()).should(ArchConditions.getField(ClassWithField.class, "field"))) ); } @@ -1193,13 +1189,13 @@ void noClass_should_getField(ArchRule satisfiedRule, ArchRule unsatisfiedRule) { static Stream theClass_should_accessField_rules() { return Stream.of( - $(theClass(ClassAccessingField.class).should().accessField(ClassWithField.class, "field"), + arguments(theClass(ClassAccessingField.class).should().accessField(ClassWithField.class, "field"), theClass(ClassAccessingWrongField.class).should().accessField(ClassWithField.class, "field")), - $(theClass(ClassAccessingField.class).should(ArchConditions.accessField(ClassWithField.class, "field")), + arguments(theClass(ClassAccessingField.class).should(ArchConditions.accessField(ClassWithField.class, "field")), theClass(ClassAccessingWrongField.class).should(ArchConditions.accessField(ClassWithField.class, "field"))), - $(theClass(ClassAccessingField.class.getName()).should().accessField(ClassWithField.class, "field"), + arguments(theClass(ClassAccessingField.class.getName()).should().accessField(ClassWithField.class, "field"), theClass(ClassAccessingWrongField.class.getName()).should().accessField(ClassWithField.class, "field")), - $(theClass(ClassAccessingField.class.getName()).should(ArchConditions.accessField(ClassWithField.class, "field")), + arguments(theClass(ClassAccessingField.class.getName()).should(ArchConditions.accessField(ClassWithField.class, "field")), theClass(ClassAccessingWrongField.class.getName()).should(ArchConditions.accessField(ClassWithField.class, "field"))) ); } @@ -1220,13 +1216,13 @@ void theClass_should_accessField(ArchRule satisfiedRule, ArchRule unsatisfiedRul static Stream noClass_should_accessField_rules() { return Stream.of( - $(noClass(ClassAccessingWrongField.class).should().accessField(ClassWithField.class, "field"), + arguments(noClass(ClassAccessingWrongField.class).should().accessField(ClassWithField.class, "field"), noClass(ClassAccessingField.class).should().accessField(ClassWithField.class, "field")), - $(noClass(ClassAccessingWrongField.class).should(ArchConditions.accessField(ClassWithField.class, "field")), + arguments(noClass(ClassAccessingWrongField.class).should(ArchConditions.accessField(ClassWithField.class, "field")), noClass(ClassAccessingField.class).should(ArchConditions.accessField(ClassWithField.class, "field"))), - $(noClass(ClassAccessingWrongField.class.getName()).should().accessField(ClassWithField.class, "field"), + arguments(noClass(ClassAccessingWrongField.class.getName()).should().accessField(ClassWithField.class, "field"), noClass(ClassAccessingField.class.getName()).should().accessField(ClassWithField.class, "field")), - $(noClass(ClassAccessingWrongField.class.getName()).should(ArchConditions.accessField(ClassWithField.class, "field")), + arguments(noClass(ClassAccessingWrongField.class.getName()).should(ArchConditions.accessField(ClassWithField.class, "field")), noClass(ClassAccessingField.class.getName()).should(ArchConditions.accessField(ClassWithField.class, "field"))) ); } @@ -1247,13 +1243,13 @@ void noClass_should_accessField(ArchRule satisfiedRule, ArchRule unsatisfiedRule static Stream theClass_should_getFieldWhere_rules() { return Stream.of( - $(theClass(ClassAccessingField.class).should().getFieldWhere(accessTargetIs(ClassWithField.class)), + arguments(theClass(ClassAccessingField.class).should().getFieldWhere(accessTargetIs(ClassWithField.class)), theClass(ClassAccessingWrongField.class).should().getFieldWhere(accessTargetIs(ClassWithField.class))), - $(theClass(ClassAccessingField.class).should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class))), + arguments(theClass(ClassAccessingField.class).should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class))), theClass(ClassAccessingWrongField.class).should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class)))), - $(theClass(ClassAccessingField.class.getName()).should().getFieldWhere(accessTargetIs(ClassWithField.class)), + arguments(theClass(ClassAccessingField.class.getName()).should().getFieldWhere(accessTargetIs(ClassWithField.class)), theClass(ClassAccessingWrongField.class.getName()).should().getFieldWhere(accessTargetIs(ClassWithField.class))), - $(theClass(ClassAccessingField.class.getName()).should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class))), + arguments(theClass(ClassAccessingField.class.getName()).should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class))), theClass(ClassAccessingWrongField.class.getName()).should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class)))) ); } @@ -1274,13 +1270,13 @@ void theClass_should_getFieldWhere(ArchRule satisfiedRule, ArchRule unsatisfiedR static Stream noClass_should_getFieldWhere_rules() { return Stream.of( - $(noClass(ClassAccessingWrongField.class).should().getFieldWhere(accessTargetIs(ClassWithField.class)), + arguments(noClass(ClassAccessingWrongField.class).should().getFieldWhere(accessTargetIs(ClassWithField.class)), noClass(ClassAccessingField.class).should().getFieldWhere(accessTargetIs(ClassWithField.class))), - $(noClass(ClassAccessingWrongField.class).should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class))), + arguments(noClass(ClassAccessingWrongField.class).should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class))), noClass(ClassAccessingField.class).should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class)))), - $(noClass(ClassAccessingWrongField.class.getName()).should().getFieldWhere(accessTargetIs(ClassWithField.class)), + arguments(noClass(ClassAccessingWrongField.class.getName()).should().getFieldWhere(accessTargetIs(ClassWithField.class)), noClass(ClassAccessingField.class.getName()).should().getFieldWhere(accessTargetIs(ClassWithField.class))), - $(noClass(ClassAccessingWrongField.class.getName()).should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class))), + arguments(noClass(ClassAccessingWrongField.class.getName()).should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class))), noClass(ClassAccessingField.class.getName()).should(ArchConditions.getFieldWhere(accessTargetIs(ClassWithField.class)))) ); } @@ -1301,13 +1297,13 @@ void noClass_should_getFieldWhere(ArchRule satisfiedRule, ArchRule unsatisfiedRu static Stream theClass_should_accessFieldWhere_rules() { return Stream.of( - $(theClass(ClassAccessingField.class).should().accessFieldWhere(accessTargetIs(ClassWithField.class)), + arguments(theClass(ClassAccessingField.class).should().accessFieldWhere(accessTargetIs(ClassWithField.class)), theClass(ClassAccessingWrongField.class).should().accessFieldWhere(accessTargetIs(ClassWithField.class))), - $(theClass(ClassAccessingField.class).should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class))), + arguments(theClass(ClassAccessingField.class).should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class))), theClass(ClassAccessingWrongField.class).should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class)))), - $(theClass(ClassAccessingField.class.getName()).should().accessFieldWhere(accessTargetIs(ClassWithField.class)), + arguments(theClass(ClassAccessingField.class.getName()).should().accessFieldWhere(accessTargetIs(ClassWithField.class)), theClass(ClassAccessingWrongField.class.getName()).should().accessFieldWhere(accessTargetIs(ClassWithField.class))), - $(theClass(ClassAccessingField.class.getName()).should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class))), + arguments(theClass(ClassAccessingField.class.getName()).should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class))), theClass(ClassAccessingWrongField.class.getName()) .should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class)))) ); @@ -1329,13 +1325,13 @@ void theClass_should_accessFieldWhere(ArchRule satisfiedRule, ArchRule unsatisfi static Stream noClass_should_accessFieldWhere_rules() { return Stream.of( - $(noClass(ClassAccessingWrongField.class).should().accessFieldWhere(accessTargetIs(ClassWithField.class)), + arguments(noClass(ClassAccessingWrongField.class).should().accessFieldWhere(accessTargetIs(ClassWithField.class)), noClass(ClassAccessingField.class).should().accessFieldWhere(accessTargetIs(ClassWithField.class))), - $(noClass(ClassAccessingWrongField.class).should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class))), + arguments(noClass(ClassAccessingWrongField.class).should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class))), noClass(ClassAccessingField.class).should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class)))), - $(noClass(ClassAccessingWrongField.class.getName()).should().accessFieldWhere(accessTargetIs(ClassWithField.class)), + arguments(noClass(ClassAccessingWrongField.class.getName()).should().accessFieldWhere(accessTargetIs(ClassWithField.class)), noClass(ClassAccessingField.class.getName()).should().accessFieldWhere(accessTargetIs(ClassWithField.class))), - $(noClass(ClassAccessingWrongField.class.getName()).should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class))), + arguments(noClass(ClassAccessingWrongField.class.getName()).should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class))), noClass(ClassAccessingField.class.getName()).should(ArchConditions.accessFieldWhere(accessTargetIs(ClassWithField.class)))) ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenCodeUnitsTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenCodeUnitsTest.java index 4945d56e72..cff021ced1 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenCodeUnitsTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenCodeUnitsTest.java @@ -39,9 +39,9 @@ import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.beAnnotatedWith; import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.described; import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.everythingViolationPrintMemberName; -import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.Collections.emptySet; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class GivenCodeUnitsTest { @@ -123,46 +123,46 @@ public void check(JavaConstructor constructor, ConditionEvents events) { static Stream restricted_parameter_types_rule_starts() { return Stream.of( - $(described(codeUnits().that().haveRawParameterTypes(String.class)), + arguments(described(codeUnits().that().haveRawParameterTypes(String.class)), ImmutableSet.of(METHOD_ONE_ARG, CONSTRUCTOR_ONE_ARG)), - $(described(codeUnits().that().haveRawParameterTypes(String.class.getName())), + arguments(described(codeUnits().that().haveRawParameterTypes(String.class.getName())), ImmutableSet.of(METHOD_ONE_ARG, CONSTRUCTOR_ONE_ARG)), - $(described(codeUnits().that().haveRawParameterTypes(oneParameterOfType(String.class))), + arguments(described(codeUnits().that().haveRawParameterTypes(oneParameterOfType(String.class))), ImmutableSet.of(METHOD_ONE_ARG, CONSTRUCTOR_ONE_ARG)), - $(described(codeUnits().that().doNotHaveRawParameterTypes(String.class)), + arguments(described(codeUnits().that().doNotHaveRawParameterTypes(String.class)), allCodeUnitsExcept(METHOD_ONE_ARG, CONSTRUCTOR_ONE_ARG)), - $(described(codeUnits().that().doNotHaveRawParameterTypes(String.class.getName())), + arguments(described(codeUnits().that().doNotHaveRawParameterTypes(String.class.getName())), allCodeUnitsExcept(METHOD_ONE_ARG, CONSTRUCTOR_ONE_ARG)), - $(described(codeUnits().that().doNotHaveRawParameterTypes(oneParameterOfType(String.class))), + arguments(described(codeUnits().that().doNotHaveRawParameterTypes(oneParameterOfType(String.class))), allCodeUnitsExcept(METHOD_ONE_ARG, CONSTRUCTOR_ONE_ARG)), - $(described(methods().that().haveRawParameterTypes(String.class)), + arguments(described(methods().that().haveRawParameterTypes(String.class)), ImmutableSet.of(METHOD_ONE_ARG)), - $(described(methods().that().haveRawParameterTypes(String.class.getName())), + arguments(described(methods().that().haveRawParameterTypes(String.class.getName())), ImmutableSet.of(METHOD_ONE_ARG)), - $(described(methods().that().haveRawParameterTypes(oneParameterOfType(String.class))), + arguments(described(methods().that().haveRawParameterTypes(oneParameterOfType(String.class))), ImmutableSet.of(METHOD_ONE_ARG)), - $(described(methods().that().doNotHaveRawParameterTypes(String.class)), + arguments(described(methods().that().doNotHaveRawParameterTypes(String.class)), allMethodsExcept(METHOD_ONE_ARG)), - $(described(methods().that().doNotHaveRawParameterTypes(String.class.getName())), + arguments(described(methods().that().doNotHaveRawParameterTypes(String.class.getName())), allMethodsExcept(METHOD_ONE_ARG)), - $(described(methods().that().doNotHaveRawParameterTypes(oneParameterOfType(String.class))), + arguments(described(methods().that().doNotHaveRawParameterTypes(oneParameterOfType(String.class))), allMethodsExcept(METHOD_ONE_ARG)), - $(described(constructors().that().haveRawParameterTypes(String.class)), + arguments(described(constructors().that().haveRawParameterTypes(String.class)), ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), - $(described(constructors().that().haveRawParameterTypes(String.class.getName())), + arguments(described(constructors().that().haveRawParameterTypes(String.class.getName())), ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), - $(described(constructors().that().haveRawParameterTypes(oneParameterOfType(String.class))), + arguments(described(constructors().that().haveRawParameterTypes(oneParameterOfType(String.class))), ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), - $(described(constructors().that().doNotHaveRawParameterTypes(String.class)), + arguments(described(constructors().that().doNotHaveRawParameterTypes(String.class)), allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), - $(described(constructors().that().doNotHaveRawParameterTypes(String.class.getName())), + arguments(described(constructors().that().doNotHaveRawParameterTypes(String.class.getName())), allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), - $(described(constructors().that().doNotHaveRawParameterTypes(oneParameterOfType(String.class))), + arguments(described(constructors().that().doNotHaveRawParameterTypes(oneParameterOfType(String.class))), allConstructorsExcept(CONSTRUCTOR_ONE_ARG)) ); } @@ -178,32 +178,32 @@ void parameter_types_predicates(DescribedRuleStart ruleStart, Collection static Stream restricted_return_type_rule_starts() { return Stream.of( - $(described(codeUnits().that().haveRawReturnType(String.class)), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(codeUnits().that().haveRawReturnType(String.class.getName())), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(codeUnits().that().haveRawReturnType(equivalentTo(String.class))), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), + arguments(described(codeUnits().that().haveRawReturnType(String.class)), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), + arguments(described(codeUnits().that().haveRawReturnType(String.class.getName())), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), + arguments(described(codeUnits().that().haveRawReturnType(equivalentTo(String.class))), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(codeUnits().that().doNotHaveRawReturnType(String.class)), allCodeUnitsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(codeUnits().that().doNotHaveRawReturnType(String.class.getName())), + arguments(described(codeUnits().that().doNotHaveRawReturnType(String.class)), allCodeUnitsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS)), + arguments(described(codeUnits().that().doNotHaveRawReturnType(String.class.getName())), allCodeUnitsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(codeUnits().that().doNotHaveRawReturnType(equivalentTo(String.class))), + arguments(described(codeUnits().that().doNotHaveRawReturnType(equivalentTo(String.class))), allCodeUnitsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(methods().that().haveRawReturnType(String.class)), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(methods().that().haveRawReturnType(String.class.getName())), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(methods().that().haveRawReturnType(equivalentTo(String.class))), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), + arguments(described(methods().that().haveRawReturnType(String.class)), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), + arguments(described(methods().that().haveRawReturnType(String.class.getName())), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), + arguments(described(methods().that().haveRawReturnType(equivalentTo(String.class))), ImmutableList.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(methods().that().doNotHaveRawReturnType(String.class)), ImmutableList.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), - $(described(methods().that().doNotHaveRawReturnType(String.class.getName())), ImmutableList.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), - $(described(methods().that().doNotHaveRawReturnType(equivalentTo(String.class))), + arguments(described(methods().that().doNotHaveRawReturnType(String.class)), ImmutableList.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), + arguments(described(methods().that().doNotHaveRawReturnType(String.class.getName())), ImmutableList.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), + arguments(described(methods().that().doNotHaveRawReturnType(equivalentTo(String.class))), ImmutableList.of(METHOD_TWO_ARGS, METHOD_FOUR_ARGS)), - $(described(constructors().that().haveRawReturnType(void.class)), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(constructors().that().haveRawReturnType(void.class.getName())), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(constructors().that().haveRawReturnType(equivalentTo(void.class))), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(described(constructors().that().haveRawReturnType(void.class)), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(described(constructors().that().haveRawReturnType(void.class.getName())), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(described(constructors().that().haveRawReturnType(equivalentTo(void.class))), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(constructors().that().doNotHaveRawReturnType(void.class)), emptySet()), - $(described(constructors().that().doNotHaveRawReturnType(void.class.getName())), emptySet()), - $(described(constructors().that().doNotHaveRawReturnType(equivalentTo(void.class))), emptySet()) + arguments(described(constructors().that().doNotHaveRawReturnType(void.class)), emptySet()), + arguments(described(constructors().that().doNotHaveRawReturnType(void.class.getName())), emptySet()), + arguments(described(constructors().that().doNotHaveRawReturnType(equivalentTo(void.class))), emptySet()) ); } @@ -220,46 +220,46 @@ void return_type_predicates(DescribedRuleStart ruleStart, Collection exp static Stream restricted_throwable_type_rule_starts() { return Stream.of( - $(described(codeUnits().that().declareThrowableOfType(FirstException.class)), + arguments(described(codeUnits().that().declareThrowableOfType(FirstException.class)), ImmutableSet.of(METHOD_ONE_ARG, METHOD_THREE_ARGS, CONSTRUCTOR_ONE_ARG, CONSTRUCTOR_THREE_ARGS)), - $(described(codeUnits().that().declareThrowableOfType(FirstException.class.getName())), + arguments(described(codeUnits().that().declareThrowableOfType(FirstException.class.getName())), ImmutableSet.of(METHOD_ONE_ARG, METHOD_THREE_ARGS, CONSTRUCTOR_ONE_ARG, CONSTRUCTOR_THREE_ARGS)), - $(described(codeUnits().that().declareThrowableOfType(equivalentTo(FirstException.class))), + arguments(described(codeUnits().that().declareThrowableOfType(equivalentTo(FirstException.class))), ImmutableSet.of(METHOD_ONE_ARG, METHOD_THREE_ARGS, CONSTRUCTOR_ONE_ARG, CONSTRUCTOR_THREE_ARGS)), - $(described(codeUnits().that().doNotDeclareThrowableOfType(FirstException.class)), + arguments(described(codeUnits().that().doNotDeclareThrowableOfType(FirstException.class)), allCodeUnitsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS, CONSTRUCTOR_ONE_ARG, CONSTRUCTOR_THREE_ARGS)), - $(described(codeUnits().that().doNotDeclareThrowableOfType(FirstException.class.getName())), + arguments(described(codeUnits().that().doNotDeclareThrowableOfType(FirstException.class.getName())), allCodeUnitsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS, CONSTRUCTOR_ONE_ARG, CONSTRUCTOR_THREE_ARGS)), - $(described(codeUnits().that().doNotDeclareThrowableOfType(equivalentTo(FirstException.class))), + arguments(described(codeUnits().that().doNotDeclareThrowableOfType(equivalentTo(FirstException.class))), allCodeUnitsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS, CONSTRUCTOR_ONE_ARG, CONSTRUCTOR_THREE_ARGS)), - $(described(methods().that().declareThrowableOfType(FirstException.class)), + arguments(described(methods().that().declareThrowableOfType(FirstException.class)), ImmutableSet.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(methods().that().declareThrowableOfType(FirstException.class.getName())), + arguments(described(methods().that().declareThrowableOfType(FirstException.class.getName())), ImmutableSet.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(methods().that().declareThrowableOfType(equivalentTo(FirstException.class))), + arguments(described(methods().that().declareThrowableOfType(equivalentTo(FirstException.class))), ImmutableSet.of(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(methods().that().doNotDeclareThrowableOfType(FirstException.class)), + arguments(described(methods().that().doNotDeclareThrowableOfType(FirstException.class)), allMethodsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(methods().that().doNotDeclareThrowableOfType(FirstException.class.getName())), + arguments(described(methods().that().doNotDeclareThrowableOfType(FirstException.class.getName())), allMethodsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(methods().that().doNotDeclareThrowableOfType(equivalentTo(FirstException.class))), + arguments(described(methods().that().doNotDeclareThrowableOfType(equivalentTo(FirstException.class))), allMethodsExcept(METHOD_ONE_ARG, METHOD_THREE_ARGS)), - $(described(constructors().that().declareThrowableOfType(FirstException.class)), + arguments(described(constructors().that().declareThrowableOfType(FirstException.class)), ImmutableSet.of(CONSTRUCTOR_ONE_ARG, CONSTRUCTOR_THREE_ARGS)), - $(described(constructors().that().declareThrowableOfType(FirstException.class.getName())), + arguments(described(constructors().that().declareThrowableOfType(FirstException.class.getName())), ImmutableSet.of(CONSTRUCTOR_ONE_ARG, CONSTRUCTOR_THREE_ARGS)), - $(described(constructors().that().declareThrowableOfType(equivalentTo(FirstException.class))), + arguments(described(constructors().that().declareThrowableOfType(equivalentTo(FirstException.class))), ImmutableSet.of(CONSTRUCTOR_ONE_ARG, CONSTRUCTOR_THREE_ARGS)), - $(described(constructors().that().doNotDeclareThrowableOfType(FirstException.class)), + arguments(described(constructors().that().doNotDeclareThrowableOfType(FirstException.class)), allConstructorsExcept(CONSTRUCTOR_ONE_ARG, CONSTRUCTOR_THREE_ARGS)), - $(described(constructors().that().doNotDeclareThrowableOfType(FirstException.class.getName())), + arguments(described(constructors().that().doNotDeclareThrowableOfType(FirstException.class.getName())), allConstructorsExcept(CONSTRUCTOR_ONE_ARG, CONSTRUCTOR_THREE_ARGS)), - $(described(constructors().that().doNotDeclareThrowableOfType(equivalentTo(FirstException.class))), + arguments(described(constructors().that().doNotDeclareThrowableOfType(equivalentTo(FirstException.class))), allConstructorsExcept(CONSTRUCTOR_ONE_ARG, CONSTRUCTOR_THREE_ARGS)) ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenFieldsTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenFieldsTest.java index 36b263bbab..62eba57191 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenFieldsTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenFieldsTest.java @@ -24,8 +24,8 @@ import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.beAnnotatedWith; import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.described; import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.everythingViolationPrintMemberName; -import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class GivenFieldsTest { @@ -46,20 +46,20 @@ public void complex_field_syntax() { static Stream restricted_property_rule_starts() { return Stream.of( - $(described(fields().that().haveRawType(String.class)), ImmutableSet.of(FIELD_A)), - $(described(fields().that().haveRawType(String.class.getName())), ImmutableSet.of(FIELD_A)), - $(described(fields().that().haveRawType(equivalentTo(String.class))), ImmutableSet.of(FIELD_A)), + arguments(described(fields().that().haveRawType(String.class)), ImmutableSet.of(FIELD_A)), + arguments(described(fields().that().haveRawType(String.class.getName())), ImmutableSet.of(FIELD_A)), + arguments(described(fields().that().haveRawType(equivalentTo(String.class))), ImmutableSet.of(FIELD_A)), - $(described(fields().that().doNotHaveRawType(String.class)), allFieldsExcept(FIELD_A)), - $(described(fields().that().doNotHaveRawType(String.class.getName())), allFieldsExcept(FIELD_A)), - $(described(fields().that().doNotHaveRawType(equivalentTo(String.class))), allFieldsExcept(FIELD_A)), + arguments(described(fields().that().doNotHaveRawType(String.class)), allFieldsExcept(FIELD_A)), + arguments(described(fields().that().doNotHaveRawType(String.class.getName())), allFieldsExcept(FIELD_A)), + arguments(described(fields().that().doNotHaveRawType(equivalentTo(String.class))), allFieldsExcept(FIELD_A)), - $(described(fields().that().areFinal()), ImmutableSet.of(FIELD_A, FIELD_B)), - $(described(fields().that().areNotFinal()), ImmutableSet.of(FIELD_C, FIELD_D)), - $(described(fields().that().areStatic()), ImmutableSet.of(FIELD_B, FIELD_D)), - $(described(fields().that().areNotStatic()), ImmutableSet.of(FIELD_A, FIELD_C)), + arguments(described(fields().that().areFinal()), ImmutableSet.of(FIELD_A, FIELD_B)), + arguments(described(fields().that().areNotFinal()), ImmutableSet.of(FIELD_C, FIELD_D)), + arguments(described(fields().that().areStatic()), ImmutableSet.of(FIELD_B, FIELD_D)), + arguments(described(fields().that().areNotStatic()), ImmutableSet.of(FIELD_A, FIELD_C)), - $(described(fields().that().areStatic().and().areFinal()), ImmutableSet.of(FIELD_B)) + arguments(described(fields().that().areStatic().and().areFinal()), ImmutableSet.of(FIELD_B)) ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMembersTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMembersTest.java index 9d9dc5d4cb..4961fea7d3 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMembersTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMembersTest.java @@ -21,6 +21,7 @@ import com.tngtech.archunit.lang.EvaluationResult; import com.tngtech.archunit.lang.SimpleConditionEvent; import com.tngtech.archunit.testutil.ArchConfigurationExtension; +import com.tngtech.archunit.testutil.TestUtils; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.junit.jupiter.params.ParameterizedTest; @@ -49,12 +50,12 @@ import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noFields; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noMembers; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noMethods; -import static com.tngtech.archunit.testutil.DataProviders.$; import static com.tngtech.archunit.testutil.TestUtils.union; import static java.util.Collections.emptySet; import static java.util.Collections.singleton; import static java.util.regex.Pattern.quote; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class GivenMembersTest { @@ -63,49 +64,49 @@ public class GivenMembersTest { static Stream member_syntax_testcases() { return Stream.of( - $(members(), "members", never(beAnnotatedWith(C.class)), + arguments(members(), "members", never(beAnnotatedWith(C.class)), ImmutableList.of( String.format("Member '%s' is annotated with @C", FIELD_ANNOTATED_WITH_B_AND_C), String.format("Member '%s' is annotated with @C", CONSTRUCTOR_ANNOTATED_WITH_B_AND_C), String.format("Member '%s' is annotated with @C", METHOD_ANNOTATED_WITH_B_AND_C) )), - $(noMembers(), "no members", beAnnotatedWith(C.class), + arguments(noMembers(), "no members", beAnnotatedWith(C.class), ImmutableList.of( String.format("Member '%s' is annotated with @C", FIELD_ANNOTATED_WITH_B_AND_C), String.format("Member '%s' is annotated with @C", CONSTRUCTOR_ANNOTATED_WITH_B_AND_C), String.format("Member '%s' is annotated with @C", METHOD_ANNOTATED_WITH_B_AND_C) )), - $(fields(), "fields", never(beAnnotatedWith(C.class)), + arguments(fields(), "fields", never(beAnnotatedWith(C.class)), ImmutableList.of( String.format("Member '%s' is annotated with @C", FIELD_ANNOTATED_WITH_B_AND_C) )), - $(noFields(), "no fields", beAnnotatedWith(C.class), + arguments(noFields(), "no fields", beAnnotatedWith(C.class), ImmutableList.of( String.format("Member '%s' is annotated with @C", FIELD_ANNOTATED_WITH_B_AND_C) )), - $(codeUnits(), "code units", never(beAnnotatedWith(C.class)), + arguments(codeUnits(), "code units", never(beAnnotatedWith(C.class)), ImmutableList.of( String.format("Member '%s' is annotated with @C", CONSTRUCTOR_ANNOTATED_WITH_B_AND_C), String.format("Member '%s' is annotated with @C", METHOD_ANNOTATED_WITH_B_AND_C) )), - $(noCodeUnits(), "no code units", beAnnotatedWith(C.class), + arguments(noCodeUnits(), "no code units", beAnnotatedWith(C.class), ImmutableList.of( String.format("Member '%s' is annotated with @C", CONSTRUCTOR_ANNOTATED_WITH_B_AND_C), String.format("Member '%s' is annotated with @C", METHOD_ANNOTATED_WITH_B_AND_C) )), - $(methods(), "methods", never(beAnnotatedWith(C.class)), + arguments(methods(), "methods", never(beAnnotatedWith(C.class)), ImmutableList.of( String.format("Member '%s' is annotated with @C", METHOD_ANNOTATED_WITH_B_AND_C) )), - $(noMethods(), "no methods", beAnnotatedWith(C.class), + arguments(noMethods(), "no methods", beAnnotatedWith(C.class), ImmutableList.of( String.format("Member '%s' is annotated with @C", METHOD_ANNOTATED_WITH_B_AND_C) )), - $(constructors(), "constructors", never(beAnnotatedWith(C.class)), + arguments(constructors(), "constructors", never(beAnnotatedWith(C.class)), ImmutableList.of( String.format("Member '%s' is annotated with @C", CONSTRUCTOR_ANNOTATED_WITH_B_AND_C) )), - $(noConstructors(), "no constructors", beAnnotatedWith(C.class), + arguments(noConstructors(), "no constructors", beAnnotatedWith(C.class), ImmutableList.of( String.format("Member '%s' is annotated with @C", CONSTRUCTOR_ANNOTATED_WITH_B_AND_C) )) @@ -151,176 +152,176 @@ public void complex_members_syntax() { static List restricted_property_rule_starts() { String classNameDot = ClassWithVariousMembers.class.getName() + "."; return ImmutableList.builder().add( - $(described(members().that().haveName(FIELD_A)), ImmutableSet.of(FIELD_A)), - $(described(codeUnits().that().haveName(FIELD_A)), ImmutableSet.of()), - $(described(fields().that().haveName(FIELD_A)), ImmutableSet.of(FIELD_A)), - $(described(codeUnits().that().haveName("methodA")), ImmutableSet.of(METHOD_A)), - $(described(methods().that().haveName("methodA")), ImmutableSet.of(METHOD_A)), - $(described(codeUnits().that().haveName(CONSTRUCTOR_NAME)), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(constructors().that().haveName(CONSTRUCTOR_NAME)), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(members().that().doNotHaveName(FIELD_A)), union( + arguments(described(members().that().haveName(FIELD_A)), ImmutableSet.of(FIELD_A)), + arguments(described(codeUnits().that().haveName(FIELD_A)), ImmutableSet.of()), + arguments(described(fields().that().haveName(FIELD_A)), ImmutableSet.of(FIELD_A)), + arguments(described(codeUnits().that().haveName("methodA")), ImmutableSet.of(METHOD_A)), + arguments(described(methods().that().haveName("methodA")), ImmutableSet.of(METHOD_A)), + arguments(described(codeUnits().that().haveName(CONSTRUCTOR_NAME)), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(described(constructors().that().haveName(CONSTRUCTOR_NAME)), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(described(members().that().doNotHaveName(FIELD_A)), union( allFieldsExcept(FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS)), - $(described(codeUnits().that().doNotHaveName(FIELD_A)), ALL_CODE_UNIT_DESCRIPTIONS), - $(described(fields().that().doNotHaveName(FIELD_A)), allFieldsExcept(FIELD_A)), - $(described(codeUnits().that().doNotHaveName("methodA")), union( + arguments(described(codeUnits().that().doNotHaveName(FIELD_A)), ALL_CODE_UNIT_DESCRIPTIONS), + arguments(described(fields().that().doNotHaveName(FIELD_A)), allFieldsExcept(FIELD_A)), + arguments(described(codeUnits().that().doNotHaveName("methodA")), union( allMethodsExcept(METHOD_A), ALL_CONSTRUCTOR_DESCRIPTIONS)), - $(described(methods().that().doNotHaveName("methodA")), allMethodsExcept(METHOD_A)), - $(described(codeUnits().that().doNotHaveName(CONSTRUCTOR_NAME)), ALL_METHOD_DESCRIPTIONS), - $(described(constructors().that().doNotHaveName(CONSTRUCTOR_NAME)), ImmutableSet.of()), - - $(described(members().that().haveNameMatching("f.*A")), ImmutableSet.of(FIELD_A)), - $(described(codeUnits().that().haveNameMatching("f.*A")), ImmutableSet.of()), - $(described(fields().that().haveNameMatching("f.*A")), ImmutableSet.of(FIELD_A)), - $(described(codeUnits().that().haveNameMatching("m.*A")), ImmutableSet.of(METHOD_A)), - $(described(methods().that().haveNameMatching("m.*A")), ImmutableSet.of(METHOD_A)), - $(described(codeUnits().that().haveNameMatching(".*init.*")), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(constructors().that().haveNameMatching(".*init.*")), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(members().that().haveNameNotMatching("f.*A")), union( + arguments(described(methods().that().doNotHaveName("methodA")), allMethodsExcept(METHOD_A)), + arguments(described(codeUnits().that().doNotHaveName(CONSTRUCTOR_NAME)), ALL_METHOD_DESCRIPTIONS), + arguments(described(constructors().that().doNotHaveName(CONSTRUCTOR_NAME)), ImmutableSet.of()), + + arguments(described(members().that().haveNameMatching("f.*A")), ImmutableSet.of(FIELD_A)), + arguments(described(codeUnits().that().haveNameMatching("f.*A")), ImmutableSet.of()), + arguments(described(fields().that().haveNameMatching("f.*A")), ImmutableSet.of(FIELD_A)), + arguments(described(codeUnits().that().haveNameMatching("m.*A")), ImmutableSet.of(METHOD_A)), + arguments(described(methods().that().haveNameMatching("m.*A")), ImmutableSet.of(METHOD_A)), + arguments(described(codeUnits().that().haveNameMatching(".*init.*")), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(described(constructors().that().haveNameMatching(".*init.*")), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(described(members().that().haveNameNotMatching("f.*A")), union( allFieldsExcept(FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS)), - $(described(codeUnits().that().haveNameNotMatching("f.*A")), ALL_CODE_UNIT_DESCRIPTIONS), - $(described(fields().that().haveNameNotMatching("f.*A")), allFieldsExcept(FIELD_A)), - $(described(codeUnits().that().haveNameNotMatching("m.*A")), union( + arguments(described(codeUnits().that().haveNameNotMatching("f.*A")), ALL_CODE_UNIT_DESCRIPTIONS), + arguments(described(fields().that().haveNameNotMatching("f.*A")), allFieldsExcept(FIELD_A)), + arguments(described(codeUnits().that().haveNameNotMatching("m.*A")), union( allMethodsExcept(METHOD_A), ALL_CONSTRUCTOR_DESCRIPTIONS)), - $(described(methods().that().haveNameNotMatching("m.*A")), allMethodsExcept(METHOD_A)), - $(described(codeUnits().that().haveNameNotMatching(".*init.*")), ALL_METHOD_DESCRIPTIONS), - $(described(constructors().that().haveNameNotMatching(".*init.*")), emptySet()), - - $(described(members().that().haveFullName(classNameDot + FIELD_A)), ImmutableSet.of(FIELD_A)), - $(described(codeUnits().that().haveFullName(classNameDot + METHOD_A)), ImmutableSet.of(METHOD_A)), - $(described(methods().that().haveFullName(classNameDot + METHOD_A)), ImmutableSet.of(METHOD_A)), - $(described(constructors().that().haveFullName(classNameDot + CONSTRUCTOR_ONE_ARG)), ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), - $(described(fields().that().haveFullName(classNameDot + FIELD_A)), ImmutableSet.of(FIELD_A)), - $(described(members().that().doNotHaveFullName(classNameDot + FIELD_A)), union(allFieldsExcept(FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS)), - $(described(codeUnits().that().doNotHaveFullName(classNameDot + METHOD_A)), allCodeUnitsExcept(METHOD_A)), - $(described(methods().that().doNotHaveFullName(classNameDot + METHOD_A)), allMethodsExcept(METHOD_A)), - $(described(constructors().that().doNotHaveFullName(classNameDot + CONSTRUCTOR_ONE_ARG)), allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), - $(described(fields().that().doNotHaveFullName(classNameDot + FIELD_A)), allFieldsExcept(FIELD_A)), - - $(described(members().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(FIELD_A, METHOD_A)), - $(described(codeUnits().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(METHOD_A)), - $(described(methods().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(METHOD_A)), - $(described(constructors().that().haveFullNameMatching(quote(classNameDot) + ".*init.*String\\)")), + arguments(described(methods().that().haveNameNotMatching("m.*A")), allMethodsExcept(METHOD_A)), + arguments(described(codeUnits().that().haveNameNotMatching(".*init.*")), ALL_METHOD_DESCRIPTIONS), + arguments(described(constructors().that().haveNameNotMatching(".*init.*")), emptySet()), + + arguments(described(members().that().haveFullName(classNameDot + FIELD_A)), ImmutableSet.of(FIELD_A)), + arguments(described(codeUnits().that().haveFullName(classNameDot + METHOD_A)), ImmutableSet.of(METHOD_A)), + arguments(described(methods().that().haveFullName(classNameDot + METHOD_A)), ImmutableSet.of(METHOD_A)), + arguments(described(constructors().that().haveFullName(classNameDot + CONSTRUCTOR_ONE_ARG)), ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), + arguments(described(fields().that().haveFullName(classNameDot + FIELD_A)), ImmutableSet.of(FIELD_A)), + arguments(described(members().that().doNotHaveFullName(classNameDot + FIELD_A)), union(allFieldsExcept(FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS)), + arguments(described(codeUnits().that().doNotHaveFullName(classNameDot + METHOD_A)), allCodeUnitsExcept(METHOD_A)), + arguments(described(methods().that().doNotHaveFullName(classNameDot + METHOD_A)), allMethodsExcept(METHOD_A)), + arguments(described(constructors().that().doNotHaveFullName(classNameDot + CONSTRUCTOR_ONE_ARG)), allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), + arguments(described(fields().that().doNotHaveFullName(classNameDot + FIELD_A)), allFieldsExcept(FIELD_A)), + + arguments(described(members().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(FIELD_A, METHOD_A)), + arguments(described(codeUnits().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(METHOD_A)), + arguments(described(methods().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(METHOD_A)), + arguments(described(constructors().that().haveFullNameMatching(quote(classNameDot) + ".*init.*String\\)")), ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), - $(described(fields().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(FIELD_A)), - $(described(members().that().haveFullNameNotMatching(quote(classNameDot) + "f.*A.*")), union( + arguments(described(fields().that().haveFullNameMatching(quote(classNameDot) + ".*A.*")), ImmutableSet.of(FIELD_A)), + arguments(described(members().that().haveFullNameNotMatching(quote(classNameDot) + "f.*A.*")), union( allFieldsExcept(FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS)), - $(described(codeUnits().that().haveFullNameNotMatching(quote(classNameDot) + "f.*A.*")), ALL_CODE_UNIT_DESCRIPTIONS), - $(described(methods().that().haveFullNameNotMatching(quote(classNameDot) + ".*A.*")), allMethodsExcept(METHOD_A)), - $(described(constructors().that().haveFullNameNotMatching(quote(classNameDot) + ".*init.*String\\)")), + arguments(described(codeUnits().that().haveFullNameNotMatching(quote(classNameDot) + "f.*A.*")), ALL_CODE_UNIT_DESCRIPTIONS), + arguments(described(methods().that().haveFullNameNotMatching(quote(classNameDot) + ".*A.*")), allMethodsExcept(METHOD_A)), + arguments(described(constructors().that().haveFullNameNotMatching(quote(classNameDot) + ".*init.*String\\)")), allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), - $(described(fields().that().haveFullNameNotMatching(quote(classNameDot) + ".*A.*")), allFieldsExcept(FIELD_A)), - - $(described(members().that().haveNameStartingWith("fie")), ALL_FIELD_DESCRIPTIONS), - $(described(codeUnits().that().haveNameStartingWith("me")), ALL_METHOD_DESCRIPTIONS), - $(described(methods().that().haveNameStartingWith("m")), ALL_METHOD_DESCRIPTIONS), - $(described(constructors().that().haveNameStartingWith("<")), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(fields().that().haveNameStartingWith("f")), ALL_FIELD_DESCRIPTIONS), - $(described(members().that().haveNameNotStartingWith("fie")), ALL_CODE_UNIT_DESCRIPTIONS), - $(described(codeUnits().that().haveNameNotStartingWith("me")), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(methods().that().haveNameNotStartingWith("m")), emptySet()), - $(described(constructors().that().haveNameNotStartingWith("<")), emptySet()), - $(described(fields().that().haveNameNotStartingWith("f")), emptySet()), - - $(described(members().that().haveNameContaining("et")), ALL_METHOD_DESCRIPTIONS), - $(described(codeUnits().that().haveNameContaining("et")), ALL_METHOD_DESCRIPTIONS), - $(described(methods().that().haveNameContaining("dA")), ImmutableSet.of(METHOD_A)), - $(described(constructors().that().haveNameContaining("init")), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(fields().that().haveNameContaining("dA")), ImmutableSet.of(FIELD_A)), - $(described(members().that().haveNameNotContaining("et")), union(ALL_FIELD_DESCRIPTIONS, ALL_CONSTRUCTOR_DESCRIPTIONS)), - $(described(codeUnits().that().haveNameNotContaining("et")), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(methods().that().haveNameNotContaining("dA")), allMethodsExcept(METHOD_A)), - $(described(constructors().that().haveNameNotContaining("init")), emptySet()), - $(described(fields().that().haveNameNotContaining("dA")), allFieldsExcept(FIELD_A)), - - $(described(members().that().haveNameEndingWith("D")), ImmutableSet.of(FIELD_D, METHOD_D)), - $(described(codeUnits().that().haveNameEndingWith("A")), ImmutableSet.of(METHOD_A)), - $(described(methods().that().haveNameEndingWith("C")), ImmutableSet.of(METHOD_C)), - $(described(constructors().that().haveNameEndingWith("it>")), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(fields().that().haveNameEndingWith("B")), ImmutableSet.of(FIELD_B)), - $(described(members().that().haveNameNotEndingWith("D")), allMembersExcept(FIELD_D, METHOD_D)), - $(described(codeUnits().that().haveNameNotEndingWith("A")), allCodeUnitsExcept(METHOD_A)), - $(described(methods().that().haveNameNotEndingWith("C")), allMethodsExcept(METHOD_C)), - $(described(constructors().that().haveNameNotEndingWith("it>")), emptySet()), - $(described(fields().that().haveNameNotEndingWith("B")), allFieldsExcept(FIELD_B)), - - $(described(members().that().arePublic()), ImmutableSet.of( + arguments(described(fields().that().haveFullNameNotMatching(quote(classNameDot) + ".*A.*")), allFieldsExcept(FIELD_A)), + + arguments(described(members().that().haveNameStartingWith("fie")), ALL_FIELD_DESCRIPTIONS), + arguments(described(codeUnits().that().haveNameStartingWith("me")), ALL_METHOD_DESCRIPTIONS), + arguments(described(methods().that().haveNameStartingWith("m")), ALL_METHOD_DESCRIPTIONS), + arguments(described(constructors().that().haveNameStartingWith("<")), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(described(fields().that().haveNameStartingWith("f")), ALL_FIELD_DESCRIPTIONS), + arguments(described(members().that().haveNameNotStartingWith("fie")), ALL_CODE_UNIT_DESCRIPTIONS), + arguments(described(codeUnits().that().haveNameNotStartingWith("me")), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(described(methods().that().haveNameNotStartingWith("m")), emptySet()), + arguments(described(constructors().that().haveNameNotStartingWith("<")), emptySet()), + arguments(described(fields().that().haveNameNotStartingWith("f")), emptySet()), + + arguments(described(members().that().haveNameContaining("et")), ALL_METHOD_DESCRIPTIONS), + arguments(described(codeUnits().that().haveNameContaining("et")), ALL_METHOD_DESCRIPTIONS), + arguments(described(methods().that().haveNameContaining("dA")), ImmutableSet.of(METHOD_A)), + arguments(described(constructors().that().haveNameContaining("init")), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(described(fields().that().haveNameContaining("dA")), ImmutableSet.of(FIELD_A)), + arguments(described(members().that().haveNameNotContaining("et")), TestUtils.union(ALL_FIELD_DESCRIPTIONS, ALL_CONSTRUCTOR_DESCRIPTIONS)), + arguments(described(codeUnits().that().haveNameNotContaining("et")), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(described(methods().that().haveNameNotContaining("dA")), allMethodsExcept(METHOD_A)), + arguments(described(constructors().that().haveNameNotContaining("init")), emptySet()), + arguments(described(fields().that().haveNameNotContaining("dA")), allFieldsExcept(FIELD_A)), + + arguments(described(members().that().haveNameEndingWith("D")), ImmutableSet.of(FIELD_D, METHOD_D)), + arguments(described(codeUnits().that().haveNameEndingWith("A")), ImmutableSet.of(METHOD_A)), + arguments(described(methods().that().haveNameEndingWith("C")), ImmutableSet.of(METHOD_C)), + arguments(described(constructors().that().haveNameEndingWith("it>")), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(described(fields().that().haveNameEndingWith("B")), ImmutableSet.of(FIELD_B)), + arguments(described(members().that().haveNameNotEndingWith("D")), allMembersExcept(FIELD_D, METHOD_D)), + arguments(described(codeUnits().that().haveNameNotEndingWith("A")), allCodeUnitsExcept(METHOD_A)), + arguments(described(methods().that().haveNameNotEndingWith("C")), allMethodsExcept(METHOD_C)), + arguments(described(constructors().that().haveNameNotEndingWith("it>")), emptySet()), + arguments(described(fields().that().haveNameNotEndingWith("B")), allFieldsExcept(FIELD_B)), + + arguments(described(members().that().arePublic()), ImmutableSet.of( FIELD_PUBLIC, METHOD_PUBLIC, CONSTRUCTOR_PUBLIC)), - $(described(fields().that().arePublic()), ImmutableSet.of(FIELD_C)), - $(described(codeUnits().that().arePublic()), ImmutableSet.of(METHOD_PUBLIC, CONSTRUCTOR_PUBLIC)), - $(described(methods().that().arePublic()), ImmutableSet.of(METHOD_PUBLIC)), - $(described(constructors().that().arePublic()), ImmutableSet.of(CONSTRUCTOR_PUBLIC)), - $(described(members().that().areNotPublic()), + arguments(described(fields().that().arePublic()), ImmutableSet.of(FIELD_C)), + arguments(described(codeUnits().that().arePublic()), ImmutableSet.of(METHOD_PUBLIC, CONSTRUCTOR_PUBLIC)), + arguments(described(methods().that().arePublic()), ImmutableSet.of(METHOD_PUBLIC)), + arguments(described(constructors().that().arePublic()), ImmutableSet.of(CONSTRUCTOR_PUBLIC)), + arguments(described(members().that().areNotPublic()), allMembersExcept(FIELD_PUBLIC, METHOD_PUBLIC, CONSTRUCTOR_PUBLIC)), - $(described(fields().that().areNotPublic()), allFieldsExcept(FIELD_C)), - $(described(codeUnits().that().areNotPublic()), + arguments(described(fields().that().areNotPublic()), allFieldsExcept(FIELD_C)), + arguments(described(codeUnits().that().areNotPublic()), allCodeUnitsExcept(METHOD_PUBLIC, CONSTRUCTOR_PUBLIC)), - $(described(methods().that().areNotPublic()), allMethodsExcept(METHOD_PUBLIC)), - $(described(constructors().that().areNotPublic()), allConstructorsExcept(CONSTRUCTOR_PUBLIC)), + arguments(described(methods().that().areNotPublic()), allMethodsExcept(METHOD_PUBLIC)), + arguments(described(constructors().that().areNotPublic()), allConstructorsExcept(CONSTRUCTOR_PUBLIC)), - $(described(members().that().areProtected()), ImmutableSet.of( + arguments(described(members().that().areProtected()), ImmutableSet.of( FIELD_PROTECTED, METHOD_PROTECTED, CONSTRUCTOR_PROTECTED)), - $(described(fields().that().areProtected()), ImmutableSet.of(FIELD_PROTECTED)), - $(described(codeUnits().that().areProtected()), ImmutableSet.of( + arguments(described(fields().that().areProtected()), ImmutableSet.of(FIELD_PROTECTED)), + arguments(described(codeUnits().that().areProtected()), ImmutableSet.of( METHOD_PROTECTED, CONSTRUCTOR_PROTECTED)), - $(described(methods().that().areProtected()), ImmutableSet.of(METHOD_PROTECTED)), - $(described(constructors().that().areProtected()), ImmutableSet.of(CONSTRUCTOR_PROTECTED)), - $(described(members().that().areNotProtected()), + arguments(described(methods().that().areProtected()), ImmutableSet.of(METHOD_PROTECTED)), + arguments(described(constructors().that().areProtected()), ImmutableSet.of(CONSTRUCTOR_PROTECTED)), + arguments(described(members().that().areNotProtected()), allMembersExcept(FIELD_PROTECTED, METHOD_PROTECTED, CONSTRUCTOR_PROTECTED)), - $(described(fields().that().areNotProtected()), allFieldsExcept(FIELD_PROTECTED)), - $(described(codeUnits().that().areNotProtected()), + arguments(described(fields().that().areNotProtected()), allFieldsExcept(FIELD_PROTECTED)), + arguments(described(codeUnits().that().areNotProtected()), allCodeUnitsExcept(METHOD_PROTECTED, CONSTRUCTOR_PROTECTED)), - $(described(methods().that().areNotProtected()), allMethodsExcept(METHOD_PROTECTED)), - $(described(constructors().that().areNotProtected()), allConstructorsExcept(CONSTRUCTOR_PROTECTED)), + arguments(described(methods().that().areNotProtected()), allMethodsExcept(METHOD_PROTECTED)), + arguments(described(constructors().that().areNotProtected()), allConstructorsExcept(CONSTRUCTOR_PROTECTED)), - $(described(members().that().arePackagePrivate()), ImmutableSet.of( + arguments(described(members().that().arePackagePrivate()), ImmutableSet.of( FIELD_PACKAGE_PRIVATE, METHOD_PACKAGE_PRIVATE, CONSTRUCTOR_PACKAGE_PRIVATE)), - $(described(fields().that().arePackagePrivate()), ImmutableSet.of(FIELD_PACKAGE_PRIVATE)), - $(described(codeUnits().that().arePackagePrivate()), ImmutableSet.of( + arguments(described(fields().that().arePackagePrivate()), ImmutableSet.of(FIELD_PACKAGE_PRIVATE)), + arguments(described(codeUnits().that().arePackagePrivate()), ImmutableSet.of( METHOD_PACKAGE_PRIVATE, CONSTRUCTOR_PACKAGE_PRIVATE)), - $(described(methods().that().arePackagePrivate()), ImmutableSet.of(METHOD_PACKAGE_PRIVATE)), - $(described(constructors().that().arePackagePrivate()), ImmutableSet.of(CONSTRUCTOR_PACKAGE_PRIVATE)), - $(described(members().that().areNotPackagePrivate()), + arguments(described(methods().that().arePackagePrivate()), ImmutableSet.of(METHOD_PACKAGE_PRIVATE)), + arguments(described(constructors().that().arePackagePrivate()), ImmutableSet.of(CONSTRUCTOR_PACKAGE_PRIVATE)), + arguments(described(members().that().areNotPackagePrivate()), allMembersExcept(FIELD_PACKAGE_PRIVATE, METHOD_PACKAGE_PRIVATE, CONSTRUCTOR_PACKAGE_PRIVATE)), - $(described(fields().that().areNotPackagePrivate()), allFieldsExcept(FIELD_PACKAGE_PRIVATE)), - $(described(codeUnits().that().areNotPackagePrivate()), + arguments(described(fields().that().areNotPackagePrivate()), allFieldsExcept(FIELD_PACKAGE_PRIVATE)), + arguments(described(codeUnits().that().areNotPackagePrivate()), allCodeUnitsExcept(METHOD_PACKAGE_PRIVATE, CONSTRUCTOR_PACKAGE_PRIVATE)), - $(described(methods().that().areNotPackagePrivate()), allMethodsExcept(METHOD_PACKAGE_PRIVATE)), - $(described(constructors().that().areNotPackagePrivate()), allConstructorsExcept(CONSTRUCTOR_PACKAGE_PRIVATE)), + arguments(described(methods().that().areNotPackagePrivate()), allMethodsExcept(METHOD_PACKAGE_PRIVATE)), + arguments(described(constructors().that().areNotPackagePrivate()), allConstructorsExcept(CONSTRUCTOR_PACKAGE_PRIVATE)), - $(described(members().that().arePrivate()), ImmutableSet.of( + arguments(described(members().that().arePrivate()), ImmutableSet.of( FIELD_PRIVATE, METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(fields().that().arePrivate()), ImmutableSet.of(FIELD_PRIVATE)), - $(described(codeUnits().that().arePrivate()), ImmutableSet.of( + arguments(described(fields().that().arePrivate()), ImmutableSet.of(FIELD_PRIVATE)), + arguments(described(codeUnits().that().arePrivate()), ImmutableSet.of( METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(methods().that().arePrivate()), ImmutableSet.of(METHOD_PRIVATE)), - $(described(constructors().that().arePrivate()), ImmutableSet.of(CONSTRUCTOR_PRIVATE)), - $(described(members().that().areNotPrivate()), + arguments(described(methods().that().arePrivate()), ImmutableSet.of(METHOD_PRIVATE)), + arguments(described(constructors().that().arePrivate()), ImmutableSet.of(CONSTRUCTOR_PRIVATE)), + arguments(described(members().that().areNotPrivate()), allMembersExcept(FIELD_PRIVATE, METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(fields().that().areNotPrivate()), allFieldsExcept(FIELD_PRIVATE)), - $(described(codeUnits().that().areNotPrivate()), + arguments(described(fields().that().areNotPrivate()), allFieldsExcept(FIELD_PRIVATE)), + arguments(described(codeUnits().that().areNotPrivate()), allCodeUnitsExcept(METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(methods().that().areNotPrivate()), allMethodsExcept(METHOD_PRIVATE)), - $(described(constructors().that().areNotPrivate()), allConstructorsExcept(CONSTRUCTOR_PRIVATE)), + arguments(described(methods().that().areNotPrivate()), allMethodsExcept(METHOD_PRIVATE)), + arguments(described(constructors().that().areNotPrivate()), allConstructorsExcept(CONSTRUCTOR_PRIVATE)), - $(described(members().that().haveModifier(PRIVATE)), ImmutableSet.of( + arguments(described(members().that().haveModifier(PRIVATE)), ImmutableSet.of( FIELD_PRIVATE, METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(fields().that().haveModifier(PRIVATE)), ImmutableSet.of(FIELD_PRIVATE)), - $(described(codeUnits().that().haveModifier(PRIVATE)), ImmutableSet.of( + arguments(described(fields().that().haveModifier(PRIVATE)), ImmutableSet.of(FIELD_PRIVATE)), + arguments(described(codeUnits().that().haveModifier(PRIVATE)), ImmutableSet.of( METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(methods().that().haveModifier(PRIVATE)), ImmutableSet.of(METHOD_PRIVATE)), - $(described(constructors().that().haveModifier(PRIVATE)), ImmutableSet.of(CONSTRUCTOR_PRIVATE)), - $(described(members().that().doNotHaveModifier(PRIVATE)), + arguments(described(methods().that().haveModifier(PRIVATE)), ImmutableSet.of(METHOD_PRIVATE)), + arguments(described(constructors().that().haveModifier(PRIVATE)), ImmutableSet.of(CONSTRUCTOR_PRIVATE)), + arguments(described(members().that().doNotHaveModifier(PRIVATE)), allMembersExcept(FIELD_PRIVATE, METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(fields().that().doNotHaveModifier(PRIVATE)), allFieldsExcept(FIELD_PRIVATE)), - $(described(codeUnits().that().doNotHaveModifier(PRIVATE)), + arguments(described(fields().that().doNotHaveModifier(PRIVATE)), allFieldsExcept(FIELD_PRIVATE)), + arguments(described(codeUnits().that().doNotHaveModifier(PRIVATE)), allCodeUnitsExcept(METHOD_PRIVATE, CONSTRUCTOR_PRIVATE)), - $(described(methods().that().doNotHaveModifier(PRIVATE)), allMethodsExcept(METHOD_PRIVATE)), - $(described(constructors().that().doNotHaveModifier(PRIVATE)), allConstructorsExcept(CONSTRUCTOR_PRIVATE)) + arguments(described(methods().that().doNotHaveModifier(PRIVATE)), allMethodsExcept(METHOD_PRIVATE)), + arguments(described(constructors().that().doNotHaveModifier(PRIVATE)), allConstructorsExcept(CONSTRUCTOR_PRIVATE)) ) .addAll(annotatedWithDataPoints( membersThat -> membersThat.areAnnotatedWith(A.class), @@ -352,20 +353,20 @@ private static List annotatedWithDataPoints( @SuppressWarnings({"unchecked", "rawtypes"}) Function> areNotAnnotatedWithA = (Function) makeNotAnnotatedWithMatchingA; return ImmutableList.of( - $(described(areAnnotatedWithA.apply(members().that())), ImmutableSet.of( + arguments(described(areAnnotatedWithA.apply(members().that())), ImmutableSet.of( FIELD_ANNOTATED_WITH_A, METHOD_ANNOTATED_WITH_A, CONSTRUCTOR_ANNOTATED_WITH_A)), - $(described(areAnnotatedWithA.apply(fields().that())), ImmutableSet.of(FIELD_ANNOTATED_WITH_A)), - $(described(areAnnotatedWithA.apply(codeUnits().that())), ImmutableSet.of( + arguments(described(areAnnotatedWithA.apply(fields().that())), ImmutableSet.of(FIELD_ANNOTATED_WITH_A)), + arguments(described(areAnnotatedWithA.apply(codeUnits().that())), ImmutableSet.of( METHOD_ANNOTATED_WITH_A, CONSTRUCTOR_ANNOTATED_WITH_A)), - $(described(areAnnotatedWithA.apply(methods().that())), ImmutableSet.of(METHOD_ANNOTATED_WITH_A)), - $(described(areAnnotatedWithA.apply(constructors().that())), ImmutableSet.of(CONSTRUCTOR_ANNOTATED_WITH_A)), - $(described(areNotAnnotatedWithA.apply(members().that())), + arguments(described(areAnnotatedWithA.apply(methods().that())), ImmutableSet.of(METHOD_ANNOTATED_WITH_A)), + arguments(described(areAnnotatedWithA.apply(constructors().that())), ImmutableSet.of(CONSTRUCTOR_ANNOTATED_WITH_A)), + arguments(described(areNotAnnotatedWithA.apply(members().that())), allMembersExcept(FIELD_ANNOTATED_WITH_A, METHOD_ANNOTATED_WITH_A, CONSTRUCTOR_ANNOTATED_WITH_A)), - $(described(areNotAnnotatedWithA.apply(fields().that())), allFieldsExcept(FIELD_ANNOTATED_WITH_A)), - $(described(areNotAnnotatedWithA.apply(codeUnits().that())), + arguments(described(areNotAnnotatedWithA.apply(fields().that())), allFieldsExcept(FIELD_ANNOTATED_WITH_A)), + arguments(described(areNotAnnotatedWithA.apply(codeUnits().that())), allCodeUnitsExcept(METHOD_ANNOTATED_WITH_A, CONSTRUCTOR_ANNOTATED_WITH_A)), - $(described(areNotAnnotatedWithA.apply(methods().that())), allMethodsExcept(METHOD_ANNOTATED_WITH_A)), - $(described(areNotAnnotatedWithA.apply(constructors().that())), allConstructorsExcept(CONSTRUCTOR_ANNOTATED_WITH_A))); + arguments(described(areNotAnnotatedWithA.apply(methods().that())), allMethodsExcept(METHOD_ANNOTATED_WITH_A)), + arguments(described(areNotAnnotatedWithA.apply(constructors().that())), allConstructorsExcept(CONSTRUCTOR_ANNOTATED_WITH_A))); } @ParameterizedTest @@ -405,16 +406,16 @@ private static List declaredInDataPoints( @SuppressWarnings({"unchecked", "rawtypes"}) Function> areNotDeclaredInClass = (Function) makeNotDeclaredInClassWithVariousMembers; return ImmutableList.of( - $(described(areDeclaredInClass.apply(members().that())), ALL_MEMBER_DESCRIPTIONS), - $(described(areDeclaredInClass.apply(fields().that())), ALL_FIELD_DESCRIPTIONS), - $(described(areDeclaredInClass.apply(codeUnits().that())), ALL_CODE_UNIT_DESCRIPTIONS), - $(described(areDeclaredInClass.apply(methods().that())), ALL_METHOD_DESCRIPTIONS), - $(described(areDeclaredInClass.apply(constructors().that())), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(described(areNotDeclaredInClass.apply(members().that())), ALL_OTHER_MEMBER_DESCRIPTIONS), - $(described(areNotDeclaredInClass.apply(fields().that())), ALL_OTHER_FIELD_DESCRIPTIONS), - $(described(areNotDeclaredInClass.apply(codeUnits().that())), ALL_OTHER_CODE_UNIT_DESCRIPTIONS), - $(described(areNotDeclaredInClass.apply(methods().that())), ALL_OTHER_METHOD_DESCRIPTIONS), - $(described(areNotDeclaredInClass.apply(constructors().that())), ALL_OTHER_CONSTRUCTOR_DESCRIPTIONS)); + arguments(described(areDeclaredInClass.apply(members().that())), ALL_MEMBER_DESCRIPTIONS), + arguments(described(areDeclaredInClass.apply(fields().that())), ALL_FIELD_DESCRIPTIONS), + arguments(described(areDeclaredInClass.apply(codeUnits().that())), ALL_CODE_UNIT_DESCRIPTIONS), + arguments(described(areDeclaredInClass.apply(methods().that())), ALL_METHOD_DESCRIPTIONS), + arguments(described(areDeclaredInClass.apply(constructors().that())), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(described(areNotDeclaredInClass.apply(members().that())), ALL_OTHER_MEMBER_DESCRIPTIONS), + arguments(described(areNotDeclaredInClass.apply(fields().that())), ALL_OTHER_FIELD_DESCRIPTIONS), + arguments(described(areNotDeclaredInClass.apply(codeUnits().that())), ALL_OTHER_CODE_UNIT_DESCRIPTIONS), + arguments(described(areNotDeclaredInClass.apply(methods().that())), ALL_OTHER_METHOD_DESCRIPTIONS), + arguments(described(areNotDeclaredInClass.apply(constructors().that())), ALL_OTHER_CONSTRUCTOR_DESCRIPTIONS)); } @ParameterizedTest diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMethodsTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMethodsTest.java index 49e6a7169f..e777cad9e8 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMethodsTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenMethodsTest.java @@ -14,19 +14,19 @@ import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.DescribedRuleStart; import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.described; import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.everythingViolationPrintMemberName; -import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class GivenMethodsTest { static Stream restricted_property_rule_starts() { return Stream.of( - $(described(methods().that().areFinal()), ImmutableSet.of(METHOD_A, METHOD_B)), - $(described(methods().that().areNotFinal()), ImmutableSet.of(METHOD_C, METHOD_D)), - $(described(methods().that().areStatic()), ImmutableSet.of(METHOD_B, METHOD_D)), - $(described(methods().that().areNotStatic()), ImmutableSet.of(METHOD_A, METHOD_C)), - $(described(methods().that().areFinal().and().areStatic()), ImmutableSet.of(METHOD_B)), - $(described(methods().that().areFinal().or().areStatic()), ImmutableSet.of(METHOD_A, METHOD_B, METHOD_D)) + arguments(described(methods().that().areFinal()), ImmutableSet.of(METHOD_A, METHOD_B)), + arguments(described(methods().that().areNotFinal()), ImmutableSet.of(METHOD_C, METHOD_D)), + arguments(described(methods().that().areStatic()), ImmutableSet.of(METHOD_B, METHOD_D)), + arguments(described(methods().that().areNotStatic()), ImmutableSet.of(METHOD_A, METHOD_C)), + arguments(described(methods().that().areFinal().and().areStatic()), ImmutableSet.of(METHOD_B)), + arguments(described(methods().that().areFinal().or().areStatic()), ImmutableSet.of(METHOD_A, METHOD_B, METHOD_D)) ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MembersShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MembersShouldTest.java index df4cd0411f..0953dd36b2 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MembersShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MembersShouldTest.java @@ -87,13 +87,13 @@ import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.areNoFieldsWithType; import static com.tngtech.archunit.lang.syntax.elements.GivenMembersTest.assertViolation; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; -import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.Collections.emptySet; import static java.util.regex.Pattern.quote; import static java.util.stream.Collectors.toList; import static java.util.stream.Collectors.toSet; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class MembersShouldTest { @@ -121,169 +121,169 @@ public void complex_members_syntax() { static List restricted_property_rule_ends() { String classNameDot = ClassWithVariousMembers.class.getName() + "."; return ImmutableList.builder().add( - $(members().should().haveName(FIELD_A), allMembersExcept(FIELD_A)), - $(codeUnits().should().haveName(FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS), - $(fields().should().haveName(FIELD_A), allFieldsExcept(FIELD_A)), - $(codeUnits().should().haveName("methodA"), allCodeUnitsExcept(METHOD_A)), - $(methods().should().haveName("methodA"), allMethodsExcept(METHOD_A)), - $(codeUnits().should().haveName(CONSTRUCTOR_NAME), ALL_METHOD_DESCRIPTIONS), - $(constructors().should().haveName(CONSTRUCTOR_NAME), emptySet()), - $(members().should().notHaveName(FIELD_A), ImmutableSet.of(FIELD_A)), - $(codeUnits().should().notHaveName("methodA"), ImmutableSet.of(METHOD_A)), - $(fields().should().notHaveName(FIELD_A), ImmutableSet.of(FIELD_A)), - $(codeUnits().should().notHaveName("methodA"), ImmutableSet.of(METHOD_A)), - $(methods().should().notHaveName("methodA"), ImmutableSet.of(METHOD_A)), - $(codeUnits().should().notHaveName(CONSTRUCTOR_NAME), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(constructors().should().notHaveName(CONSTRUCTOR_NAME), ALL_CONSTRUCTOR_DESCRIPTIONS), - - $(members().should().haveNameMatching("f.*A"), allMembersExcept(FIELD_A)), - $(codeUnits().should().haveNameMatching("f.*A"), ALL_CODE_UNIT_DESCRIPTIONS), - $(fields().should().haveNameMatching("f.*A"), allFieldsExcept(FIELD_A)), - $(codeUnits().should().haveNameMatching("m.*A"), allCodeUnitsExcept(METHOD_A)), - $(methods().should().haveNameMatching("m.*A"), allMethodsExcept(METHOD_A)), - $(codeUnits().should().haveNameMatching(".*init.*"), ALL_METHOD_DESCRIPTIONS), - $(constructors().should().haveNameMatching(".*init.*"), emptySet()), - $(members().should().haveNameNotMatching("f.*A"), ImmutableSet.of(FIELD_A)), - $(codeUnits().should().haveNameNotMatching("f.*A"), emptySet()), - $(fields().should().haveNameNotMatching("f.*A"), ImmutableSet.of(FIELD_A)), - $(codeUnits().should().haveNameNotMatching("m.*A"), ImmutableSet.of(METHOD_A)), - $(methods().should().haveNameNotMatching("m.*A"), ImmutableSet.of(METHOD_A)), - $(codeUnits().should().haveNameNotMatching(".*init.*"), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(constructors().should().haveNameNotMatching(".*init.*"), ALL_CONSTRUCTOR_DESCRIPTIONS), - - $(members().should().haveFullName(classNameDot + FIELD_A), allMembersExcept(FIELD_A)), - $(fields().should().haveFullName(classNameDot + FIELD_A), allFieldsExcept(FIELD_A)), - $(codeUnits().should().haveFullName(classNameDot + FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS), - $(methods().should().haveFullName(classNameDot + METHOD_A), allMethodsExcept(METHOD_A)), - $(codeUnits().should().haveFullName(classNameDot + METHOD_A), allCodeUnitsExcept(METHOD_A)), - $(members().should().notHaveFullName(classNameDot + FIELD_A), ImmutableSet.of(FIELD_A)), - $(fields().should().notHaveFullName(classNameDot + FIELD_A), ImmutableSet.of(FIELD_A)), - $(codeUnits().should().notHaveFullName(classNameDot + FIELD_A), emptySet()), - $(methods().should().notHaveFullName(classNameDot + METHOD_A), ImmutableSet.of(METHOD_A)), - $(codeUnits().should().notHaveFullName(classNameDot + METHOD_A), ImmutableSet.of(METHOD_A)), - - $(members().should().haveFullNameMatching(quote(classNameDot) + ".*A\\(?\\)?"), allMembersExcept(FIELD_A, METHOD_A)), - $(codeUnits().should().haveFullNameMatching(quote(classNameDot) + ".*A"), ALL_CODE_UNIT_DESCRIPTIONS), - $(fields().should().haveFullNameMatching(quote(classNameDot) + ".*A"), allFieldsExcept(FIELD_A)), - $(codeUnits().should().haveFullNameMatching(quote(classNameDot) + ".*A" + quote("()")), allCodeUnitsExcept(METHOD_A)), - $(methods().should().haveFullNameMatching(quote(classNameDot) + ".*A" + quote("()")), allMethodsExcept(METHOD_A)), - $(codeUnits().should().haveFullNameMatching(quote(classNameDot) + "..*init.*"), ALL_METHOD_DESCRIPTIONS), - $(constructors().should().haveFullNameMatching(quote(classNameDot) + ".*init.*String\\)"), + arguments(members().should().haveName(FIELD_A), allMembersExcept(FIELD_A)), + arguments(codeUnits().should().haveName(FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS), + arguments(fields().should().haveName(FIELD_A), allFieldsExcept(FIELD_A)), + arguments(codeUnits().should().haveName("methodA"), allCodeUnitsExcept(METHOD_A)), + arguments(methods().should().haveName("methodA"), allMethodsExcept(METHOD_A)), + arguments(codeUnits().should().haveName(CONSTRUCTOR_NAME), ALL_METHOD_DESCRIPTIONS), + arguments(constructors().should().haveName(CONSTRUCTOR_NAME), emptySet()), + arguments(members().should().notHaveName(FIELD_A), ImmutableSet.of(FIELD_A)), + arguments(codeUnits().should().notHaveName("methodA"), ImmutableSet.of(METHOD_A)), + arguments(fields().should().notHaveName(FIELD_A), ImmutableSet.of(FIELD_A)), + arguments(codeUnits().should().notHaveName("methodA"), ImmutableSet.of(METHOD_A)), + arguments(methods().should().notHaveName("methodA"), ImmutableSet.of(METHOD_A)), + arguments(codeUnits().should().notHaveName(CONSTRUCTOR_NAME), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(constructors().should().notHaveName(CONSTRUCTOR_NAME), ALL_CONSTRUCTOR_DESCRIPTIONS), + + arguments(members().should().haveNameMatching("f.*A"), allMembersExcept(FIELD_A)), + arguments(codeUnits().should().haveNameMatching("f.*A"), ALL_CODE_UNIT_DESCRIPTIONS), + arguments(fields().should().haveNameMatching("f.*A"), allFieldsExcept(FIELD_A)), + arguments(codeUnits().should().haveNameMatching("m.*A"), allCodeUnitsExcept(METHOD_A)), + arguments(methods().should().haveNameMatching("m.*A"), allMethodsExcept(METHOD_A)), + arguments(codeUnits().should().haveNameMatching(".*init.*"), ALL_METHOD_DESCRIPTIONS), + arguments(constructors().should().haveNameMatching(".*init.*"), emptySet()), + arguments(members().should().haveNameNotMatching("f.*A"), ImmutableSet.of(FIELD_A)), + arguments(codeUnits().should().haveNameNotMatching("f.*A"), emptySet()), + arguments(fields().should().haveNameNotMatching("f.*A"), ImmutableSet.of(FIELD_A)), + arguments(codeUnits().should().haveNameNotMatching("m.*A"), ImmutableSet.of(METHOD_A)), + arguments(methods().should().haveNameNotMatching("m.*A"), ImmutableSet.of(METHOD_A)), + arguments(codeUnits().should().haveNameNotMatching(".*init.*"), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(constructors().should().haveNameNotMatching(".*init.*"), ALL_CONSTRUCTOR_DESCRIPTIONS), + + arguments(members().should().haveFullName(classNameDot + FIELD_A), allMembersExcept(FIELD_A)), + arguments(fields().should().haveFullName(classNameDot + FIELD_A), allFieldsExcept(FIELD_A)), + arguments(codeUnits().should().haveFullName(classNameDot + FIELD_A), ALL_CODE_UNIT_DESCRIPTIONS), + arguments(methods().should().haveFullName(classNameDot + METHOD_A), allMethodsExcept(METHOD_A)), + arguments(codeUnits().should().haveFullName(classNameDot + METHOD_A), allCodeUnitsExcept(METHOD_A)), + arguments(members().should().notHaveFullName(classNameDot + FIELD_A), ImmutableSet.of(FIELD_A)), + arguments(fields().should().notHaveFullName(classNameDot + FIELD_A), ImmutableSet.of(FIELD_A)), + arguments(codeUnits().should().notHaveFullName(classNameDot + FIELD_A), emptySet()), + arguments(methods().should().notHaveFullName(classNameDot + METHOD_A), ImmutableSet.of(METHOD_A)), + arguments(codeUnits().should().notHaveFullName(classNameDot + METHOD_A), ImmutableSet.of(METHOD_A)), + + arguments(members().should().haveFullNameMatching(quote(classNameDot) + ".*A\\(?\\)?"), allMembersExcept(FIELD_A, METHOD_A)), + arguments(codeUnits().should().haveFullNameMatching(quote(classNameDot) + ".*A"), ALL_CODE_UNIT_DESCRIPTIONS), + arguments(fields().should().haveFullNameMatching(quote(classNameDot) + ".*A"), allFieldsExcept(FIELD_A)), + arguments(codeUnits().should().haveFullNameMatching(quote(classNameDot) + ".*A" + quote("()")), allCodeUnitsExcept(METHOD_A)), + arguments(methods().should().haveFullNameMatching(quote(classNameDot) + ".*A" + quote("()")), allMethodsExcept(METHOD_A)), + arguments(codeUnits().should().haveFullNameMatching(quote(classNameDot) + "..*init.*"), ALL_METHOD_DESCRIPTIONS), + arguments(constructors().should().haveFullNameMatching(quote(classNameDot) + ".*init.*String\\)"), allConstructorsExcept(CONSTRUCTOR_ONE_ARG)), - $(members().should().haveFullNameNotMatching(quote(classNameDot) + ".*A\\(?\\)?"), ImmutableSet.of(FIELD_A, METHOD_A)), - $(codeUnits().should().haveFullNameNotMatching(quote(classNameDot) + ".*A"), emptySet()), - $(fields().should().haveFullNameNotMatching(quote(classNameDot) + ".*A"), ImmutableSet.of(FIELD_A)), - $(codeUnits().should().haveFullNameNotMatching(quote(classNameDot) + ".*A" + quote("()")), ImmutableSet.of(METHOD_A)), - $(methods().should().haveFullNameNotMatching(quote(classNameDot) + ".*A" + quote("()")), ImmutableSet.of(METHOD_A)), - $(codeUnits().should().haveFullNameNotMatching(quote(classNameDot) + ".*init.*"), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(constructors().should().haveFullNameNotMatching(quote(classNameDot) + ".*init.*String\\)"), ImmutableSet.of(CONSTRUCTOR_ONE_ARG)), - - $(members().should().haveNameStartingWith("fi"), ALL_CODE_UNIT_DESCRIPTIONS), - $(fields().should().haveNameStartingWith("m"), ALL_FIELD_DESCRIPTIONS), - $(codeUnits().should().haveNameStartingWith(""), ALL_METHOD_DESCRIPTIONS), - $(methods().should().haveNameEndingWith("dC"), allMethodsExcept(METHOD_C)), - $(constructors().should().haveNameEndingWith(""), ALL_CONSTRUCTOR_DESCRIPTIONS), - $(methods().should().haveNameNotEndingWith("dC"), ImmutableSet.of(METHOD_C)), - $(constructors().should().haveNameNotEndingWith(""), ALL_METHOD_DESCRIPTIONS), + arguments(methods().should().haveNameEndingWith("dC"), allMethodsExcept(METHOD_C)), + arguments(constructors().should().haveNameEndingWith(""), ALL_CONSTRUCTOR_DESCRIPTIONS), + arguments(methods().should().haveNameNotEndingWith("dC"), ImmutableSet.of(METHOD_C)), + arguments(constructors().should().haveNameNotEndingWith(" membersShould.beAnnotatedWith(A.class), @@ -315,20 +315,20 @@ private static List annotatedWithDataPoints( @SuppressWarnings({"unchecked", "rawtypes"}) Function, MembersShouldConjunction> areNotAnnotatedWithA = (Function) makeNotAnnotatedWithMatchingA; return ImmutableList.of( - $(areAnnotatedWithA.apply(members().should()), allMembersExcept( + arguments(areAnnotatedWithA.apply(members().should()), allMembersExcept( FIELD_ANNOTATED_WITH_A, METHOD_ANNOTATED_WITH_A, CONSTRUCTOR_ANNOTATED_WITH_A)), - $(areAnnotatedWithA.apply(fields().should()), allFieldsExcept(FIELD_ANNOTATED_WITH_A)), - $(areAnnotatedWithA.apply(codeUnits().should()), allCodeUnitsExcept( + arguments(areAnnotatedWithA.apply(fields().should()), allFieldsExcept(FIELD_ANNOTATED_WITH_A)), + arguments(areAnnotatedWithA.apply(codeUnits().should()), allCodeUnitsExcept( METHOD_ANNOTATED_WITH_A, CONSTRUCTOR_ANNOTATED_WITH_A)), - $(areAnnotatedWithA.apply(methods().should()), allMethodsExcept(METHOD_ANNOTATED_WITH_A)), - $(areAnnotatedWithA.apply(constructors().should()), allConstructorsExcept(CONSTRUCTOR_ANNOTATED_WITH_A)), - $(areNotAnnotatedWithA.apply(members().should()), + arguments(areAnnotatedWithA.apply(methods().should()), allMethodsExcept(METHOD_ANNOTATED_WITH_A)), + arguments(areAnnotatedWithA.apply(constructors().should()), allConstructorsExcept(CONSTRUCTOR_ANNOTATED_WITH_A)), + arguments(areNotAnnotatedWithA.apply(members().should()), ImmutableSet.of(FIELD_ANNOTATED_WITH_A, METHOD_ANNOTATED_WITH_A, CONSTRUCTOR_ANNOTATED_WITH_A)), - $(areNotAnnotatedWithA.apply(fields().should()), ImmutableSet.of(FIELD_ANNOTATED_WITH_A)), - $(areNotAnnotatedWithA.apply(codeUnits().should()), + arguments(areNotAnnotatedWithA.apply(fields().should()), ImmutableSet.of(FIELD_ANNOTATED_WITH_A)), + arguments(areNotAnnotatedWithA.apply(codeUnits().should()), ImmutableSet.of(METHOD_ANNOTATED_WITH_A, CONSTRUCTOR_ANNOTATED_WITH_A)), - $(areNotAnnotatedWithA.apply(methods().should()), ImmutableSet.of(METHOD_ANNOTATED_WITH_A)), - $(areNotAnnotatedWithA.apply(constructors().should()), ImmutableSet.of(CONSTRUCTOR_ANNOTATED_WITH_A))); + arguments(areNotAnnotatedWithA.apply(methods().should()), ImmutableSet.of(METHOD_ANNOTATED_WITH_A)), + arguments(areNotAnnotatedWithA.apply(constructors().should()), ImmutableSet.of(CONSTRUCTOR_ANNOTATED_WITH_A))); } @ParameterizedTest @@ -367,16 +367,16 @@ private static List declaredInDataPoints( @SuppressWarnings({"unchecked", "rawtypes"}) Function, MembersShouldConjunction> areNotDeclaredInClass = (Function) makeNotDeclaredInClassWithVariousMembers; return ImmutableList.of( - $(areDeclaredInClass.apply(members().should()), ALL_OTHER_MEMBER_DESCRIPTIONS), - $(areDeclaredInClass.apply(fields().should()), ALL_OTHER_FIELD_DESCRIPTIONS), - $(areDeclaredInClass.apply(codeUnits().should()), ALL_OTHER_CODE_UNIT_DESCRIPTIONS), - $(areDeclaredInClass.apply(methods().should()), ALL_OTHER_METHOD_DESCRIPTIONS), - $(areDeclaredInClass.apply(constructors().should()), ALL_OTHER_CONSTRUCTOR_DESCRIPTIONS), - $(areNotDeclaredInClass.apply(members().should()), ALL_MEMBER_DESCRIPTIONS), - $(areNotDeclaredInClass.apply(fields().should()), ALL_FIELD_DESCRIPTIONS), - $(areNotDeclaredInClass.apply(codeUnits().should()), ALL_CODE_UNIT_DESCRIPTIONS), - $(areNotDeclaredInClass.apply(methods().should()), ALL_METHOD_DESCRIPTIONS), - $(areNotDeclaredInClass.apply(constructors().should()), ALL_CONSTRUCTOR_DESCRIPTIONS)); + arguments(areDeclaredInClass.apply(members().should()), ALL_OTHER_MEMBER_DESCRIPTIONS), + arguments(areDeclaredInClass.apply(fields().should()), ALL_OTHER_FIELD_DESCRIPTIONS), + arguments(areDeclaredInClass.apply(codeUnits().should()), ALL_OTHER_CODE_UNIT_DESCRIPTIONS), + arguments(areDeclaredInClass.apply(methods().should()), ALL_OTHER_METHOD_DESCRIPTIONS), + arguments(areDeclaredInClass.apply(constructors().should()), ALL_OTHER_CONSTRUCTOR_DESCRIPTIONS), + arguments(areNotDeclaredInClass.apply(members().should()), ALL_MEMBER_DESCRIPTIONS), + arguments(areNotDeclaredInClass.apply(fields().should()), ALL_FIELD_DESCRIPTIONS), + arguments(areNotDeclaredInClass.apply(codeUnits().should()), ALL_CODE_UNIT_DESCRIPTIONS), + arguments(areNotDeclaredInClass.apply(methods().should()), ALL_METHOD_DESCRIPTIONS), + arguments(areNotDeclaredInClass.apply(constructors().should()), ALL_CONSTRUCTOR_DESCRIPTIONS)); } @ParameterizedTest @@ -391,16 +391,16 @@ void declaration_predicates(MembersShouldConjunction conjunction, Set static Stream haveNameStartingWith_rules() { return Stream.of( - $(members().should().haveNameStartingWith("field"), "field", "violated"), - $(members().should(ArchConditions.haveNameStartingWith("field")), "field", "violated"), - $(fields().should().haveNameStartingWith("field"), "field", "violated"), - $(fields().should(ArchConditions.haveNameStartingWith("field")), "field", "violated"), - $(codeUnits().should().haveNameStartingWith("method"), "method", "violated"), - $(codeUnits().should(ArchConditions.haveNameStartingWith("method")), "method", "violated"), - $(methods().should().haveNameStartingWith("method"), "method", "violated"), - $(methods().should(ArchConditions.haveNameStartingWith("method")), "method", "violated"), - $(constructors().should().haveNameStartingWith("constructor"), "constructor", ""), - $(constructors().should(ArchConditions.haveNameStartingWith("constructor")), "constructor", "") + arguments(members().should().haveNameStartingWith("field"), "field", "violated"), + arguments(members().should(ArchConditions.haveNameStartingWith("field")), "field", "violated"), + arguments(fields().should().haveNameStartingWith("field"), "field", "violated"), + arguments(fields().should(ArchConditions.haveNameStartingWith("field")), "field", "violated"), + arguments(codeUnits().should().haveNameStartingWith("method"), "method", "violated"), + arguments(codeUnits().should(ArchConditions.haveNameStartingWith("method")), "method", "violated"), + arguments(methods().should().haveNameStartingWith("method"), "method", "violated"), + arguments(methods().should(ArchConditions.haveNameStartingWith("method")), "method", "violated"), + arguments(constructors().should().haveNameStartingWith("constructor"), "constructor", ""), + arguments(constructors().should(ArchConditions.haveNameStartingWith("constructor")), "constructor", "") ); } @@ -418,16 +418,16 @@ void haveNameStartingWith(ArchRule rule, String prefix, String violatingMember) static Stream haveNameNotStartingWith_rules() { return Stream.of( - $(members().should().haveNameNotStartingWith("violated"), "violated"), - $(members().should(ArchConditions.haveNameNotStartingWith("violated")), "violated"), - $(fields().should().haveNameNotStartingWith("violated"), "violated"), - $(fields().should(ArchConditions.haveNameNotStartingWith("violated")), "violated"), - $(codeUnits().should().haveNameNotStartingWith("violated"), "violated"), - $(codeUnits().should(ArchConditions.haveNameNotStartingWith("violated")), "violated"), - $(methods().should().haveNameNotStartingWith("violated"), "violated"), - $(methods().should(ArchConditions.haveNameNotStartingWith("violated")), "violated"), - $(constructors().should().haveNameNotStartingWith(""), ""), - $(constructors().should(ArchConditions.haveNameNotStartingWith("")), "") + arguments(members().should().haveNameNotStartingWith("violated"), "violated"), + arguments(members().should(ArchConditions.haveNameNotStartingWith("violated")), "violated"), + arguments(fields().should().haveNameNotStartingWith("violated"), "violated"), + arguments(fields().should(ArchConditions.haveNameNotStartingWith("violated")), "violated"), + arguments(codeUnits().should().haveNameNotStartingWith("violated"), "violated"), + arguments(codeUnits().should(ArchConditions.haveNameNotStartingWith("violated")), "violated"), + arguments(methods().should().haveNameNotStartingWith("violated"), "violated"), + arguments(methods().should(ArchConditions.haveNameNotStartingWith("violated")), "violated"), + arguments(constructors().should().haveNameNotStartingWith(""), ""), + arguments(constructors().should(ArchConditions.haveNameNotStartingWith("")), "") ); } @@ -445,16 +445,16 @@ void haveNameNotStartingWith(ArchRule rule, String prefix) { static Stream haveNameContaining_rules() { return Stream.of( - $(members().should().haveNameContaining("field"), "field", "violated"), - $(members().should(ArchConditions.haveNameContaining("field")), "field", "violated"), - $(fields().should().haveNameContaining("field"), "field", "violated"), - $(fields().should(ArchConditions.haveNameContaining("field")), "field", "violated"), - $(codeUnits().should().haveNameContaining("method"), "method", "violated"), - $(codeUnits().should(ArchConditions.haveNameContaining("method")), "method", "violated"), - $(methods().should().haveNameContaining("method"), "method", "violated"), - $(methods().should(ArchConditions.haveNameContaining("method")), "method", "violated"), - $(constructors().should().haveNameContaining("constructor"), "constructor", ""), - $(constructors().should(ArchConditions.haveNameContaining("constructor")), "constructor", "") + arguments(members().should().haveNameContaining("field"), "field", "violated"), + arguments(members().should(ArchConditions.haveNameContaining("field")), "field", "violated"), + arguments(fields().should().haveNameContaining("field"), "field", "violated"), + arguments(fields().should(ArchConditions.haveNameContaining("field")), "field", "violated"), + arguments(codeUnits().should().haveNameContaining("method"), "method", "violated"), + arguments(codeUnits().should(ArchConditions.haveNameContaining("method")), "method", "violated"), + arguments(methods().should().haveNameContaining("method"), "method", "violated"), + arguments(methods().should(ArchConditions.haveNameContaining("method")), "method", "violated"), + arguments(constructors().should().haveNameContaining("constructor"), "constructor", ""), + arguments(constructors().should(ArchConditions.haveNameContaining("constructor")), "constructor", "") ); } @@ -472,16 +472,16 @@ void haveNameContaining(ArchRule rule, String infix, String violatingMember) { static Stream haveNameNotContaining_rules() { return Stream.of( - $(members().should().haveNameNotContaining("violated"), "violated"), - $(members().should(ArchConditions.haveNameNotContaining("violated")), "violated"), - $(fields().should().haveNameNotContaining("violated"), "violated"), - $(fields().should(ArchConditions.haveNameNotContaining("violated")), "violated"), - $(codeUnits().should().haveNameNotContaining("violated"), "violated"), - $(codeUnits().should(ArchConditions.haveNameNotContaining("violated")), "violated"), - $(methods().should().haveNameNotContaining("violated"), "violated"), - $(methods().should(ArchConditions.haveNameNotContaining("violated")), "violated"), - $(constructors().should().haveNameNotContaining(""), ""), - $(constructors().should(ArchConditions.haveNameNotContaining("")), "") + arguments(members().should().haveNameNotContaining("violated"), "violated"), + arguments(members().should(ArchConditions.haveNameNotContaining("violated")), "violated"), + arguments(fields().should().haveNameNotContaining("violated"), "violated"), + arguments(fields().should(ArchConditions.haveNameNotContaining("violated")), "violated"), + arguments(codeUnits().should().haveNameNotContaining("violated"), "violated"), + arguments(codeUnits().should(ArchConditions.haveNameNotContaining("violated")), "violated"), + arguments(methods().should().haveNameNotContaining("violated"), "violated"), + arguments(methods().should(ArchConditions.haveNameNotContaining("violated")), "violated"), + arguments(constructors().should().haveNameNotContaining(""), ""), + arguments(constructors().should(ArchConditions.haveNameNotContaining("")), "") ); } @@ -499,16 +499,16 @@ void haveNameNotContaining(ArchRule rule, String infix) { static Stream haveNameEndingWith_rules() { return Stream.of( - $(members().should().haveNameEndingWith("field"), "field", "violated"), - $(members().should(ArchConditions.haveNameEndingWith("field")), "field", "violated"), - $(fields().should().haveNameEndingWith("field"), "field", "violated"), - $(fields().should(ArchConditions.haveNameEndingWith("field")), "field", "violated"), - $(codeUnits().should().haveNameEndingWith("method"), "method", "violated"), - $(codeUnits().should(ArchConditions.haveNameEndingWith("method")), "method", "violated"), - $(methods().should().haveNameEndingWith("method"), "method", "violated"), - $(methods().should(ArchConditions.haveNameEndingWith("method")), "method", "violated"), - $(constructors().should().haveNameEndingWith("constructor"), "constructor", ""), - $(constructors().should(ArchConditions.haveNameEndingWith("constructor")), "constructor", "") + arguments(members().should().haveNameEndingWith("field"), "field", "violated"), + arguments(members().should(ArchConditions.haveNameEndingWith("field")), "field", "violated"), + arguments(fields().should().haveNameEndingWith("field"), "field", "violated"), + arguments(fields().should(ArchConditions.haveNameEndingWith("field")), "field", "violated"), + arguments(codeUnits().should().haveNameEndingWith("method"), "method", "violated"), + arguments(codeUnits().should(ArchConditions.haveNameEndingWith("method")), "method", "violated"), + arguments(methods().should().haveNameEndingWith("method"), "method", "violated"), + arguments(methods().should(ArchConditions.haveNameEndingWith("method")), "method", "violated"), + arguments(constructors().should().haveNameEndingWith("constructor"), "constructor", ""), + arguments(constructors().should(ArchConditions.haveNameEndingWith("constructor")), "constructor", "") ); } @@ -526,16 +526,16 @@ void haveNameEndingWith(ArchRule rule, String suffix, String violatingMember) { static Stream haveNameNotEndingWith_rules() { return Stream.of( - $(members().should().haveNameNotEndingWith("violated"), "violated"), - $(members().should(ArchConditions.haveNameNotEndingWith("violated")), "violated"), - $(fields().should().haveNameNotEndingWith("violated"), "violated"), - $(fields().should(ArchConditions.haveNameNotEndingWith("violated")), "violated"), - $(codeUnits().should().haveNameNotEndingWith("violated"), "violated"), - $(codeUnits().should(ArchConditions.haveNameNotEndingWith("violated")), "violated"), - $(methods().should().haveNameNotEndingWith("violated"), "violated"), - $(methods().should(ArchConditions.haveNameNotEndingWith("violated")), "violated"), - $(constructors().should().haveNameNotEndingWith(""), ""), - $(constructors().should(ArchConditions.haveNameNotEndingWith("")), "") + arguments(members().should().haveNameNotEndingWith("violated"), "violated"), + arguments(members().should(ArchConditions.haveNameNotEndingWith("violated")), "violated"), + arguments(fields().should().haveNameNotEndingWith("violated"), "violated"), + arguments(fields().should(ArchConditions.haveNameNotEndingWith("violated")), "violated"), + arguments(codeUnits().should().haveNameNotEndingWith("violated"), "violated"), + arguments(codeUnits().should(ArchConditions.haveNameNotEndingWith("violated")), "violated"), + arguments(methods().should().haveNameNotEndingWith("violated"), "violated"), + arguments(methods().should(ArchConditions.haveNameNotEndingWith("violated")), "violated"), + arguments(constructors().should().haveNameNotEndingWith(""), ""), + arguments(constructors().should(ArchConditions.haveNameNotEndingWith("")), "") ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MethodsShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MethodsShouldTest.java index 01b66d39e7..7302d0e7ef 100644 --- a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MethodsShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/MethodsShouldTest.java @@ -14,19 +14,19 @@ import static com.tngtech.archunit.core.domain.TestUtils.importClasses; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.methods; import static com.tngtech.archunit.lang.syntax.elements.MembersShouldTest.parseMembers; -import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class MethodsShouldTest { static Stream restricted_property_rule_ends() { return Stream.of( - $(methods().should().beFinal(), ImmutableSet.of(METHOD_C, METHOD_D)), - $(methods().should().notBeFinal(), ImmutableSet.of(METHOD_A, METHOD_B)), - $(methods().should().beStatic(), ImmutableSet.of(METHOD_A, METHOD_C)), - $(methods().should().notBeStatic(), ImmutableSet.of(METHOD_B, METHOD_D)), - $(methods().should().notBeFinal().andShould().notBeStatic(), ImmutableSet.of(METHOD_A, METHOD_B, METHOD_D)), - $(methods().should().notBeFinal().orShould().notBeStatic(), ImmutableSet.of(METHOD_B)) + arguments(methods().should().beFinal(), ImmutableSet.of(METHOD_C, METHOD_D)), + arguments(methods().should().notBeFinal(), ImmutableSet.of(METHOD_A, METHOD_B)), + arguments(methods().should().beStatic(), ImmutableSet.of(METHOD_A, METHOD_C)), + arguments(methods().should().notBeStatic(), ImmutableSet.of(METHOD_B, METHOD_D)), + arguments(methods().should().notBeFinal().andShould().notBeStatic(), ImmutableSet.of(METHOD_A, METHOD_B, METHOD_D)), + arguments(methods().should().notBeFinal().orShould().notBeStatic(), ImmutableSet.of(METHOD_B)) ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/library/ProxyRulesTest.java b/archunit/src/test/java/com/tngtech/archunit/library/ProxyRulesTest.java index 1b4c65aa06..e9259d6bac 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/ProxyRulesTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/ProxyRulesTest.java @@ -16,22 +16,22 @@ import static com.tngtech.archunit.library.ProxyRules.no_classes_should_directly_call_other_methods_declared_in_the_same_class_that; import static com.tngtech.archunit.library.ProxyRules.no_classes_should_directly_call_other_methods_declared_in_the_same_class_that_are_annotated_with; import static com.tngtech.archunit.testutil.Assertions.assertThatRule; -import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.regex.Pattern.quote; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class ProxyRulesTest { static Stream call_own_method_with_specific_annotation_rules() { return Stream.of( - $(no_classes_should_directly_call_other_methods_declared_in_the_same_class_that_are_annotated_with(ProxyAnnotation.class), String.format( + arguments(no_classes_should_directly_call_other_methods_declared_in_the_same_class_that_are_annotated_with(ProxyAnnotation.class), String.format( "no classes should directly call other methods declared in the same class that are annotated with @%s, because it bypasses the proxy mechanism", ProxyAnnotation.class.getSimpleName())), - $(noClasses().should(directly_call_other_methods_declared_in_the_same_class_that_are_annotated_with(ProxyAnnotation.class)), String.format( + arguments(noClasses().should(directly_call_other_methods_declared_in_the_same_class_that_are_annotated_with(ProxyAnnotation.class)), String.format( "no classes should directly call other methods declared in the same class that are annotated with @%s", ProxyAnnotation.class.getSimpleName())), - $(no_classes_should_directly_call_other_methods_declared_in_the_same_class_that(have(name("selfProxied"))), + arguments(no_classes_should_directly_call_other_methods_declared_in_the_same_class_that(have(name("selfProxied"))), "no classes should directly call other methods declared in the same class that have name 'selfProxied', because it bypasses the proxy mechanism"), - $(noClasses().should(directly_call_other_methods_declared_in_the_same_class_that(have(name("selfProxied")))), + arguments(noClasses().should(directly_call_other_methods_declared_in_the_same_class_that(have(name("selfProxied")))), "no classes should directly call other methods declared in the same class that have name 'selfProxied'") ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SliceRuleTest.java b/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SliceRuleTest.java index 549fe8f832..3e4d4da9ae 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SliceRuleTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SliceRuleTest.java @@ -36,11 +36,11 @@ import static com.tngtech.archunit.library.dependencies.GivenSlicesTest.TEST_CLASSES_PACKAGE; import static com.tngtech.archunit.library.dependencies.SlicesRuleDefinition.slices; import static com.tngtech.archunit.testutil.Assertions.assertThatDependencies; -import static com.tngtech.archunit.testutil.DataProviders.$; import static java.lang.System.lineSeparator; import static java.util.stream.Collectors.toList; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class SliceRuleTest { @@ -51,7 +51,7 @@ static Stream cycle_limits() { int totalNumberOfCycles = getNumberOfCyclesInCompleteGraph(7); int halfOfTotal = totalNumberOfCycles / 2; return Stream.of( - $(new Runnable() { + arguments(new Runnable() { @Override public void run() { ArchConfiguration.get().setProperty(MAX_NUMBER_OF_CYCLES_TO_DETECT_PROPERTY_NAME, @@ -63,7 +63,7 @@ public String toString() { return "limited number of cycles to half of existing number of cycles should report half the cycles"; } }, halfOfTotal), - $(new Runnable() { + arguments(new Runnable() { @Override public void run() { // keep default @@ -74,7 +74,7 @@ public String toString() { return "if no limit of cycles is configured should report max. 100 cycles"; } }, 100), - $(new Runnable() { + arguments(new Runnable() { @Override public void run() { ArchConfiguration.get().setProperty(MAX_NUMBER_OF_CYCLES_TO_DETECT_PROPERTY_NAME, @@ -86,7 +86,7 @@ public String toString() { return "if the exact amount of existing cycles is configured as limit should report all cycles"; } }, totalNumberOfCycles), - $(new Runnable() { + arguments(new Runnable() { @Override public void run() { ArchConfiguration.get().setProperty(MAX_NUMBER_OF_CYCLES_TO_DETECT_PROPERTY_NAME, diff --git a/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SlicesShouldTest.java b/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SlicesShouldTest.java index f1f733c6a5..1456956dd9 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SlicesShouldTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/dependencies/SlicesShouldTest.java @@ -22,10 +22,10 @@ import static com.tngtech.archunit.base.DescribedPredicate.alwaysTrue; import static com.tngtech.archunit.library.dependencies.GivenSlicesTest.TEST_CLASSES_PACKAGE; import static com.tngtech.archunit.library.dependencies.SlicesRuleDefinition.slices; -import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.regex.Pattern.quote; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.fail; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class SlicesShouldTest { static Stream rules() { @@ -76,9 +76,9 @@ void slice_rules_should_ignore_configured_dependencies(SliceRule rule) { static Stream rules_with_expected_base_description() { return Stream.of( - $(slices().matching("foo.(*)..").should().notDependOnEachOther(), + arguments(slices().matching("foo.(*)..").should().notDependOnEachOther(), "slices matching 'foo.(*)..' should not depend on each other"), - $(slices().matching("foo.(*)..").should().beFreeOfCycles(), + arguments(slices().matching("foo.(*)..").should().beFreeOfCycles(), "slices matching 'foo.(*)..' should be free of cycles")); } diff --git a/archunit/src/test/java/com/tngtech/archunit/library/metrics/LakosMetricsTest.java b/archunit/src/test/java/com/tngtech/archunit/library/metrics/LakosMetricsTest.java index 39fc1d1f0d..9e111cb2f9 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/metrics/LakosMetricsTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/metrics/LakosMetricsTest.java @@ -17,8 +17,8 @@ import static com.tngtech.archunit.library.metrics.TestElement.GET_DEPENDENCIES; import static com.tngtech.archunit.library.metrics.TestMetricsComponentDependencyGraph.fromNode; import static com.tngtech.archunit.library.metrics.TestMetricsComponentDependencyGraph.graph; -import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class LakosMetricsTest { @@ -33,38 +33,38 @@ public void lakos_metrics_of_a_single_component() { static Stream dependency_graphs_with_expected_metrics() { return Stream.of( - $( + arguments( graph(fromNode("A").toNodes("B")), ExpectedMetrics.ccd(3).acd(1.5).racd(0.75).nccd(1) ), // some binary trees that all have NCCD = 1 - $( + arguments( graph(fromNode("A").toNodes("B", "C")), ExpectedMetrics.ccd(5).acd(5 / 3.0).racd(5 / 3.0 / 3.0).nccd(1.0) ), - $( + arguments( graph(fromNode("A").toNodes("B", "C") .fromNode("B").toNodes("D")), ExpectedMetrics.ccd(8).acd(8 / 4.0).racd(8 / 4.0 / 4.0).nccd(1.0) ), - $( + arguments( graph(fromNode("A").toNodes("B", "C") .fromNode("B").toNodes("D", "E")), ExpectedMetrics.ccd(11).acd(11 / 5.0).racd(11 / 5.0 / 5.0).nccd(1.0) ), - $( + arguments( graph(fromNode("A").toNodes("B", "C") .fromNode("B").toNodes("D", "E") .fromNode("C").toNodes("F")), ExpectedMetrics.ccd(14).acd(14 / 6.0).racd(14 / 6.0 / 6.0).nccd(1.0) ), - $( + arguments( graph(fromNode("A").toNodes("B", "C") .fromNode("B").toNodes("D", "E") .fromNode("C").toNodes("F", "G")), ExpectedMetrics.ccd(17).acd(17 / 7.0).racd(17 / 7.0 / 7.0).nccd(1.0) ), - $( + arguments( graph(fromNode("1").toNodes("21", "22") .fromNode("21").toNodes("311", "312") .fromNode("311").toNodes("4111", "4112") @@ -75,12 +75,12 @@ static Stream dependency_graphs_with_expected_metrics() { ExpectedMetrics.ccd(49).acd(49 / 15.0).racd(49 / 15.0 / 15.0).nccd(1.0) ), // some linear graphs - $( + arguments( graph(fromNode("A").toNodes("B") .fromNode("B").toNodes("C")), ExpectedMetrics.ccd(6).acd(2).racd(2 / 3.0).nccd(6 / 5.0) ), - $( + arguments( graph(fromNode("A").toNodes("B") .fromNode("B").toNodes("C") .fromNode("C").toNodes("D") @@ -89,7 +89,7 @@ static Stream dependency_graphs_with_expected_metrics() { ExpectedMetrics.ccd(21).acd(21 / 6.0).racd(21 / 6.0 / 6.0).nccd(21 / 14.0) ), // some cyclic graphs - $( + arguments( graph(fromNode("A").toNodes("B", "Z") .fromNode("B").toNodes("C") .fromNode("C").toNodes("D") @@ -98,7 +98,7 @@ static Stream dependency_graphs_with_expected_metrics() { .fromNode("W").toNodes("Z")), ExpectedMetrics.ccd(19).acd(19 / 6.0).racd(19 / 6.0 / 6.0).nccd(19 / 14.0) ), - $( + arguments( graph(fromNode("A").toNodes("B") .fromNode("B").toNodes("C") .fromNode("C").toNodes("D") @@ -107,7 +107,7 @@ static Stream dependency_graphs_with_expected_metrics() { .fromNode("F").toNodes("A")), ExpectedMetrics.ccd(36).acd(36 / 6.0).racd(36 / 6.0 / 6.0).nccd(36 / 14.0) ), - $( + arguments( graph(fromNode("A").toNodes("B", "D") .fromNode("B").toNodes("C") .fromNode("C").toNodes("A") @@ -116,7 +116,7 @@ static Stream dependency_graphs_with_expected_metrics() { .fromNode("F").toNodes("D")), ExpectedMetrics.ccd(27).acd(27 / 6.0).racd(27 / 6.0 / 6.0).nccd(27 / 14.0) ), - $( + arguments( graph(fromNode("A").toNodes("B", "D") .fromNode("B").toNodes("C") .fromNode("C").toNodes("A") diff --git a/archunit/src/test/java/com/tngtech/archunit/library/modules/ArchModuleTest.java b/archunit/src/test/java/com/tngtech/archunit/library/modules/ArchModuleTest.java index 5a2af6660c..e405b944cd 100644 --- a/archunit/src/test/java/com/tngtech/archunit/library/modules/ArchModuleTest.java +++ b/archunit/src/test/java/com/tngtech/archunit/library/modules/ArchModuleTest.java @@ -7,9 +7,9 @@ import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; -import static com.tngtech.archunit.testutil.DataProviders.$; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.params.provider.Arguments.arguments; public class ArchModuleTest { @@ -37,8 +37,8 @@ public void identifier_parts() { static Stream illegal_indices() { return Stream.of( - $(ArchModule.Identifier.from("one"), 0), - $(ArchModule.Identifier.from("one"), 2) + arguments(ArchModule.Identifier.from("one"), 0), + arguments(ArchModule.Identifier.from("one"), 2) ); } diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/DataProviders.java b/archunit/src/test/java/com/tngtech/archunit/testutil/DataProviders.java deleted file mode 100644 index 87d508cfba..0000000000 --- a/archunit/src/test/java/com/tngtech/archunit/testutil/DataProviders.java +++ /dev/null @@ -1,9 +0,0 @@ -package com.tngtech.archunit.testutil; - -import org.junit.jupiter.params.provider.Arguments; - -public class DataProviders { - public static Arguments $(Object... arguments) { - return Arguments.of(arguments); - } -} diff --git a/archunit/src/test/java/com/tngtech/archunit/testutil/syntax/RandomSyntaxTestBase.java b/archunit/src/test/java/com/tngtech/archunit/testutil/syntax/RandomSyntaxTestBase.java index 3e71113c55..83161c2471 100644 --- a/archunit/src/test/java/com/tngtech/archunit/testutil/syntax/RandomSyntaxTestBase.java +++ b/archunit/src/test/java/com/tngtech/archunit/testutil/syntax/RandomSyntaxTestBase.java @@ -34,7 +34,6 @@ import static com.tngtech.archunit.core.domain.Formatters.ensureSimpleName; import static com.tngtech.archunit.core.domain.JavaConstructor.CONSTRUCTOR_NAME; import static com.tngtech.archunit.core.domain.TestUtils.importClassesWithContext; -import static com.tngtech.archunit.testutil.DataProviders.$; import static java.util.Arrays.asList; import static java.util.Arrays.stream; import static java.util.Collections.emptyList; @@ -42,6 +41,7 @@ import static java.util.stream.Collectors.toList; import static java.util.stream.Collectors.toSet; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; public abstract class RandomSyntaxTestBase { private static final Logger LOG = LoggerFactory.getLogger(RandomSyntaxTestBase.class); @@ -74,7 +74,7 @@ protected static Stream createRandomRules(RandomRulesBlueprint bluepr blueprint.parameterProviders, ExpectedDescription.from(blueprint.seed, blueprint.descriptionReplacements)) ) - .map(spec -> $(spec.getActualArchRule(), spec.getExpectedDescription())); + .map(spec -> arguments(spec.getActualArchRule(), spec.getExpectedDescription())); } @ParameterizedTest