add anyParameterThat and allParameters predicates (#1498)

In another project I'm writing rules about method parameter annotations,
and it seems like support for that in the DSL would make sense.

This change is the first step towards that,
it extracts a HasParameters interface from JavaCodeUnit
and provides DescribedPredicates for
- checking that any parameter matches
- checking that all parameters match

Author: hankem

archunit/src/main/java/com/tngtech/archunit/core/domain/JavaCodeUnit.java

@@ -131,7 +131,7 @@ public List<JavaType> getParameterTypes() {
     }
 
     /**
-     * @return the {@link JavaParameter parameters} of this {@link JavaCodeUnit}. On the contrary to the Reflection API this will only contain
+     * @return the {@link JavaParameter parameters} of this {@link JavaCodeUnit}. In contrast to the Reflection API this will only contain
      *         the parameters from the signature and not synthetic parameters, if the signature is generic. In these cases
      *         {@link #getParameters()}{@code .size()} will always be equal to {@link #getParameterTypes()}{@code .size()},
      *         but not necessarily to {@link #getRawParameterTypes()}{@code .size()} in case the compiler adds synthetic parameters.<br>
@@ -411,6 +411,26 @@ public boolean test(JavaCodeUnit input) {
                 }
             };
         }
+
+        /**
+         * @param predicate A {@link DescribedPredicate} for the {@link JavaParameter}s of the {@link JavaCodeUnit}
+         * @return A {@link DescribedPredicate predicate} for a {@link JavaCodeUnit} that returns {@code true}
+         *         if and only if at least one {@link JavaParameter} of the {@link JavaCodeUnit} matches the given predicate.
+         */
+        @PublicAPI(usage = ACCESS)
+        public static DescribedPredicate<JavaCodeUnit> anyParameterThat(DescribedPredicate<? super JavaParameter> predicate) {
+            return DescribedPredicate.anyElementThat(predicate).onResultOf(JavaCodeUnit::getParameters).as("any parameter that %s", predicate.getDescription());
+        }
+
+        /**
+         * @param predicate A {@link DescribedPredicate} for the {@link JavaParameter}s of the {@link JavaCodeUnit}
+         * @return A {@link DescribedPredicate predicate} for a {@link JavaCodeUnit} that returns {@code true}
+         *         if and only if all {@link JavaParameter}s of the {@link JavaCodeUnit} match the given predicate.
+         */
+        @PublicAPI(usage = ACCESS)
+        public static DescribedPredicate<JavaCodeUnit> allParameters(DescribedPredicate<? super JavaParameter> predicate) {
+            return DescribedPredicate.<JavaParameter>allElements(predicate).onResultOf(JavaCodeUnit::getParameters).as("all parameters %s", predicate.getDescription());
+        }
     }
 
     /**

archunit/src/test/java/com/tngtech/archunit/core/domain/JavaCodeUnitTest.java

@@ -8,6 +8,7 @@
 import java.util.Set;
 
 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;
@@ -18,9 +19,13 @@
 import static com.google.common.collect.Lists.newArrayList;
 import static com.google.common.collect.Sets.union;
 import static com.tngtech.archunit.core.domain.JavaClass.Predicates.equivalentTo;
+import static com.tngtech.archunit.core.domain.JavaCodeUnit.Predicates.allParameters;
+import static com.tngtech.archunit.core.domain.JavaCodeUnit.Predicates.anyParameterThat;
 import static com.tngtech.archunit.core.domain.JavaParameter.startWithLowercase;
 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.lang.conditions.ArchPredicates.are;
+import static com.tngtech.archunit.lang.conditions.ArchPredicates.is;
 import static com.tngtech.archunit.testutil.Assertions.assertThat;
 import static com.tngtech.archunit.testutil.Assertions.assertThatAnnotation;
 import static com.tngtech.archunit.testutil.Assertions.assertThatTypes;
@@ -326,6 +331,32 @@ void method(@SomeParameterAnnotation("test") String param) {
         assertThat(parameter.tryGetAnnotationOfType(Deprecated.class.getName())).isEmpty();
     }
 
+    @Test
+    public void predicate_on_any_parameter() {
+        JavaClass someClass = importClassWithContext(SomeClass.class);
+        DescribedPredicate<JavaParameter> stringTyped = equivalentTo(String.class).onResultOf(JavaParameter::getRawType);
+
+        DescribedPredicate<JavaCodeUnit> predicate = anyParameterThat(is(stringTyped));
+
+        assertThat(predicate).hasDescription("any parameter that is equivalent to java.lang.String")
+                .accepts(someClass.getMethod("method", String.class, String.class))
+                .accepts(someClass.getMethod("method", String.class, Integer.class))
+                .rejects(someClass.getMethod("method", Integer.class, Integer.class));
+    }
+
+    @Test
+    public void predicate_on_all_parameters() {
+        JavaClass someClass = importClassWithContext(SomeClass.class);
+        DescribedPredicate<JavaParameter> stringTyped = equivalentTo(String.class).onResultOf(JavaParameter::getRawType);
+
+        DescribedPredicate<JavaCodeUnit> predicate = allParameters(are(stringTyped));
+
+        assertThat(predicate).hasDescription("all parameters are equivalent to java.lang.String")
+                .accepts(someClass.getMethod("method", String.class, String.class))
+                .rejects(someClass.getMethod("method", String.class, Integer.class))
+                .rejects(someClass.getMethod("method", Integer.class, Integer.class));
+    }
+
     @SuppressWarnings("unused")
     private static class ClassWithVariousCodeUnitParameters {
         ClassWithVariousCodeUnitParameters(Object simple, String noParameterizedTypes) {
@@ -379,6 +410,18 @@ enum NonTrivialEnum {
         }
     }
 
+    @SuppressWarnings("unused")
+    private static class SomeClass {
+        void method(Integer a, Integer b) {
+        }
+
+        void method(String l, String r) {
+        }
+
+        void method(String s, Integer i) {
+        }
+    }
+
     @interface SomeMetaAnnotation {
     }