Factory methods. Oops. Should have been MatchIterables.

sf105 · sf105 · commit d4e6adfecd61 · 2014-12-26T13:59:00.000+01:00
diff --git a/hamcrest-library/src/main/java/org/hamcrest/Matchers.java b/hamcrest-library/src/main/java/org/hamcrest/Matchers.java
@@ -541,7 +541,7 @@ public static <E> org.hamcrest.Matcher<E[]> arrayContaining(E... items) {
      * @param itemMatchers the matchers that must be satisfied by the items in the examined array
      */
     @SafeVarargs
-    public static <E> org.hamcrest.Matcher<E[]> arrayContaining(org.hamcrest.Matcher<? super E>... itemMatchers) {
+    public static <E> org.hamcrest.Matcher<E[]> arrayContaining(Matcher<? super E>... itemMatchers) {
         return MatchArrays.arrayContaining(itemMatchers);
     }
 
@@ -554,7 +554,7 @@ public static <E> org.hamcrest.Matcher<E[]> arrayContaining(org.hamcrest.Matcher
      *
      * @param itemMatchers a list of matchers, each of which must be satisfied by the corresponding item in an examined array
      */
-    public static <E> org.hamcrest.Matcher<E[]> arrayContaining(java.util.List<org.hamcrest.Matcher<? super E>> itemMatchers) {
+    public static <E> org.hamcrest.Matcher<E[]> arrayContaining(java.util.List<Matcher<? super E>> itemMatchers) {
         return MatchArrays.arrayContaining(itemMatchers);
     }
 
@@ -578,7 +578,7 @@ public static <E> org.hamcrest.Matcher<E[]> arrayContaining(java.util.List<org.h
      * @param itemMatchers a list of matchers, each of which must be satisfied by an entry in an examined array
      */
     @SafeVarargs
-    public static <E> org.hamcrest.Matcher<E[]> arrayContainingInAnyOrder(org.hamcrest.Matcher<? super E>... itemMatchers) {
+    public static <E> org.hamcrest.Matcher<E[]> arrayContainingInAnyOrder(Matcher<? super E>... itemMatchers) {
         return MatchArrays.arrayContainingInAnyOrder(itemMatchers);
     }
 
@@ -601,7 +601,7 @@ public static <E> org.hamcrest.Matcher<E[]> arrayContainingInAnyOrder(org.hamcre
      *
      * @param itemMatchers a list of matchers, each of which must be satisfied by an item provided by an examined array
      */
-    public static <E> org.hamcrest.Matcher<E[]> arrayContainingInAnyOrder(java.util.Collection<org.hamcrest.Matcher<? super E>> itemMatchers) {
+    public static <E> org.hamcrest.Matcher<E[]> arrayContainingInAnyOrder(java.util.Collection<Matcher<? super E>> itemMatchers) {
         return MatchArrays.arrayContainingInAnyOrder(itemMatchers);
     }
 
@@ -773,7 +773,7 @@ public static <E> org.hamcrest.Matcher<java.lang.Iterable<E>> emptyIterableOf(ja
      */
     @SafeVarargs
     public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains(E... items) {
-        return MatchCollections.contains(items);
+        return MatchIterables.contains(items);
     }
 
     /**
@@ -786,8 +786,8 @@ public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains
      * @param itemMatcher the matcher that must be satisfied by the single item provided by an
      *                    examined {@link Iterable}
      */
-    public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains(org.hamcrest.Matcher<? super E> itemMatcher) {
-        return MatchCollections.contains(itemMatcher);
+    public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E> itemMatcher) {
+        return MatchIterables.contains(itemMatcher);
     }
 
     /**
@@ -801,8 +801,8 @@ public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains
      * @param itemMatchers the matchers that must be satisfied by the items provided by an examined {@link Iterable}
      */
     @SafeVarargs
-    public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains(org.hamcrest.Matcher<? super E>... itemMatchers) {
-        return MatchCollections.contains(itemMatchers);
+    public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E>... itemMatchers) {
+        return MatchIterables.contains(itemMatchers);
     }
 
     /**
@@ -816,8 +816,8 @@ public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains
      * @param itemMatchers a list of matchers, each of which must be satisfied by the corresponding item provided by
      *                     an examined {@link Iterable}
      */
-    public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains(java.util.List<org.hamcrest.Matcher<? super E>> itemMatchers) {
-        return MatchCollections.contains(itemMatchers);
+    public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains(java.util.List<Matcher<? super E>> itemMatchers) {
+        return MatchIterables.contains(itemMatchers);
     }
 
     /**
@@ -913,7 +913,7 @@ public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains
      * @param itemMatchers the matchers that must be satisfied by the items provided by an examined {@link Iterable} in the same relative order
      */
     @SafeVarargs
-    public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(org.hamcrest.Matcher<? super E>... itemMatchers) {
+    public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(Matcher<? super E>... itemMatchers) {
         return org.hamcrest.collection.IsIterableContainingInRelativeOrder.containsInRelativeOrder(itemMatchers);
     }
 
@@ -927,7 +927,7 @@ public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains
      * @param itemMatchers a list of matchers, each of which must be satisfied by the items provided by
      *                     an examined {@link Iterable} in the same relative order
      */
-    public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(java.util.List<org.hamcrest.Matcher<? super E>> itemMatchers) {
+    public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(java.util.List<Matcher<? super E>> itemMatchers) {
         return org.hamcrest.collection.IsIterableContainingInRelativeOrder.containsInRelativeOrder(itemMatchers);
     }
 
diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java b/hamcrest-library/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java
@@ -3,13 +3,12 @@
 import org.hamcrest.Description;
 import org.hamcrest.Matcher;
 import org.hamcrest.TypeSafeDiagnosingMatcher;
+import org.hamcrest.internal.Wrapping;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
-import java.util.List;
 
-import static org.hamcrest.core.IsEqual.equalTo;
+import static java.util.Arrays.asList;
 
 public class IsIterableContainingInAnyOrder<T> extends TypeSafeDiagnosingMatcher<Iterable<? extends T>> {
     private final Collection<Matcher<? super T>> matchers;
@@ -98,7 +97,7 @@ private boolean isMatched(S item) {
      */
     @SafeVarargs
     public static <T> Matcher<Iterable<? extends T>> containsInAnyOrder(Matcher<? super T>... itemMatchers) {
-        return containsInAnyOrder(Arrays.asList(itemMatchers));
+        return containsInAnyOrder(asList(itemMatchers));
     }
 
     /**
@@ -123,12 +122,7 @@ public static <T> Matcher<Iterable<? extends T>> containsInAnyOrder(Matcher<? su
      */
     @SafeVarargs
     public static <T> Matcher<Iterable<? extends T>> containsInAnyOrder(T... items) {
-        List<Matcher<? super T>> matchers = new ArrayList<>();
-        for (T item : items) {
-            matchers.add(equalTo(item));
-        }
-        
-        return new IsIterableContainingInAnyOrder<>(matchers);
+        return new IsIterableContainingInAnyOrder<>(Wrapping.asEqualToMatchers(items));
     }
 
     /**
diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/MatchCollections.java b/hamcrest-library/src/main/java/org/hamcrest/collection/MatchCollections.java
@@ -1,10 +1,8 @@
 package org.hamcrest.collection;
 
 import org.hamcrest.Matcher;
-import org.hamcrest.internal.Wrapping;
 
 import java.util.Collection;
-import java.util.List;
 
 import static org.hamcrest.object.MatchObjects.equalTo;
 
@@ -58,52 +56,4 @@ public static <E> Matcher<Collection<? extends E>> empty() {
   public static <E> Matcher<Collection<E>> emptyCollectionOf(Class<E> unusedToForceReturnType) {
       return (Matcher)empty();
   }
-
-  /**
-   * Creates a matcher for {@link Iterable}s that matches when a single pass over the
-   * examined {@link Iterable} yields a series of items, each logically equal to the
-   * corresponding item in the specified items.  For a positive match, the examined iterable
-   * must be of the same length as the number of specified items.
-   * For example:
-   * <pre>assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))</pre>
-   *
-   * @param items
-   *     the items that must equal the items provided by an examined {@link Iterable}
-   */
-  @SafeVarargs
-  public static <E> Matcher<Iterable<? extends E>> contains(E... items) {
-      return contains(Wrapping.asEqualToMatchers(items));
-  }
-
-  /**
-   * Creates a matcher for {@link Iterable}s that matches when a single pass over the
-   * examined {@link Iterable} yields a series of items, each satisfying the corresponding
-   * matcher in the specified matchers.  For a positive match, the examined iterable
-   * must be of the same length as the number of specified matchers.
-   * For example:
-   * <pre>assertThat(Arrays.asList("foo", "bar"), contains(equalTo("foo"), equalTo("bar")))</pre>
-   *
-   * @param itemMatchers
-   *     the matchers that must be satisfied by the items provided by an examined {@link Iterable}
-   */
-  @SafeVarargs
-  public static <E> Matcher<Iterable<? extends E>> contains(Matcher<? super E>... itemMatchers) {
-      return contains(Wrapping.nullSafe(itemMatchers));
-  }
-
-  /**
-   * Creates a matcher for {@link Iterable}s that matches when a single pass over the
-   * examined {@link Iterable} yields a series of items, each satisfying the corresponding
-   * matcher in the specified list of matchers.  For a positive match, the examined iterable
-   * must be of the same length as the specified list of matchers.
-   * For example:
-   * <pre>assertThat(Arrays.asList("foo", "bar"), contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))</pre>
-   *
-   * @param itemMatchers
-   *     a list of matchers, each of which must be satisfied by the corresponding item provided by
-   *     an examined {@link Iterable}
-   */
-  public static <E> Matcher<Iterable<? extends E>> contains(List<Matcher<? super E>> itemMatchers) {
-      return new IsIterableContainingInOrder<>(itemMatchers);
-  }
 }
