Add array support to collection conditions

docs/utilities.adoc

@@ -71,7 +71,7 @@ include::{sourcedir}/utilities/CollectionConditions.groovy[tag=strict-matcher]
 include::{sourcedir}/utilities/CollectionConditions.groovy[tag=strict-matcher-result]
 ----
 
-NOTE: Both operands must be `Iterable` for this to work.
+NOTE: Both operands must either be `Iterable` or an array for this to work.
 Otherwise, it will be treated like the standard groovy https://groovy-lang.org/operators.html#_find_operator[find operator] or https://groovy-lang.org/operators.html#_match_operator[match operators].
 
 [[file-stystem-fixture]]

spock-core/src/main/java/org/spockframework/runtime/SpockRuntime.java

@@ -17,6 +17,7 @@
 package org.spockframework.runtime;
 
 import static java.util.stream.Collectors.toList;
+import static org.spockframework.util.ReflectionUtil.isArray;
 
 import org.spockframework.runtime.model.*;
 import org.spockframework.util.*;
@@ -241,7 +242,8 @@ void verify(ErrorCollector errorCollector, @Nullable List<Object> values, @Nulla
       int idxActual = values.indexOf(left);
       int idxExpected = values.indexOf(right);
 
-      if (left instanceof Iterable && right instanceof Iterable) {
+
+      if (isIterableOrArray(left) && isIterableOrArray(right)) {
         if (SpockRuntime.MATCH_COLLECTIONS_AS_SET.equals(method)) {
           Set<?> actual = GroovyRuntimeUtil.coerce(left, LinkedHashSet.class);
           Set<?> expected = GroovyRuntimeUtil.coerce(right, LinkedHashSet.class);
@@ -253,11 +255,13 @@ void verify(ErrorCollector errorCollector, @Nullable List<Object> values, @Nulla
           values.set(idxExpected, expected);
 
         } else {
-          Matcher<?> matcher = StreamSupport.stream(((Iterable<?>)right).spliterator(), false)
+          Object localLeft = convertArrayToCollectionIfNecessary(left);
+          Object localRight = convertArrayToCollectionIfNecessary(right);
+          Matcher<?> matcher = StreamSupport.stream(((Iterable<?>)localRight).spliterator(), false)
             .map(CoreMatchers::equalTo)
             .collect(Collectors.collectingAndThen(toList(), IsIterableContainingInAnyOrder::containsInAnyOrder));
 
-          if (HamcrestFacade.matches(matcher, left)) {
+          if (HamcrestFacade.matches(matcher, localLeft)) {
             return;
           }
           description = HamcrestFacade.getFailureDescription(matcher, left, message);
@@ -303,4 +307,14 @@ static CollectionCondition parse(Object target, String method, Object[] args, bo
       return null;
     }
   }
+  private static boolean isIterableOrArray(Object o) {
+    return o instanceof Iterable || isArray(o);
+  }
+
+  private static Object convertArrayToCollectionIfNecessary(Object o) {
+    if (isArray(o)) {
+      return  GroovyRuntimeUtil.coerce(o, List.class);
+    }
+    return o;
+  }
 }

spock-core/src/main/java/org/spockframework/util/ReflectionUtil.java

@@ -71,6 +71,9 @@ public static boolean isAnnotationPresent(AnnotatedElement element, String class
 
     return false;
   }
+  public static boolean isArray(Object obj) {
+    return (obj != null && obj.getClass().isArray());
+  }
 
   public static boolean isAnnotationPresentRecursive(Class<?> cls, Class<? extends Annotation> annotationClass) {
     return cls.isAnnotationPresent(annotationClass) ||

spock-specs/src/test/groovy/org/spockframework/smoke/condition/ConditionEvaluation.groovy

@@ -359,6 +359,38 @@ class ConditionEvaluation extends EmbeddedSpecification {
 
   }
 
+  def "collection conditions work with various types"() {
+    when:
+    runner.runFeatureBody("""
+        given:
+        def a = [1,1,2,2,3,3] as ${aType}
+        def b = [1,2,3] as ${bType}
+        expect:
+        a =~ b
+        """)
+    then:
+    noExceptionThrown()
+
+    where:
+    [aType, bType] << ['int[]', 'Integer[]', 'List', 'Set', 'Queue', 'Deque'].with { [it, it] }.combinations()
+  }
+
+  def "strict collection conditions work with various types"() {
+    when:
+    runner.runFeatureBody("""
+        given:
+        def a = [1,1,2,2,3,3] as ${aType}
+        def b = [1,2,3,3,2,1] as ${bType}
+        expect:
+        a ==~ b
+        """)
+    then:
+    noExceptionThrown()
+
+    where:
+    [aType, bType] << ['int[]', 'Integer[]', 'List', 'Queue', 'Deque'].with { [it, it] }.combinations()
+  }
+
   /*
   def "MapEntryExpression"() {
       // tested as part of testMapExpression