HasItemInArray implemented with Collection matcher

sf105 · sf105 · commit 541886227607 · 2016-04-06T15:27:49.000+02:00
diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/ArrayMatching.java b/hamcrest-library/src/main/java/org/hamcrest/collection/ArrayMatching.java
@@ -28,7 +28,7 @@ public class ArrayMatching {
    *     the matcher to apply to elements in examined arrays
    */
   public static <T> Matcher<T[]> hasItemInArray(Matcher<? super T> elementMatcher) {
-      return new IsArrayContaining<>(elementMatcher);
+      return new HasItemInArray<>(elementMatcher);
   }
 
   /**
@@ -164,7 +164,6 @@ public static <E> Matcher<E[]> arrayContaining(List<Matcher<? super E>> itemMatc
       return new ArrayAsIterableMatcher<>(new IsIterableContainingInOrder<>(itemMatchers), itemMatchers, "");
   }
 
-
   private static <E> List<Matcher<? super E>> asEqualMatchers(E[] items) {
     final List<Matcher<? super E>> matchers = new ArrayList<>();
     for (E item : items) {
diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/HasItemInArray.java b/hamcrest-library/src/main/java/org/hamcrest/collection/HasItemInArray.java
@@ -0,0 +1,40 @@
+package org.hamcrest.collection;
+
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeDiagnosingMatcher;
+import org.hamcrest.TypeSafeMatcher;
+import org.hamcrest.core.IsCollectionContaining;
+
+import static java.util.Arrays.asList;
+
+/**
+ * Matches if an array contains an item satisfying a nested matcher.
+ */
+public class HasItemInArray<T> extends TypeSafeMatcher<T[]> {
+    private final Matcher<? super T> elementMatcher;
+    private final TypeSafeDiagnosingMatcher<Iterable<? super T>> collectionMatcher;
+
+    public HasItemInArray(Matcher<? super T> elementMatcher) {
+        this.elementMatcher = elementMatcher;
+        this.collectionMatcher = new IsCollectionContaining<>(elementMatcher);
+    }
+
+    @Override
+    public boolean matchesSafely(T[] actual) {
+        return collectionMatcher.matches(asList(actual));
+    }
+    
+    @Override
+    public void describeMismatchSafely(T[] actual, Description mismatchDescription) {
+        collectionMatcher.describeMismatch(asList(actual), mismatchDescription);
+    }
+
+    @Override
+    public void describeTo(Description description) {
+        description
+            .appendText("an array containing ")
+            .appendDescriptionOf(elementMatcher);
+    }
+
+}
diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayContaining.java b/hamcrest-library/src/main/java/org/hamcrest/collection/IsArrayContaining.java
diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/HasItemInArrayTest.java b/hamcrest-library/src/test/java/org/hamcrest/collection/HasItemInArrayTest.java
@@ -3,34 +3,38 @@
 import org.hamcrest.AbstractMatcherTest;
 import org.hamcrest.Matcher;
 
+import static org.hamcrest.Matchers.lessThan;
 import static org.hamcrest.collection.ArrayMatching.hasItemInArray;
 
-public class IsArrayContainingTest extends AbstractMatcherTest {
+public class HasItemInArrayTest extends AbstractMatcherTest {
 
     @Override
     protected Matcher<?> createMatcher() {
-        return ArrayMatching.hasItemInArray("irrelevant");
+        return hasItemInArray("irrelevant");
     }
 
     public void testMatchesAnArrayThatContainsAnElementMatchingTheGivenMatcher() {
         assertMatches("should matches array that contains 'a'",
-                ArrayMatching.hasItemInArray("a"), new String[]{"a", "b", "c"});
+                hasItemInArray("a"), new String[]{"a", "b", "c"});
     }
 
     public void testDoesNotMatchAnArrayThatDoesntContainAnElementMatchingTheGivenMatcher() {
         assertDoesNotMatch("should not matches array that doesn't contain 'a'",
-                ArrayMatching.hasItemInArray("a"), new String[]{"b", "c"});
+                hasItemInArray("a"), new String[]{"b", "c"});
         assertDoesNotMatch("should not matches empty array",
-                ArrayMatching.hasItemInArray("a"), new String[0]);
+                hasItemInArray("a"), new String[0]);
+        assertMismatchDescription(
+              "mismatches were: [<3> was greater than <2>, <4> was greater than <2>, <5> was greater than <2>]",
+              hasItemInArray(lessThan(2)), new Integer[] {3, 4, 5});
     }
 
     public void testDoesNotMatchNull() {
         assertDoesNotMatch("should not matches null",
-                ArrayMatching.hasItemInArray("a"), null);
+                hasItemInArray("a"), null);
     }
 
     public void testHasAReadableDescription() {
-        assertDescription("an array containing \"a\"", ArrayMatching.hasItemInArray("a"));
+        assertDescription("an array containing a value less than <2>", hasItemInArray(lessThan(2)));
     }
 
     // Remaining code no longer compiles, thanks to generics. I think that's a good thing, but

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public class ArrayMatching {`
`28`	`28`	`* the matcher to apply to elements in examined arrays`
`29`	`29`	`*/`
`30`	`30`	`public static <T> Matcher<T[]> hasItemInArray(Matcher<? super T> elementMatcher) {`
`31`		`- return new IsArrayContaining<>(elementMatcher);`
	`31`	`+ return new HasItemInArray<>(elementMatcher);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`/**`
`@@ -164,7 +164,6 @@ public static <E> Matcher<E[]> arrayContaining(List<Matcher<? super E>> itemMatc`
`164`	`164`	`return new ArrayAsIterableMatcher<>(new IsIterableContainingInOrder<>(itemMatchers), itemMatchers, "");`
`165`	`165`	`}`
`166`	`166`
`167`		`-`
`168`	`167`	`private static <E> List<Matcher<? super E>> asEqualMatchers(E[] items) {`
`169`	`168`	`final List<Matcher<? super E>> matchers = new ArrayList<>();`
`170`	`169`	`for (E item : items) {`