renamed ArrayMatcher to ArrayAsIterableMatcher

sf105 · sf105 · commit f4bec1ee28f2 · 2016-04-06T15:17:38.000+02:00
diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/ArrayAsIterableMatcher.java b/hamcrest-library/src/main/java/org/hamcrest/collection/ArrayAsIterableMatcher.java
@@ -12,12 +12,12 @@
 /**
  * @author Steve Freeman 2016 http://www.hamcrest.com
  */
-public class ArrayMatcher<E> extends TypeSafeMatcher<E[]> {
+public class ArrayAsIterableMatcher<E> extends TypeSafeMatcher<E[]> {
   protected final TypeSafeDiagnosingMatcher<Iterable<? extends E>> iterableMatcher;
   private final String message;
   protected final Collection<Matcher<? super E>> matchers;
 
-  public ArrayMatcher(
+  public ArrayAsIterableMatcher(
         TypeSafeDiagnosingMatcher<Iterable<? extends E>> iterableMatcher,
         Collection<Matcher<? super E>> matchers,
         String message)
diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/ArrayMatching.java b/hamcrest-library/src/main/java/org/hamcrest/collection/ArrayMatching.java
@@ -91,7 +91,7 @@ public static <E> Matcher<E[]> arrayContainingInAnyOrder(Matcher<? super E>... i
    *     a list of matchers, each of which must be satisfied by an item provided by an examined array
    */
   public static <E> Matcher<E[]> arrayContainingInAnyOrder(Collection<Matcher<? super E>> itemMatchers) {
-    return new ArrayMatcher<>(new IsIterableContainingInAnyOrder<>(itemMatchers), itemMatchers, "in any order");
+    return new ArrayAsIterableMatcher<>(new IsIterableContainingInAnyOrder<>(itemMatchers), itemMatchers, "in any order");
   }
 
   /**
@@ -161,7 +161,7 @@ public static <E> Matcher<E[]> arrayContaining(Matcher<? super E>... itemMatcher
    *     a list of matchers, each of which must be satisfied by the corresponding item in an examined array
    */
   public static <E> Matcher<E[]> arrayContaining(List<Matcher<? super E>> itemMatchers) {
-      return new  ArrayMatcher<>(new IsIterableContainingInOrder<>(itemMatchers), itemMatchers, "");
+      return new ArrayAsIterableMatcher<>(new IsIterableContainingInOrder<>(itemMatchers), itemMatchers, "");
   }
 
 
diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayContainingInOrderTest.java b/hamcrest-library/src/test/java/org/hamcrest/collection/IsArrayContainingInOrderTest.java
@@ -3,34 +3,35 @@
 import org.hamcrest.AbstractMatcherTest;
 import org.hamcrest.Matcher;
 
+import static org.hamcrest.collection.ArrayMatching.arrayContaining;
 import static org.hamcrest.core.IsEqual.equalTo;
 
 public class IsArrayContainingInOrderTest extends AbstractMatcherTest {
 
     @SuppressWarnings("unchecked")
     @Override
     protected Matcher<?> createMatcher() {
-        return ArrayMatching.arrayContaining(equalTo(1), equalTo(2));
+        return arrayContaining(equalTo(1), equalTo(2));
     }
 
     @SuppressWarnings("unchecked")
     public void testHasAReadableDescription() {
-        assertDescription("[<1>, <2>]", ArrayMatching.arrayContaining(equalTo(1), equalTo(2)));
+        assertDescription("[<1>, <2>]", arrayContaining(equalTo(1), equalTo(2)));
     }
     
     public void testMatchesItemsInOrder() {
-      assertMatches("in order", ArrayMatching.arrayContaining(1, 2, 3), new Integer[] {1, 2, 3});
-      assertMatches("single", ArrayMatching.arrayContaining(1), new Integer[] {1});
+      assertMatches("in order", arrayContaining(1, 2, 3), new Integer[] {1, 2, 3});
+      assertMatches("single", arrayContaining(1), new Integer[] {1});
     }
 
     @SuppressWarnings("unchecked")
     public void testAppliesMatchersInOrder() {
-      assertMatches("in order", ArrayMatching.arrayContaining(equalTo(1), equalTo(2), equalTo(3)), new Integer[] {1, 2, 3});
-      assertMatches("single", ArrayMatching.arrayContaining(equalTo(1)), new Integer[] {1});
+      assertMatches("in order", arrayContaining(equalTo(1), equalTo(2), equalTo(3)), new Integer[] {1, 2, 3});
+      assertMatches("single", arrayContaining(equalTo(1)), new Integer[] {1});
     }
     
     public void testMismatchesItemsInOrder() {
-      Matcher<Integer[]> matcher = ArrayMatching.arrayContaining(1, 2, 3);
+      Matcher<Integer[]> matcher = arrayContaining(1, 2, 3);
       assertMismatchDescription("was null", matcher, null);
       assertMismatchDescription("no item was <1>", matcher, new Integer[] {});
       assertMismatchDescription("no item was <2>", matcher, new Integer[] {1});
@@ -39,6 +40,6 @@ public void testMismatchesItemsInOrder() {
     }
 
     public void testCanHandleNullValuesInAnArray() {
-      assertMatches("with nulls", ArrayMatching.arrayContaining(null, null), new Object[]{null, null});
+      assertMatches("with nulls", arrayContaining(null, null), new Object[]{null, null});
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ public static <E> Matcher<E[]> arrayContainingInAnyOrder(Matcher<? super E>... i`
`91`	`91`	`* a list of matchers, each of which must be satisfied by an item provided by an examined array`
`92`	`92`	`*/`
`93`	`93`	`public static <E> Matcher<E[]> arrayContainingInAnyOrder(Collection<Matcher<? super E>> itemMatchers) {`
`94`		`- return new ArrayMatcher<>(new IsIterableContainingInAnyOrder<>(itemMatchers), itemMatchers, "in any order");`
	`94`	`+ return new ArrayAsIterableMatcher<>(new IsIterableContainingInAnyOrder<>(itemMatchers), itemMatchers, "in any order");`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`/**`
`@@ -161,7 +161,7 @@ public static <E> Matcher<E[]> arrayContaining(Matcher<? super E>... itemMatcher`
`161`	`161`	`* a list of matchers, each of which must be satisfied by the corresponding item in an examined array`
`162`	`162`	`*/`
`163`	`163`	`public static <E> Matcher<E[]> arrayContaining(List<Matcher<? super E>> itemMatchers) {`
`164`		`- return new ArrayMatcher<>(new IsIterableContainingInOrder<>(itemMatchers), itemMatchers, "");`
	`164`	`+ return new ArrayAsIterableMatcher<>(new IsIterableContainingInOrder<>(itemMatchers), itemMatchers, "");`
`165`	`165`	`}`
`166`	`166`
`167`	`167`