Coverage Report

 /*
  * Copyright (c) 2011 David Beaumont
  *
  * 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 java.util.Comparator;
 import java.util.List;
 
 import org.truth0.FailureStrategy;
 
 import com.google.common.annotations.GwtCompatible;
 
 @GwtCompatible
 public class ListSubject<S extends ListSubject<S, T, C>, T, C extends List<T>>
     extends CollectionSubject<S, T, C> {
 
   @SuppressWarnings({ "unchecked", "rawtypes" })
   public static <T, C extends List<T>> ListSubject<? extends ListSubject<?, T, C>, T, C> create(
       FailureStrategy failureStrategy, List<T> list) {
     return new ListSubject(failureStrategy, list);
   }
 
   protected ListSubject(FailureStrategy failureStrategy, C list) {
     super(failureStrategy, list);
   }
 
   /**
    * Attests that a List contains the specified sequence.
    */
   public void containsSequence(List<?> sequence) {
     if (sequence.isEmpty()) {
       return;
     }
     List<?> list = getSubject();
     while (true) {
       int first = list.indexOf(sequence.get(0));
       if (first < 0) {
         break;    // Not found
       }
       int last = first + sequence.size();
       if (last > list.size()) {
         break;    // Not enough room left
       }
       if (sequence.equals(list.subList(first, last))) {
         return;
       }
       list = list.subList(first + 1, list.size());
     }
     fail("contains sequence", sequence);
   }
 
   /**
    * Attests that a List is strictly ordered according to the natural ordering of its elements.
    * Null elements are not permitted.
    *
    * @throws ClassCastException if any pair of elements is not mutually Comparable.
    * @throws NullPointerException if any element is null.
    */
   public void isOrdered() {
     pairwiseCheck(new PairwiseChecker<T>() {
       @SuppressWarnings("unchecked")
       @Override public void check(T prev, T next) {
         if (((Comparable<T>) prev).compareTo(next) >= 0) {
           fail("is strictly ordered", prev, next);
         }
       }
     });
   }
 
   /**
    * Attests that a List is partially ordered according to the natural ordering of its elements.
    * Null elements are not permitted.
    *
    * @throws ClassCastException if any pair of elements is not mutually Comparable.
    * @throws NullPointerException if any element is null.
    */
   public void isPartiallyOrdered() {
     pairwiseCheck(new PairwiseChecker<T>() {
       @SuppressWarnings("unchecked")
       @Override public void check(T prev, T next) {
         if (((Comparable<T>) prev).compareTo(next) > 0) {
           fail("is partially ordered", prev, next);
         }
       }
     });
   }
 
   /**
    * Attests that a List is strictly ordered according to the given comparator.
    * Null elements are not permitted.
    *
    * @throws ClassCastException if any pair of elements is not mutually Comparable.
    * @throws NullPointerException if any element is null.
    */
   public void isOrdered(final Comparator<T> comparator) {
     pairwiseCheck(new PairwiseChecker<T>() {
       @Override public void check(T prev, T next) {
         if (comparator.compare(prev, next) >= 0) {
           fail("is strictly ordered", prev, next);
         }
       }
     });
   }
 
   /**
    * Attests that a List is partially ordered according to the given comparator.
    * Null elements are not permitted.
    *
    * @throws ClassCastException if any pair of elements is not mutually Comparable.
    * @throws NullPointerException if any element is null.
    */
   public void isPartiallyOrdered(final Comparator<T> comparator) {
     pairwiseCheck(new PairwiseChecker<T>() {
       @Override public void check(T prev, T next) {
         if (comparator.compare(prev, next) > 0) {
           fail("is partially ordered", prev, next);
         }
       }
     });
   }
 
   private void pairwiseCheck(PairwiseChecker<T> checker) {
     List<T> list = getSubject();
     if (list.size() > 1) {
       T prev = list.get(0);
       for (int n = 1; n < list.size(); n++) {
         T next = list.get(n);
         checker.check(prev, next);
         prev = next;
       }
     }
   }
 
   private interface PairwiseChecker<T> {
     void check(T prev, T next);
   }
 }

1		/*
2		* Copyright (c) 2011 David Beaumont
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 java.util.Comparator;
19		import java.util.List;
20
21		import org.truth0.FailureStrategy;
22
23		import com.google.common.annotations.GwtCompatible;
24
25		@GwtCompatible
26		public class ListSubject<S extends ListSubject<S, T, C>, T, C extends List<T>>
27		extends CollectionSubject<S, T, C> {
28
29		@SuppressWarnings({ "unchecked", "rawtypes" })
30		public static <T, C extends List<T>> ListSubject<? extends ListSubject<?, T, C>, T, C> create(
31		FailureStrategy failureStrategy, List<T> list) {
32	30	return new ListSubject(failureStrategy, list);
33		}
34
35		protected ListSubject(FailureStrategy failureStrategy, C list) {
36	30	super(failureStrategy, list);
37	30	}
38
39		/**
40		* Attests that a List contains the specified sequence.
41		*/
42		public void containsSequence(List<?> sequence) {
43	7	if (sequence.isEmpty()) {
44	1	return;
45		}
46	6	List<?> list = getSubject();
47		while (true) {
48	10	int first = list.indexOf(sequence.get(0));
49	10	if (first < 0) {
50	1	break; // Not found
51		}
52	9	int last = first + sequence.size();
53	9	if (last > list.size()) {
54	1	break; // Not enough room left
55		}
56	8	if (sequence.equals(list.subList(first, last))) {
57	4	return;
58		}
59	4	list = list.subList(first + 1, list.size());
60	4	}
61	2	fail("contains sequence", sequence);
62	0	}
63
64		/**
65		* Attests that a List is strictly ordered according to the natural ordering of its elements.
66		* Null elements are not permitted.
67		*
68		* @throws ClassCastException if any pair of elements is not mutually Comparable.
69		* @throws NullPointerException if any element is null.
70		*/
71		public void isOrdered() {
72	5	pairwiseCheck(new PairwiseChecker<T>() {
73		@SuppressWarnings("unchecked")
74		@Override public void check(T prev, T next) {
75	6	if (((Comparable<T>) prev).compareTo(next) >= 0) {
76	1	fail("is strictly ordered", prev, next);
77		}
78	4	}
79		});
80	3	}
81
82		/**
83		* Attests that a List is partially ordered according to the natural ordering of its elements.
84		* Null elements are not permitted.
85		*
86		* @throws ClassCastException if any pair of elements is not mutually Comparable.
87		* @throws NullPointerException if any element is null.
88		*/
89		public void isPartiallyOrdered() {
90	5	pairwiseCheck(new PairwiseChecker<T>() {
91		@SuppressWarnings("unchecked")
92		@Override public void check(T prev, T next) {
93	9	if (((Comparable<T>) prev).compareTo(next) > 0) {
94	1	fail("is partially ordered", prev, next);
95		}
96	7	}
97		});
98	3	}
99
100		/**
101		* Attests that a List is strictly ordered according to the given comparator.
102		* Null elements are not permitted.
103		*
104		* @throws ClassCastException if any pair of elements is not mutually Comparable.
105		* @throws NullPointerException if any element is null.
106		*/
107		public void isOrdered(final Comparator<T> comparator) {
108	4	pairwiseCheck(new PairwiseChecker<T>() {
109		@Override public void check(T prev, T next) {
110	5	if (comparator.compare(prev, next) >= 0) {
111	1	fail("is strictly ordered", prev, next);
112		}
113	4	}
114		});
115	3	}
116
117		/**
118		* Attests that a List is partially ordered according to the given comparator.
119		* Null elements are not permitted.
120		*
121		* @throws ClassCastException if any pair of elements is not mutually Comparable.
122		* @throws NullPointerException if any element is null.
123		*/
124		public void isPartiallyOrdered(final Comparator<T> comparator) {
125	4	pairwiseCheck(new PairwiseChecker<T>() {
126		@Override public void check(T prev, T next) {
127	8	if (comparator.compare(prev, next) > 0) {
128	1	fail("is partially ordered", prev, next);
129		}
130	7	}
131		});
132	3	}
133
134		private void pairwiseCheck(PairwiseChecker<T> checker) {
135	18	List<T> list = getSubject();
136	18	if (list.size() > 1) {
137	10	T prev = list.get(0);
138	32	for (int n = 1; n < list.size(); n++) {
139	28	T next = list.get(n);
140	28	checker.check(prev, next);
141	22	prev = next;
142		}
143		}
144	12	}
145
146		private interface PairwiseChecker<T> {
147		void check(T prev, T next);
148		}
149		}