Coverage Report

 /*
  * Copyright (c) 2011 David Saff
  * Copyright (c) 2011 Christian Gruber
  * Copyright (c) 2012 Google, Inc.
  *
  * 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.truth0.subjects;
 
 import static org.truth0.subjects.SubjectUtils.accumulate;
 import static org.truth0.subjects.SubjectUtils.countDuplicates;
 
 import com.google.common.annotations.GwtCompatible;
 
 import org.truth0.FailureStrategy;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 
 @GwtCompatible
 public class CollectionSubject<S extends CollectionSubject<S, T, C>, T, C extends Collection<T>> extends IterableSubject<S, T, C> {
 
   @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);
   }
 
   // TODO: Arguably this should even be package private
   protected CollectionSubject(FailureStrategy failureStrategy, C list) {
     super(failureStrategy, list);
   }
 
   /**
    * Attests that a Collection is empty or fails.
    */
   @Override public void isEmpty() {
     if (!getSubject().isEmpty()) {
       fail("is empty");
     }
   }
 
   public Has<T, C> has() {
     return new Has<T, C>() {
       @Override public void item(T item) {
         if (!getSubject().contains(item)) {
           fail("has item", item);
         }
       }
 
       @Override public void anyOf(T first) {
         anyFrom(accumulate(first));
       }
       @Override public final void anyOf(T first, T second, T ... rest) {
         anyFrom(accumulate(first, second, rest));
       }
       @Override public void anyFrom(Collection<T> col) {
         for (Object item : col) {
           if (getSubject().contains(item)) {
             return;
           }
         }
         fail("contains", col);
       }
 
       @Override public Ordered allOf(T first) {
         return allFrom(accumulate(first));
       }
       @Override public final Ordered allOf(T first, T second, T ... rest) {
         return allFrom(accumulate(first, second, rest));
       }
       @Override public Ordered allFrom(final Collection<T> required) {
         Collection<T> toRemove = new ArrayList<T>(required);
         // remove each item in the subject, as many times as it occurs in the subject.
         for (Object item : getSubject()) {
           toRemove.remove(item);
         }
         if (!toRemove.isEmpty()) {
           failWithBadResults("has all of", required, "is missing", countDuplicates(toRemove));
         }
         return new InOrder("has all in order", required);
       }
 
       @Override public Ordered exactly(T first) {
         return exactlyAs(accumulate(first));
       }
       @Override public final Ordered exactly(T first, T second, T ... rest) {
         return exactlyAs(accumulate(first, second, rest));
       }
       @Override public Ordered exactlyAs(Collection<T> required) {
         Collection<T> toRemove = new ArrayList<T>(required);
         Collection<Object> extra = new ArrayList<Object>();
         // remove each item in the subject, as many times as it occurs in the subject.
         for (Object item : getSubject()) {
           if (!toRemove.remove(item)) {
             extra.add(item);
           }
         }
         if (!toRemove.isEmpty()) {
           failWithBadResults("has exactly", required, "is missing", countDuplicates(toRemove));
         }
         if (!extra.isEmpty()) {
           failWithBadResults("has exactly", required, "has unexpected items", countDuplicates(extra));
         }
         return new InOrder("has exactly in order", required);
       }
     };
   }
 
   private class InOrder implements Ordered {
     private final String check;
     private final Collection<T> required;
 
     InOrder(String check, Collection<T> required) {
       this.check = check;
       this.required = required;
     }
 
     @Override public void inOrder() {
       Iterator<T> actualItems = getSubject().iterator();
       for (Object expected : required) {
         if (!actualItems.hasNext()) {
           fail(check, required);
         } else {
           Object actual = actualItems.next();
           if (actual == expected || actual != null && actual.equals(expected)) {
             continue;
           } else {
             fail(check, required);
           }
         }
       }
       if (actualItems.hasNext()) {
         fail(check, required);
       }
     }
   }
 
   public interface Has<E, C extends Collection<E>> {
     /**
      * Attests that a Collection contains at least the item
      */
     void item(E item);
 
     /**
      * Attests that a Collection contains at least one of the provided objects
      * or fails.
      */
     void anyOf(E first);
 
     /**
      * Attests that a Collection contains at least one of the provided objects
      * or fails.
      */
     void anyOf(E first, E second, E... rest);
 
     /**
      * Attests that a Collection contains at least one of the objects contained
      * in the provided collection or fails.
      */
     void anyFrom(Collection<E> expected);
 
     /**
      * Attests that a Collection contains at least all of the provided objects
      * or fails, coping with duplicates in both the Collection and the
      * parameters.
      */
     Ordered allOf(E first);
 
     /**
      * Attests that a Collection contains at least all of the provided objects
      * or fails, coping with duplicates in both the Collection and the
      * parameters.
      */
     Ordered allOf(E first, E second, E... rest);
 
     /**
      * Attests that a Collection contains at least all of the objects contained
      * in the provided collection or fails, coping with duplicates in both
      * the Collection and the parameters.
      */
     Ordered allFrom(Collection<E> expected);
 
     /**
      * Attests that a Collection contains at all of the provided objects and
      * only these objects or fails. This copes with duplicates in both the
      * Collection and the parameters. It makes no attestation about order
      * unless {@code inOrder()} is explicitly called.
      */
     Ordered exactly(E first);
 
     /**
      * Attests that a Collection contains at all of the provided objects and
      * only these objects or fails. This copes with duplicates in both the
      * Collection and the parameters. It makes no attestation about order
      * unless {@code inOrder()} is explicitly called.
      */
     Ordered exactly(E first, E second, E... rest);
 
     /**
      * Attests that a Collection contains at all of the objects contained in the
      * provided collection and only these objects or fails. This copes with
      * duplicates in both the Collection and the parameters. It makes no
      * attestation about order unless {@code inOrder()} is explicitly called.
      */
     Ordered exactlyAs(Collection<E> expected);
   }
 }

1		/*
2		* Copyright (c) 2011 David Saff
3		* Copyright (c) 2011 Christian Gruber
4		* Copyright (c) 2012 Google, Inc.
5		*
6		* Licensed under the Apache License, Version 2.0 (the "License");
7		* you may not use this file except in compliance with the License.
8		* You may obtain a copy of the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing, software
13		* distributed under the License is distributed on an "AS IS" BASIS,
14		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15		* See the License for the specific language governing permissions and
16		* limitations under the License.
17		*/
18		package org.truth0.subjects;
19
20		import static org.truth0.subjects.SubjectUtils.accumulate;
21		import static org.truth0.subjects.SubjectUtils.countDuplicates;
22
23		import com.google.common.annotations.GwtCompatible;
24
25		import org.truth0.FailureStrategy;
26
27		import java.util.ArrayList;
28		import java.util.Collection;
29		import java.util.Iterator;
30
31		@GwtCompatible
32		public class CollectionSubject<S extends CollectionSubject<S, T, C>, T, C extends Collection<T>> extends IterableSubject<S, T, C> {
33
34		@SuppressWarnings({ "unchecked", "rawtypes" })
35		public static <T, C extends Collection<T>> CollectionSubject<? extends CollectionSubject<?, T, C>, T, C> create(
36		FailureStrategy failureStrategy, Collection<T> list) {
37	42	return new CollectionSubject(failureStrategy, list);
38		}
39
40		// TODO: Arguably this should even be package private
41		protected CollectionSubject(FailureStrategy failureStrategy, C list) {
42	72	super(failureStrategy, list);
43	72	}
44
45		/**
46		* Attests that a Collection is empty or fails.
47		*/
48		@Override public void isEmpty() {
49	2	if (!getSubject().isEmpty()) {
50	1	fail("is empty");
51		}
52	1	}
53
54		public Has<T, C> has() {
55	45	return new Has<T, C>() {
56		@Override public void item(T item) {
57	4	if (!getSubject().contains(item)) {
58	1	fail("has item", item);
59		}
60	3	}
61
62		@Override public void anyOf(T first) {
63	0	anyFrom(accumulate(first));
64	0	}
65		@Override public final void anyOf(T first, T second, T ... rest) {
66	6	anyFrom(accumulate(first, second, rest));
67	5	}
68		@Override public void anyFrom(Collection<T> col) {
69	6	for (Object item : col) {
70	11	if (getSubject().contains(item)) {
71	4	return;
72		}
73		}
74	2	fail("contains", col);
75	1	}
76
77		@Override public Ordered allOf(T first) {
78	0	return allFrom(accumulate(first));
79		}
80		@Override public final Ordered allOf(T first, T second, T ... rest) {
81	16	return allFrom(accumulate(first, second, rest));
82		}
83		@Override public Ordered allFrom(final Collection<T> required) {
84	16	Collection<T> toRemove = new ArrayList<T>(required);
85		// remove each item in the subject, as many times as it occurs in the subject.
86	16	for (Object item : getSubject()) {
87	49	toRemove.remove(item);
88		}
89	16	if (!toRemove.isEmpty()) {
90	5	failWithBadResults("has all of", required, "is missing", countDuplicates(toRemove));
91		}
92	12	return new InOrder("has all in order", required);
93		}
94
95		@Override public Ordered exactly(T first) {
96	0	return exactlyAs(accumulate(first));
97		}
98		@Override public final Ordered exactly(T first, T second, T ... rest) {
99	19	return exactlyAs(accumulate(first, second, rest));
100		}
101		@Override public Ordered exactlyAs(Collection<T> required) {
102	19	Collection<T> toRemove = new ArrayList<T>(required);
103	19	Collection<Object> extra = new ArrayList<Object>();
104		// remove each item in the subject, as many times as it occurs in the subject.
105	19	for (Object item : getSubject()) {
106	61	if (!toRemove.remove(item)) {
107	3	extra.add(item);
108		}
109		}
110	19	if (!toRemove.isEmpty()) {
111	5	failWithBadResults("has exactly", required, "is missing", countDuplicates(toRemove));
112		}
113	14	if (!extra.isEmpty()) {
114	2	failWithBadResults("has exactly", required, "has unexpected items", countDuplicates(extra));
115		}
116	12	return new InOrder("has exactly in order", required);
117		}
118		};
119		}
120
121		private class InOrder implements Ordered {
122		private final String check;
123		private final Collection<T> required;
124
125	24	InOrder(String check, Collection<T> required) {
126	24	this.check = check;
127	24	this.required = required;
128	24	}
129
130		@Override public void inOrder() {
131	12	Iterator<T> actualItems = getSubject().iterator();
132	12	for (Object expected : required) {
133	26	if (!actualItems.hasNext()) {
134	2	fail(check, required);
135		} else {
136	24	Object actual = actualItems.next();
137	24	if (actual == expected \|\| actual != null && actual.equals(expected)) {
138	0	continue;
139		} else {
140	4	fail(check, required);
141		}
142	0	}
143		}
144	6	if (actualItems.hasNext()) {
145	2	fail(check, required);
146		}
147	4	}
148		}
149
150		public interface Has<E, C extends Collection<E>> {
151		/**
152		* Attests that a Collection contains at least the item
153		*/
154		void item(E item);
155
156		/**
157		* Attests that a Collection contains at least one of the provided objects
158		* or fails.
159		*/
160		void anyOf(E first);
161
162		/**
163		* Attests that a Collection contains at least one of the provided objects
164		* or fails.
165		*/
166		void anyOf(E first, E second, E... rest);
167
168		/**
169		* Attests that a Collection contains at least one of the objects contained
170		* in the provided collection or fails.
171		*/
172		void anyFrom(Collection<E> expected);
173
174		/**
175		* Attests that a Collection contains at least all of the provided objects
176		* or fails, coping with duplicates in both the Collection and the
177		* parameters.
178		*/
179		Ordered allOf(E first);
180
181		/**
182		* Attests that a Collection contains at least all of the provided objects
183		* or fails, coping with duplicates in both the Collection and the
184		* parameters.
185		*/
186		Ordered allOf(E first, E second, E... rest);
187
188		/**
189		* Attests that a Collection contains at least all of the objects contained
190		* in the provided collection or fails, coping with duplicates in both
191		* the Collection and the parameters.
192		*/
193		Ordered allFrom(Collection<E> expected);
194
195		/**
196		* Attests that a Collection contains at all of the provided objects and
197		* only these objects or fails. This copes with duplicates in both the
198		* Collection and the parameters. It makes no attestation about order
199		* unless {@code inOrder()} is explicitly called.
200		*/
201		Ordered exactly(E first);
202
203		/**
204		* Attests that a Collection contains at all of the provided objects and
205		* only these objects or fails. This copes with duplicates in both the
206		* Collection and the parameters. It makes no attestation about order
207		* unless {@code inOrder()} is explicitly called.
208		*/
209		Ordered exactly(E first, E second, E... rest);
210
211		/**
212		* Attests that a Collection contains at all of the objects contained in the
213		* provided collection and only these objects or fails. This copes with
214		* duplicates in both the Collection and the parameters. It makes no
215		* attestation about order unless {@code inOrder()} is explicitly called.
216		*/
217		Ordered exactlyAs(Collection<E> expected);
218		}
219		}