Rename HasConsecutiveItems to HasSubsequence

bhamiltoncx · bhamiltoncx · commit 1ee2cd889f83 · 2014-12-12T10:02:56.000-08:00
diff --git a/hamcrest-library/matchers.xml b/hamcrest-library/matchers.xml
@@ -19,7 +19,7 @@
     <factory class="org.hamcrest.core.StringEndsWith"/>
 
     <!-- Collection -->
-    <factory class="org.hamcrest.collection.HasConsecutiveItems"/>
+    <factory class="org.hamcrest.collection.HasSubsequence"/>
     <factory class="org.hamcrest.collection.IsArray"/>
     <factory class="org.hamcrest.collection.IsArrayContaining"/>
     <factory class="org.hamcrest.collection.IsArrayContainingInOrder"/>
@@ -63,4 +63,4 @@
     <!-- XML -->
     <factory class="org.hamcrest.xml.HasXPath"/>
 
-</matchers>
+</matchers>
diff --git a/hamcrest-library/src/main/java/org/hamcrest/collection/HasSubsequence.java b/hamcrest-library/src/main/java/org/hamcrest/collection/HasSubsequence.java
@@ -15,25 +15,25 @@
  * Matches if a collection contains another collection's items in
  * consecutive order anywhere inside it.
  */
-public class HasConsecutiveItems<T>
+public class HasSubsequence<T>
     extends TypeSafeDiagnosingMatcher<Collection<? extends T>> {
     private final List<Matcher<? super T>> matchers;
 
-    public HasConsecutiveItems(List<Matcher<? super T>> matchers) {
+    public HasSubsequence(List<Matcher<? super T>> matchers) {
         this.matchers = matchers;
     }
 
     @Override
     public boolean matchesSafely(
-            Collection<? extends T> itemsToMatch,
+            Collection<? extends T> subsequenceToMatch,
             Description mismatchDescription) {
-        List<? extends T> itemsToMatchList = new ArrayList<T>(itemsToMatch);
+        List<? extends T> subsequenceToMatchList = new ArrayList<T>(subsequenceToMatch);
 
-        for (int i = 0; i <= itemsToMatchList.size() - matchers.size(); i++) {
+        for (int i = 0; i <= subsequenceToMatchList.size() - matchers.size(); i++) {
             boolean allMatchersMatched = true;
             for (int j = 0; j < matchers.size(); j++) {
                 Matcher<? super T> matcher = matchers.get(j);
-                if (!matcher.matches(itemsToMatchList.get(i + j))) {
+                if (!matcher.matches(subsequenceToMatchList.get(i + j))) {
                     allMatchersMatched = false;
                     break;
                 }
@@ -44,42 +44,42 @@ public boolean matchesSafely(
         }
 
         mismatchDescription
-                .appendText("could not find items inside collection ")
-                .appendValueList("[", ", ", "]", itemsToMatch);
+                .appendText("could not find subsequence inside collection ")
+                .appendValueList("[", ", ", "]", subsequenceToMatch);
         return false;
     }
 
     @Override
     public void describeTo(Description description) {
         description
-                .appendText("collection contains consecutive items matching ")
+                .appendText("collection contains subsequence matching ")
                 .appendList("[", ", ", "]", matchers);
     }
 
     @Factory
-    public static <T> Matcher<Collection<? extends T>> hasConsecutiveItems(
+    public static <T> Matcher<Collection<? extends T>> hasSubsequence(
             List<Matcher<? super T>> matchers) {
-        return new HasConsecutiveItems<T>(matchers);
+        return new HasSubsequence<T>(matchers);
     }
 
     @Factory
-    public static <T> Matcher<Collection<? extends T>> hasConsecutiveItems(
+    public static <T> Matcher<Collection<? extends T>> hasSubsequence(
             Matcher<? super T>... matchers) {
-        return hasConsecutiveItems(Arrays.asList(matchers));
+        return hasSubsequence(Arrays.asList(matchers));
     }
 
     @Factory
-    public static <T> Matcher<Collection<? extends T>> hasConsecutiveItems(
+    public static <T> Matcher<Collection<? extends T>> hasSubsequence(
             Iterable<? extends T> items) {
         List<Matcher<? super T>> matchers = new ArrayList<Matcher<? super T>>();
         for (Object item : items) {
             matchers.add(equalTo(item));
         }
-        return new HasConsecutiveItems<T>(matchers);
+        return new HasSubsequence<T>(matchers);
     }
 
     @Factory
-    public static <T> Matcher<Collection<? extends T>> hasConsecutiveItems(T... elements) {
-        return hasConsecutiveItems(Arrays.asList(elements));
+    public static <T> Matcher<Collection<? extends T>> hasSubsequence(T... elements) {
+        return hasSubsequence(Arrays.asList(elements));
     }
 }
diff --git a/hamcrest-library/src/test/java/org/hamcrest/collection/HasSubsequenceTest.java b/hamcrest-library/src/test/java/org/hamcrest/collection/HasSubsequenceTest.java
@@ -9,61 +9,61 @@
 import org.hamcrest.Matcher;
 
 import static java.util.Arrays.asList;
-import static org.hamcrest.collection.HasConsecutiveItems.hasConsecutiveItems;
+import static org.hamcrest.collection.HasSubsequence.hasSubsequence;
 import static org.hamcrest.core.IsEqual.equalTo;
 
 @SuppressWarnings("unchecked")
-public class HasConsecutiveItemsTest extends AbstractMatcherTest {
-    private final Matcher<Collection<? extends WithValue>> contains123 = hasConsecutiveItems(value(1), value(2), value(3));
+public class HasSubsequenceTest extends AbstractMatcherTest {
+    private final Matcher<Collection<? extends WithValue>> contains123 = hasSubsequence(value(1), value(2), value(3));
 
     @Override
     protected Matcher<?> createMatcher() {
-        return hasConsecutiveItems(1, 2);
+        return hasSubsequence(1, 2);
     }
 
     public void testMatchingSingleItemCollection() throws Exception {
-        assertMatches("Single item iterable", hasConsecutiveItems(1), asList(1));
+        assertMatches("Single item iterable", hasSubsequence(1), asList(1));
     }
 
     public void testMatchingMultipleItemCollection() throws Exception {
-        assertMatches("Multiple item iterable", hasConsecutiveItems(1, 2, 3), asList(1, 2, 3));
+        assertMatches("Multiple item iterable", hasSubsequence(1, 2, 3), asList(1, 2, 3));
     }
 
     public void testMatchesWithMoreElementsThanExpectedAtBeginning() throws Exception {
-        assertMatches("More elements at beginning", hasConsecutiveItems(2, 3, 4), asList(1, 2, 3, 4));
+        assertMatches("More elements at beginning", hasSubsequence(2, 3, 4), asList(1, 2, 3, 4));
     }
 
     public void testMatchesWithMoreElementsThanExpectedAtEnd() throws Exception {
-        assertMatches("More elements at end", hasConsecutiveItems(1, 2, 3), asList(1, 2, 3, 4));
+        assertMatches("More elements at end", hasSubsequence(1, 2, 3), asList(1, 2, 3, 4));
     }
 
     public void testDoesNotMatchWithMoreElementsThanExpectedInBetween() throws Exception {
-        assertMismatchDescription("could not find items inside collection [<1>, <2>, <3>]", hasConsecutiveItems(1, 3), asList(1, 2, 3));
+        assertMismatchDescription("could not find subsequence inside collection [<1>, <2>, <3>]", hasSubsequence(1, 3), asList(1, 2, 3));
     }
 
     public void testMatchesSubSection() throws Exception {
-        assertMatches("Sub section of iterable", hasConsecutiveItems(2, 3), asList(1, 2, 3, 4));
+        assertMatches("Sub section of iterable", hasSubsequence(2, 3), asList(1, 2, 3, 4));
     }
 
     public void testDoesNotMatchWithFewerElementsThanExpected() throws Exception {
         List<WithValue> valueList = asList(make(1), make(2));
-        assertMismatchDescription("could not find items inside collection [<WithValue 1>, <WithValue 2>]", contains123, valueList);
+        assertMismatchDescription("could not find subsequence inside collection [<WithValue 1>, <WithValue 2>]", contains123, valueList);
     }
 
     public void testDoesNotMatchIfSingleItemNotFound() throws Exception {
-        assertMismatchDescription("could not find items inside collection [<WithValue 3>]", hasConsecutiveItems(value(4)), asList(make(3)));
+        assertMismatchDescription("could not find subsequence inside collection [<WithValue 3>]", hasSubsequence(value(4)), asList(make(3)));
     }
 
     public void testDoesNotMatchIfOneOfMultipleItemsNotFound() throws Exception {
-        assertMismatchDescription("could not find items inside collection [<WithValue 1>, <WithValue 2>, <WithValue 4>]", contains123, asList(make(1), make(2), make(4)));
+        assertMismatchDescription("could not find subsequence inside collection [<WithValue 1>, <WithValue 2>, <WithValue 4>]", contains123, asList(make(1), make(2), make(4)));
     }
 
     public void testDoesNotMatchEmptyCollection() throws Exception {
-        assertMismatchDescription("could not find items inside collection []", hasConsecutiveItems(value(4)), new ArrayList<WithValue>());
+        assertMismatchDescription("could not find subsequence inside collection []", hasSubsequence(value(4)), new ArrayList<WithValue>());
     }
 
     public void testHasAReadableDescription() {
-        assertDescription("collection contains consecutive items matching [<1>, <2>]", hasConsecutiveItems(1, 2));
+        assertDescription("collection contains subsequence matching [<1>, <2>]", hasSubsequence(1, 2));
     }
 
     public static class WithValue {

Original file line number	Diff line number	Diff line change
`@@ -9,61 +9,61 @@`
`9`	`9`	`import org.hamcrest.Matcher;`
`10`	`10`
`11`	`11`	`import static java.util.Arrays.asList;`
`12`		`-import static org.hamcrest.collection.HasConsecutiveItems.hasConsecutiveItems;`
	`12`	`+import static org.hamcrest.collection.HasSubsequence.hasSubsequence;`
`13`	`13`	`import static org.hamcrest.core.IsEqual.equalTo;`
`14`	`14`
`15`	`15`	`@SuppressWarnings("unchecked")`
`16`		`-public class HasConsecutiveItemsTest extends AbstractMatcherTest {`
`17`		`- private final Matcher<Collection<? extends WithValue>> contains123 = hasConsecutiveItems(value(1), value(2), value(3));`
	`16`	`+public class HasSubsequenceTest extends AbstractMatcherTest {`
	`17`	`+ private final Matcher<Collection<? extends WithValue>> contains123 = hasSubsequence(value(1), value(2), value(3));`
`18`	`18`
`19`	`19`	`@Override`
`20`	`20`	`protected Matcher<?> createMatcher() {`
`21`		`- return hasConsecutiveItems(1, 2);`
	`21`	`+ return hasSubsequence(1, 2);`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`public void testMatchingSingleItemCollection() throws Exception {`
`25`		`- assertMatches("Single item iterable", hasConsecutiveItems(1), asList(1));`
	`25`	`+ assertMatches("Single item iterable", hasSubsequence(1), asList(1));`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`public void testMatchingMultipleItemCollection() throws Exception {`
`29`		`- assertMatches("Multiple item iterable", hasConsecutiveItems(1, 2, 3), asList(1, 2, 3));`
	`29`	`+ assertMatches("Multiple item iterable", hasSubsequence(1, 2, 3), asList(1, 2, 3));`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`public void testMatchesWithMoreElementsThanExpectedAtBeginning() throws Exception {`
`33`		`- assertMatches("More elements at beginning", hasConsecutiveItems(2, 3, 4), asList(1, 2, 3, 4));`
	`33`	`+ assertMatches("More elements at beginning", hasSubsequence(2, 3, 4), asList(1, 2, 3, 4));`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`public void testMatchesWithMoreElementsThanExpectedAtEnd() throws Exception {`
`37`		`- assertMatches("More elements at end", hasConsecutiveItems(1, 2, 3), asList(1, 2, 3, 4));`
	`37`	`+ assertMatches("More elements at end", hasSubsequence(1, 2, 3), asList(1, 2, 3, 4));`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`public void testDoesNotMatchWithMoreElementsThanExpectedInBetween() throws Exception {`
`41`		`- assertMismatchDescription("could not find items inside collection [<1>, <2>, <3>]", hasConsecutiveItems(1, 3), asList(1, 2, 3));`
	`41`	`+ assertMismatchDescription("could not find subsequence inside collection [<1>, <2>, <3>]", hasSubsequence(1, 3), asList(1, 2, 3));`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`public void testMatchesSubSection() throws Exception {`
`45`		`- assertMatches("Sub section of iterable", hasConsecutiveItems(2, 3), asList(1, 2, 3, 4));`
	`45`	`+ assertMatches("Sub section of iterable", hasSubsequence(2, 3), asList(1, 2, 3, 4));`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`public void testDoesNotMatchWithFewerElementsThanExpected() throws Exception {`
`49`	`49`	`List<WithValue> valueList = asList(make(1), make(2));`
`50`		`- assertMismatchDescription("could not find items inside collection [<WithValue 1>, <WithValue 2>]", contains123, valueList);`
	`50`	`+ assertMismatchDescription("could not find subsequence inside collection [<WithValue 1>, <WithValue 2>]", contains123, valueList);`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`public void testDoesNotMatchIfSingleItemNotFound() throws Exception {`
`54`		`- assertMismatchDescription("could not find items inside collection [<WithValue 3>]", hasConsecutiveItems(value(4)), asList(make(3)));`
	`54`	`+ assertMismatchDescription("could not find subsequence inside collection [<WithValue 3>]", hasSubsequence(value(4)), asList(make(3)));`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`public void testDoesNotMatchIfOneOfMultipleItemsNotFound() throws Exception {`
`58`		`- assertMismatchDescription("could not find items inside collection [<WithValue 1>, <WithValue 2>, <WithValue 4>]", contains123, asList(make(1), make(2), make(4)));`
	`58`	`+ assertMismatchDescription("could not find subsequence inside collection [<WithValue 1>, <WithValue 2>, <WithValue 4>]", contains123, asList(make(1), make(2), make(4)));`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`public void testDoesNotMatchEmptyCollection() throws Exception {`
`62`		`- assertMismatchDescription("could not find items inside collection []", hasConsecutiveItems(value(4)), new ArrayList<WithValue>());`
	`62`	`+ assertMismatchDescription("could not find subsequence inside collection []", hasSubsequence(value(4)), new ArrayList<WithValue>());`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`public void testHasAReadableDescription() {`
`66`		`- assertDescription("collection contains consecutive items matching [<1>, <2>]", hasConsecutiveItems(1, 2));`
	`66`	`+ assertDescription("collection contains subsequence matching [<1>, <2>]", hasSubsequence(1, 2));`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`public static class WithValue {`