Create Ordered interface for passing an 'inOrder()' fluent constraint on top of contains, as well as fixing a bug in iterablesubject, and add some tests. Also, normalize list/iterables methods of comparison.

Author: cgruber

src/main/java/org/junit/contrib/truth/subjects/CollectionSubject.java

@@ -16,18 +16,20 @@
  */
 package org.junit.contrib.truth.subjects;
 
-import java.util.ArrayList;
-import java.util.Arrays;
+import static org.junit.contrib.truth.subjects.SubjectUtils.accumulate;
+import static org.junit.contrib.truth.subjects.SubjectUtils.countOf;
+
 import java.util.Collection;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
 import org.junit.contrib.truth.FailureStrategy;
 
 public class CollectionSubject<S extends CollectionSubject<S, T, C>, T, C extends Collection<T>> extends IterableSubject<S, T, C> {
 
-  @SuppressWarnings("unchecked")
+  @SuppressWarnings({ "unchecked", "rawtypes" })
   public static <T, C extends Collection<T>> CollectionSubject<? extends CollectionSubject<?, T, C>, T, C> create(
       FailureStrategy failureStrategy, Collection<T> list) {
     return new CollectionSubject(failureStrategy, list);
@@ -48,6 +50,9 @@ protected CollectionSubject(FailureStrategy failureStrategy, C list) {
     return nextChain();
   }
 
+  /**
+   * Attests that a Collection is empty or fails.
+   */
   @Override public And<S> isEmpty() {
     if (!getSubject().isEmpty()) {
       fail("isEmpty");
@@ -59,25 +64,27 @@ protected CollectionSubject(FailureStrategy failureStrategy, C list) {
    * Attests that a Collection contains at least one of the provided
    * objects or fails.
    */
-  public And<S> containsAnyOf(Object ... items) {
+  public And<S> containsAnyOf(Object first, Object second, Object ... rest) {
     Collection<?> collection = getSubject();
-    for (Object item : items) {
+    for (Object item : accumulate(first, second, rest)) {
       if (collection.contains(item)) {
         return nextChain();
       }
     }
-    fail("contains", (Object[])items);
+    fail("contains", accumulate(first, second, rest));
     return nextChain();
   }
 
+
   /**
    * Attests that a Collection contains all of the provided objects or fails.
    * This copes with duplicates in both the Collection and the parameters.
    */
-  public And<S> containsAllOf(Object ... items) {
+  public Ordered<S> contains(Object first, Object second, Object ... rest) {
+    final And<S> next = nextChain();
     Collection<?> collection = getSubject();
     // Arrays.asList() does not support remove() so we need a mutable copy.
-    List<Object> required = new ArrayList<Object>(Arrays.asList(items));
+    List<Object> required = accumulate(first, second, rest);
     for (Object item : collection) {
       required.remove(item);
     }
@@ -87,21 +94,37 @@ public And<S> containsAllOf(Object ... items) {
       Object[] params = new Object[missing.size()];
       int n = 0;
       for (Object item : missing) {
-        int count = countOf(item, items);
+        int count = countOf(item, accumulate(first, second, rest));
         params[n++] = (count > 1) ? count + " copies of " + item : item;
       }
       fail("contains", params);
     }
-    return nextChain();
-  }
 
-  private static int countOf(Object t, Object... items) {
-    int count = 0;
-    for (Object item : items) {
-      if (t == null ? (item == null) : t.equals(item)) {
-        count++;
+    final List<?> expectedItems = accumulate(first, second, rest);
+    return new Ordered<S>() {
+      @Override public And<S> inOrder() {
+        Iterator<T> actualItems = getSubject().iterator();
+        for (Object expected : expectedItems) {
+          if (!actualItems.hasNext()) {
+            fail("iterates through", expectedItems);
+          } else {
+            Object actual = actualItems.next();
+            if (actual == expected || actual != null && actual.equals(expected)) {
+              continue;
+            } else {
+              fail("iterates through", expectedItems);
+            }
+          }
+        }
+        if (actualItems.hasNext()) {
+          fail("iterates through", expectedItems);
+        }
+        return nextChain();
       }
-    }
-    return count;
+      @Override public S and() {
+        return nextChain().and();
+      }
+    };
   }
+
 }

src/main/java/org/junit/contrib/truth/subjects/IterableSubject.java

@@ -16,11 +16,8 @@
 
 package org.junit.contrib.truth.subjects;
 
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.Iterator;
 
 import org.junit.contrib.truth.FailureStrategy;
 
@@ -60,28 +57,28 @@ public And<S> isEmpty() {
     return nextChain();
   }
 
-  public And<S> hasContentsInOrder(Object... expected) {
-    // TODO(kevinb): prettier error message
-    List<Object> target = new ArrayList<Object>();
-    for (Object t : getSubject()) {
-      target.add(t);
+  /**
+   * Asserts that the items are supplied in the order given by the iterable. For
+   * Collections and other things which contain items but may not have guaranteed
+   * iteration order, this method should be overridden.
+   */
+  public And<S> iteratesOverSequence(Object... expectedItems) {
+    Iterator<T> actualItems = getSubject().iterator();
+    for (Object expected : expectedItems) {
+      if (!actualItems.hasNext()) {
+        fail("iterates through", Arrays.asList(expectedItems));
+      } else {
+        Object actual = actualItems.next();
+        if (actual == expected || actual != null && actual.equals(expected)) {
+          continue;
+        } else {
+          fail("iterates through", Arrays.asList(expectedItems));
+        }
+      }
     }
-    check().that(target).isEqualTo(Arrays.asList(expected));
-    return nextChain();
-  }
-
-  public And<S> hasContentsAnyOrder(Object... expected) {
-    check().that(createFakeMultiset(getSubject()))
-        .isEqualTo(createFakeMultiset(Arrays.asList(expected)));
-    return nextChain();
-  }
-
-  private static Map<Object, Integer> createFakeMultiset(Iterable<?> iterable) {
-    Map<Object, Integer> map = new HashMap<Object, Integer>();
-    for (Object t : iterable) {
-      Integer count = map.get(t);
-      map.put(t, (count == null) ? 1 : count + 1);
+    if (actualItems.hasNext()) {
+      fail("iterates through", Arrays.asList(expectedItems));
     }
-    return map;
+    return nextChain();
   }
 }

src/main/java/org/junit/contrib/truth/subjects/Ordered.java

@@ -0,0 +1,15 @@
+package org.junit.contrib.truth.subjects;
+
+import org.junit.contrib.truth.subjects.Subject.And;
+
+public interface Ordered<Q> extends And<Q> {
+
+  /**
+   * An additional assertion, implemented by some containment subjects
+   * which allows for a further constraint of orderedness.
+   */
+  And<Q> inOrder();
+
+}
+
+

src/main/java/org/junit/contrib/truth/subjects/Subject.java

@@ -1,7 +1,7 @@
 /*
  * Copyright (c) 2011 David Saff
  * Copyright (c) 2011 Christian Gruber
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -22,7 +22,7 @@
 /**
  * Propositions for arbitrarily typed subjects and for properties
  * of Object
- * 
+ *
  * @author David Saff
  * @author Christian Gruber (cgruber@israfil.net)
  */
@@ -34,9 +34,9 @@ public class Subject<S extends Subject<S,T>,T> {
   public Subject(FailureStrategy failureStrategy, T subject) {
     this.failureStrategy = failureStrategy;
     this.subject = subject;
-    
+
     this.chain = new And<S>(){
-      @SuppressWarnings("unchecked") 
+      @SuppressWarnings("unchecked")
       @Override public S and() {
         return (S)Subject.this;
       }
@@ -50,10 +50,10 @@ public Subject(FailureStrategy failureStrategy, T subject) {
   protected final And<S> nextChain() {
     return chain;
   }
-  
+
   public And<S> is(T other) {
 
-    if (getSubject() == null) { 
+    if (getSubject() == null) {
       if(other != null) {
         fail("is", other);
       }
@@ -71,7 +71,7 @@ public And<S> isNull() {
     }
     return nextChain();
   }
-  
+
   public And<S> isNotNull() {
     if (getSubject() == null) {
       failWithoutSubject("is not null");
@@ -80,7 +80,7 @@ public And<S> isNotNull() {
   }
 
   public And<S> isEqualTo(Object other) {
-    if (getSubject() == null) { 
+    if (getSubject() == null) {
       if(other != null) {
         fail("is equal to", other);
       }
@@ -93,7 +93,7 @@ public And<S> isEqualTo(Object other) {
   }
 
   public And<S> isNotEqualTo(Object other) {
-    if (getSubject() == null) { 
+    if (getSubject() == null) {
       if(other == null) {
         fail("is not equal to", other);
       }
@@ -127,6 +127,11 @@ protected TestVerb check() {
     return new TestVerb(failureStrategy);
   }
 
+  /**
+   * Assembles a failure message and passes such to the FailureStrategy
+   * @param verb the act being asserted
+   * @param messageParts the expectations against which the subject is compared
+   */
   protected void fail(String verb, Object... messageParts) {
     String message = "Not true that ";
     message += "<" + getSubject() + "> " + verb;
@@ -144,13 +149,13 @@ protected void failWithoutSubject(String verb) {
 
   /**
    * A convenience class to allow for chaining in the fluent API
-   * style, such that subjects can make propositions in series.  
+   * style, such that subjects can make propositions in series.
    * i.e. ASSERT.that(blah).isNotNull().and().contains(b).and().isNotEmpty();
    */
   public static interface And<C> {
     /**
      * Returns the next object in the chain of anded objects.
      */
     C and();
-  }  
+  }
 }

src/main/java/org/junit/contrib/truth/subjects/SubjectUtils.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2011 David Saff
+ * Copyright (c) 2011 Christian Gruber
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.junit.contrib.truth.subjects;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+
+/**
+ * Utility methods used in Subject<T> implementors.
+ *
+ * @author Christian Gruber (cgruber@israfil.net)
+ */
+class SubjectUtils {
+
+  private SubjectUtils() {}
+
+  static <T> List<T> accumulate(T first, T second, T ... rest) {
+    List<T> items = new LinkedList<T>();
+    items.add(first);
+    items.add(second);
+    items.addAll(Arrays.asList(rest));
+    return items;
+  }
+
+  static <T> int countOf(T t, Iterable<T> items) {
+    int count = 0;
+    for (T item : items) {
+      if (t == null ? (item == null) : t.equals(item)) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+}