Coverage Report

Coverage Report - org.truth0.subjects.IterableSubject

Classes in this File

Line Coverage

Branch Coverage

Complexity

IterableSubject

92%

23/25

87%

14/16

2.143

 /*
  * Copyright (C) 2011 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 com.google.common.annotations.GwtCompatible;
 
 import org.truth0.FailureStrategy;
 
 import java.util.Arrays;
 import java.util.Iterator;
 
 /**
  * @author Kevin Bourrillion
  */
 @GwtCompatible
 public class IterableSubject<S extends IterableSubject<S, T, C>, T, C extends Iterable<T>> extends Subject<S, C> {
 
   @SuppressWarnings({ "unchecked", "rawtypes" })
   public static <T, C extends Iterable<T>> IterableSubject<? extends IterableSubject<?, T, C>, T, C> create(
       FailureStrategy failureStrategy, Iterable<T> list) {
     return new IterableSubject(failureStrategy, list);
   }
 
   // TODO: Arguably this should even be package private
   protected IterableSubject(FailureStrategy failureStrategy, C list) {
     super(failureStrategy, list);
   }
 
   /**
    * Attests that the subject holds no more objects, or fails.
    */
   public void isEmpty() {
     if (getSubject().iterator().hasNext()) {
       fail("is empty");
     }
   }
 
   /**
    * Attests that the subject holds one or more objects, or fails
    */
   public void isNotEmpty() {
     if (!getSubject().iterator().hasNext()) {
       fail("is not empty");
     }
   }
 
   /**
    * Asserts that the items are supplied in the order given by the iterable. If
    * the iterable under test and/or the {@code expectedItems} do not provide
    * iteration order guarantees (say, {@link Set<T>}s), this method may provide
    * unexpected results.  Consider using {@link #is(T)} in such cases, or using
    * collections and iterables that provide strong order guarantees.
    */
   public void iteratesAs(Iterable<T> expectedItems) {
     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);
     }
   }
 
   /**
    * @deprecated use {@link #iteratesAs(T...)}
    */
   @Deprecated
   public void iteratesOverSequence(T... expectedItems) {
     iteratesAs(expectedItems);
   }
 
   /**
    * Asserts that the items are supplied in the order given by the iterable. If
    * the iterable under test does not provide iteration order guarantees (say,
    * a {@link Set<T>}), this method is not suitable for asserting that order.
    * Consider using {@link #is(T)}
    */
   public void iteratesAs(T... expectedItems) {
     iteratesAs(Arrays.asList(expectedItems));
   }
 }

1		/*
2		* Copyright (C) 2011 Google, Inc.
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.truth0.subjects;
17
18		import com.google.common.annotations.GwtCompatible;
19
20		import org.truth0.FailureStrategy;
21
22		import java.util.Arrays;
23		import java.util.Iterator;
24
25		/**
26		* @author Kevin Bourrillion
27		*/
28		@GwtCompatible
29		public class IterableSubject<S extends IterableSubject<S, T, C>, T, C extends Iterable<T>> extends Subject<S, C> {
30
31		@SuppressWarnings({ "unchecked", "rawtypes" })
32		public static <T, C extends Iterable<T>> IterableSubject<? extends IterableSubject<?, T, C>, T, C> create(
33		FailureStrategy failureStrategy, Iterable<T> list) {
34	11	return new IterableSubject(failureStrategy, list);
35		}
36
37		// TODO: Arguably this should even be package private
38		protected IterableSubject(FailureStrategy failureStrategy, C list) {
39	83	super(failureStrategy, list);
40	83	}
41
42		/**
43		* Attests that the subject holds no more objects, or fails.
44		*/
45		public void isEmpty() {
46	2	if (getSubject().iterator().hasNext()) {
47	1	fail("is empty");
48		}
49	1	}
50
51		/**
52		* Attests that the subject holds one or more objects, or fails
53		*/
54		public void isNotEmpty() {
55	2	if (!getSubject().iterator().hasNext()) {
56	1	fail("is not empty");
57		}
58	1	}
59
60		/**
61		* Asserts that the items are supplied in the order given by the iterable. If
62		* the iterable under test and/or the {@code expectedItems} do not provide
63		* iteration order guarantees (say, {@link Set<T>}s), this method may provide
64		* unexpected results. Consider using {@link #is(T)} in such cases, or using
65		* collections and iterables that provide strong order guarantees.
66		*/
67		public void iteratesAs(Iterable<T> expectedItems) {
68	7	Iterator<T> actualItems = getSubject().iterator();
69	7	for (Object expected : expectedItems) {
70	16	if (!actualItems.hasNext()) {
71	1	fail("iterates through", expectedItems);
72		} else {
73	15	Object actual = actualItems.next();
74	15	if (actual == expected \|\| actual != null && actual.equals(expected)) {
75	0	continue;
76		} else {
77	1	fail("iterates through", expectedItems);
78		}
79	0	}
80		}
81	5	if (actualItems.hasNext()) {
82	1	fail("iterates through", expectedItems);
83		}
84	4	}
85
86		/**
87		* @deprecated use {@link #iteratesAs(T...)}
88		*/
89		@Deprecated
90		public void iteratesOverSequence(T... expectedItems) {
91	1	iteratesAs(expectedItems);
92	1	}
93
94		/**
95		* Asserts that the items are supplied in the order given by the iterable. If
96		* the iterable under test does not provide iteration order guarantees (say,
97		* a {@link Set<T>}), this method is not suitable for asserting that order.
98		* Consider using {@link #is(T)}
99		*/
100		public void iteratesAs(T... expectedItems) {
101	6	iteratesAs(Arrays.asList(expectedItems));
102	3	}
103		}