CollectionAsserts.java revision 9330:8b1f1c2a400f
1/* 2 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24import java.util.ArrayList; 25import java.util.Arrays; 26import java.util.Collections; 27import java.util.Comparator; 28import java.util.HashSet; 29import java.util.Iterator; 30import java.util.List; 31import java.util.Objects; 32import java.util.Set; 33 34import static org.testng.Assert.assertEquals; 35import static org.testng.Assert.assertTrue; 36import static org.testng.Assert.fail; 37 38/** 39 * @library 40 * CollectionAssert -- assertion methods for lambda test cases 41 */ 42public class CollectionAsserts { 43 44 private CollectionAsserts() { 45 // no instances 46 } 47 48 public static void assertCountSum(Iterable<? super Integer> it, int count, int sum) { 49 assertCountSum(it.iterator(), count, sum); 50 } 51 52 public static void assertCountSum(Iterator<? super Integer> it, int count, int sum) { 53 int c = 0; 54 int s = 0; 55 while (it.hasNext()) { 56 int i = (Integer) it.next(); 57 c++; 58 s += i; 59 } 60 61 assertEquals(c, count); 62 assertEquals(s, sum); 63 } 64 65 public static void assertConcat(Iterator<Character> it, String result) { 66 StringBuilder sb = new StringBuilder(); 67 while (it.hasNext()) { 68 sb.append(it.next()); 69 } 70 71 assertEquals(result, sb.toString()); 72 } 73 74 public static<T extends Comparable<? super T>> void assertSorted(Iterator<T> i) { 75 if (!i.hasNext()) 76 return; 77 T last = i.next(); 78 while (i.hasNext()) { 79 T t = i.next(); 80 assertTrue(last.compareTo(t) <= 0); 81 assertTrue(t.compareTo(last) >= 0); 82 last = t; 83 } 84 } 85 86 public static<T> void assertSorted(Iterator<T> i, Comparator<? super T> comp) { 87 if (!i.hasNext()) 88 return; 89 T last = i.next(); 90 while (i.hasNext()) { 91 T t = i.next(); 92 assertTrue(comp.compare(last, t) <= 0); 93 assertTrue(comp.compare(t, last) >= 0); 94 last = t; 95 } 96 } 97 98 public static<T extends Comparable<? super T>> void assertSorted(Iterable<T> iter) { 99 assertSorted(iter.iterator()); 100 } 101 102 public static<T> void assertSorted(Iterable<T> iter, Comparator<? super T> comp) { 103 assertSorted(iter.iterator(), comp); 104 } 105 106 public static <T> void assertUnique(Iterable<T> iter) { 107 assertUnique(iter.iterator()); 108 } 109 110 public static<T> void assertUnique(Iterator<T> iter) { 111 if (!iter.hasNext()) { 112 return; 113 } 114 115 Set<T> uniq = new HashSet<>(); 116 while(iter.hasNext()) { 117 T each = iter.next(); 118 assertTrue(!uniq.contains(each)); 119 uniq.add(each); 120 } 121 } 122 123 public static<T> void assertContents(Iterable<T> actual, Iterable<T> expected) { 124 assertContents(actual, expected, null); 125 } 126 127 public static<T> void assertContents(Iterable<T> actual, Iterable<T> expected, String msg) { 128 assertContents(actual.iterator(), expected.iterator(), msg); 129 } 130 131 public static<T> void assertContents(Iterator<T> actual, Iterator<T> expected) { 132 assertContents(actual, expected, null); 133 } 134 135 public static<T> void assertContents(Iterator<T> actual, Iterator<T> expected, String msg) { 136 List<T> history = new ArrayList<>(); 137 138 while (expected.hasNext()) { 139 if (!actual.hasNext()) { 140 List<T> expectedData = new ArrayList<>(history); 141 while (expected.hasNext()) 142 expectedData.add(expected.next()); 143 fail(String.format("%s Premature end of data; expected=%s, found=%s", 144 (msg == null ? "" : msg), expectedData, history)); 145 } 146 T a = actual.next(); 147 T e = expected.next(); 148 history.add(a); 149 150 if (!Objects.equals(a, e)) 151 fail(String.format("%s Data mismatch; preceding=%s, nextExpected=%s, nextFound=%s", 152 (msg == null ? "" : msg), history, e, a)); 153 } 154 if (actual.hasNext()) { 155 List<T> rest = new ArrayList<>(); 156 while (actual.hasNext()) 157 rest.add(actual.next()); 158 fail(String.format("%s Unexpected data %s after %s", 159 (msg == null ? "" : msg), rest, history)); 160 } 161 } 162 163 @SafeVarargs 164 @SuppressWarnings("varargs") 165 public static<T> void assertContents(Iterator<T> actual, T... expected) { 166 assertContents(actual, Arrays.asList(expected).iterator()); 167 } 168 169 public static<T extends Comparable<? super T>> void assertContentsUnordered(Iterable<T> actual, Iterable<T> expected) { 170 assertContentsUnordered(actual, expected, null); 171 } 172 173 public static<T extends Comparable<? super T>> void assertContentsUnordered(Iterable<T> actual, Iterable<T> expected, String msg) { 174 List<T> allExpected = new ArrayList<>(); 175 for (T t : expected) { 176 allExpected.add(t); 177 } 178 179 for (T t : actual) { 180 assertTrue(allExpected.remove(t), msg + " element '" + String.valueOf(t) + "' not found"); 181 } 182 183 assertTrue(allExpected.isEmpty(), msg + "expected contained additional elements"); 184 } 185 186 static <T> void assertSplitContents(Iterable<Iterable<T>> splits, Iterable<T> list) { 187 Iterator<Iterable<T>> mI = splits.iterator(); 188 Iterator<T> pI = null; 189 Iterator<T> lI = list.iterator(); 190 191 while (lI.hasNext()) { 192 if (pI == null) 193 pI = mI.next().iterator(); 194 while (!pI.hasNext()) { 195 if (!mI.hasNext()) { 196 break; 197 } 198 else { 199 pI = mI.next().iterator(); 200 } 201 } 202 assertTrue(pI.hasNext()); 203 T pT = pI.next(); 204 T lT = lI.next(); 205 assertEquals(pT, lT); 206 } 207 208 if (pI != null) { 209 assertTrue(!pI.hasNext()); 210 } 211 212 while(mI.hasNext()) { 213 pI = mI.next().iterator(); 214 assertTrue(!pI.hasNext()); 215 } 216 } 217} 218