1 /* 2 * Copyright (c) 2011, 2017, 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 24 /* 25 * @test 26 * @bug 4533691 7129185 27 * @summary Unit test for Collections.emptyNavigableSet 28 * @run testng EmptyNavigableSet 29 */ 30 31 import org.testng.Assert; 32 import org.testng.Assert.ThrowingRunnable; 33 import org.testng.annotations.DataProvider; 34 import org.testng.annotations.Test; 35 36 import java.math.BigInteger; 37 import java.util.Arrays; 38 import java.util.Collection; 39 import java.util.Collections; 40 import java.util.Comparator; 41 import java.util.Iterator; 42 import java.util.NavigableSet; 43 import java.util.NoSuchElementException; 44 import java.util.SortedSet; 45 import java.util.TreeSet; 46 47 import static org.testng.Assert.assertFalse; 48 import static org.testng.Assert.assertNull; 49 import static org.testng.Assert.assertSame; 50 import static org.testng.Assert.assertTrue; 51 52 public class EmptyNavigableSet { 53 assertInstance(T actual, Class<? extends T> expected)54 public static <T> void assertInstance(T actual, Class<? extends T> expected) { 55 assertInstance(actual, expected, null); 56 } 57 assertInstance(T actual, Class<? extends T> expected, String message)58 public static <T> void assertInstance(T actual, Class<? extends T> expected, String message) { 59 assertTrue(expected.isInstance(actual), ((null != message) ? message : "") 60 + " " + (actual == null ? "<null>" : actual.getClass().getSimpleName()) + " != " + expected.getSimpleName() + ". "); 61 } 62 assertEmptyNavigableSet(Object obj)63 public static <T extends Throwable> void assertEmptyNavigableSet(Object obj) { 64 assertInstance(obj, NavigableSet.class); 65 assertTrue(((NavigableSet)obj).isEmpty() && (((NavigableSet)obj).size() == 0)); 66 } 67 assertEmptyNavigableSet(Object obj, String message)68 public static <T extends Throwable> void assertEmptyNavigableSet(Object obj, String message) { 69 assertInstance(obj, NavigableSet.class, message); 70 assertTrue(((NavigableSet)obj).isEmpty() && (((NavigableSet)obj).size() == 0), 71 ((null != message) ? message : "") + " Not empty. "); 72 } 73 assertThrows(Class<T> throwableClass, ThrowingRunnable runnable, String message)74 private <T extends Throwable> void assertThrows(Class<T> throwableClass, 75 ThrowingRunnable runnable, 76 String message) { 77 try { 78 Assert.assertThrows(throwableClass, runnable); 79 } catch (AssertionError e) { 80 throw new AssertionError(String.format("%s%n%s", 81 ((null != message) ? message : ""), e.getMessage()), e); 82 } 83 } 84 assertThrowsCCE(ThrowingRunnable r, String s)85 private void assertThrowsCCE(ThrowingRunnable r, String s) { 86 assertThrows(ClassCastException.class, r, s); 87 } 88 assertThrowsNPE(ThrowingRunnable r, String s)89 private void assertThrowsNPE(ThrowingRunnable r, String s) { 90 assertThrows(NullPointerException.class, r, s); 91 } 92 assertThrowsIAE(ThrowingRunnable r, String s)93 private void assertThrowsIAE(ThrowingRunnable r, String s) { 94 assertThrows(IllegalArgumentException.class, r, s); 95 } 96 assertThrowsNSEE(ThrowingRunnable r, String s)97 private void assertThrowsNSEE(ThrowingRunnable r, String s) { 98 assertThrows(NoSuchElementException.class, r, s); 99 } 100 isDescending(SortedSet<?> set)101 public static final boolean isDescending(SortedSet<?> set) { 102 if (null == set.comparator()) { 103 // natural order 104 return false; 105 } 106 107 if (Collections.reverseOrder() == set.comparator()) { 108 // reverse natural order. 109 return true; 110 } 111 112 if (set.comparator().equals(Collections.reverseOrder(Collections.reverseOrder(set.comparator())))) { 113 // it's a Collections.reverseOrder(Comparator). 114 return true; 115 } 116 117 throw new IllegalStateException("can't determine ordering for " + set); 118 } 119 120 /** 121 * Tests that the comparator is {@code null}. 122 */ 123 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testComparatorIsNull(String description, NavigableSet<?> navigableSet)124 public void testComparatorIsNull(String description, NavigableSet<?> navigableSet) { 125 Comparator comparator = navigableSet.comparator(); 126 127 assertTrue(comparator == null || comparator == Collections.reverseOrder(), description + ": Comparator (" + comparator + ") is not null."); 128 } 129 130 /** 131 * Tests that contains requires Comparable 132 */ 133 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testContainsRequiresComparable(String description, NavigableSet<?> navigableSet)134 public void testContainsRequiresComparable(String description, NavigableSet<?> navigableSet) { 135 assertThrowsCCE( 136 () -> navigableSet.contains(new Object()), 137 description + ": Comparable should be required"); 138 } 139 140 /** 141 * Tests that the contains method returns {@code false}. 142 */ 143 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testContains(String description, NavigableSet<?> navigableSet)144 public void testContains(String description, NavigableSet<?> navigableSet) { 145 assertFalse(navigableSet.contains(new Integer(1)), 146 description + ": Should not contain any elements."); 147 } 148 149 /** 150 * Tests that the containsAll method returns {@code false}. 151 */ 152 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testContainsAll(String description, NavigableSet<?> navigableSet)153 public void testContainsAll(String description, NavigableSet<?> navigableSet) { 154 TreeSet treeSet = new TreeSet(); 155 treeSet.add("1"); 156 treeSet.add("2"); 157 treeSet.add("3"); 158 159 assertFalse(navigableSet.containsAll(treeSet), "Should not contain any elements."); 160 } 161 162 /** 163 * Tests that the iterator is empty. 164 */ 165 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testEmptyIterator(String description, NavigableSet<?> navigableSet)166 public void testEmptyIterator(String description, NavigableSet<?> navigableSet) { 167 assertFalse(navigableSet.iterator().hasNext(), "The iterator is not empty."); 168 } 169 170 /** 171 * Tests that the set is empty. 172 */ 173 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testIsEmpty(String description, NavigableSet<?> navigableSet)174 public void testIsEmpty(String description, NavigableSet<?> navigableSet) { 175 assertTrue(navigableSet.isEmpty(), "The set is not empty."); 176 } 177 178 /** 179 * Tests that the first() method throws NoSuchElementException 180 */ 181 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testFirst(String description, NavigableSet<?> navigableSet)182 public void testFirst(String description, NavigableSet<?> navigableSet) { 183 assertThrowsNSEE(navigableSet::first, description); 184 } 185 186 /** 187 * Tests the headSet() method. 188 */ 189 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testHeadSet(String description, NavigableSet navigableSet)190 public void testHeadSet(String description, NavigableSet navigableSet) { 191 assertThrowsNPE( 192 () -> { NavigableSet ns = navigableSet.headSet(null, false); }, 193 description + ": Must throw NullPointerException for null element"); 194 195 assertThrowsCCE( 196 () -> { NavigableSet ns = navigableSet.headSet(new Object(), true); }, 197 description + ": Must throw ClassCastException for non-Comparable element"); 198 199 NavigableSet ns = navigableSet.headSet("1", false); 200 201 assertEmptyNavigableSet(ns, description + ": Returned value is not empty navigable set."); 202 } 203 204 /** 205 * Tests that the last() method throws NoSuchElementException 206 */ 207 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testLast(String description, NavigableSet<?> navigableSet)208 public void testLast(String description, NavigableSet<?> navigableSet) { 209 assertThrowsNSEE(navigableSet::last, description); 210 } 211 212 /** 213 * Tests that the size is 0. 214 */ 215 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testSizeIsZero(String description, NavigableSet<?> navigableSet)216 public void testSizeIsZero(String description, NavigableSet<?> navigableSet) { 217 assertTrue(0 == navigableSet.size(), "The size of the set is not 0."); 218 } 219 220 /** 221 * Tests the subSet() method. 222 */ 223 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testSubSet(String description, NavigableSet navigableSet)224 public void testSubSet(String description, NavigableSet navigableSet) { 225 assertThrowsNPE( 226 () -> { 227 SortedSet ss = navigableSet.subSet(null, BigInteger.TEN); 228 }, 229 description + ": Must throw NullPointerException for null element"); 230 231 assertThrowsNPE( 232 () -> { 233 SortedSet ss = navigableSet.subSet(BigInteger.ZERO, null); 234 }, 235 description + ": Must throw NullPointerException for null element"); 236 237 assertThrowsNPE( 238 () -> { 239 SortedSet ss = navigableSet.subSet(null, null); 240 }, 241 description + ": Must throw NullPointerException for null element"); 242 243 Object obj1 = new Object(); 244 Object obj2 = new Object(); 245 246 assertThrowsCCE( 247 () -> { 248 SortedSet ss = navigableSet.subSet(obj1, BigInteger.TEN); 249 }, 250 description + ": Must throw ClassCastException for parameter which is not Comparable."); 251 252 assertThrowsCCE( 253 () -> { 254 SortedSet ss = navigableSet.subSet(BigInteger.ZERO, obj2); 255 }, 256 description + ": Must throw ClassCastException for parameter which is not Comparable."); 257 258 assertThrowsCCE( 259 () -> { 260 SortedSet ss = navigableSet.subSet(obj1, obj2); 261 }, 262 description + ": Must throw ClassCastException for parameter which is not Comparable."); 263 264 // minimal range 265 navigableSet.subSet(BigInteger.ZERO, false, BigInteger.ZERO, false); 266 navigableSet.subSet(BigInteger.ZERO, false, BigInteger.ZERO, true); 267 navigableSet.subSet(BigInteger.ZERO, true, BigInteger.ZERO, false); 268 navigableSet.subSet(BigInteger.ZERO, true, BigInteger.ZERO, true); 269 270 Object first = isDescending(navigableSet) ? BigInteger.TEN : BigInteger.ZERO; 271 Object last = (BigInteger.ZERO == first) ? BigInteger.TEN : BigInteger.ZERO; 272 273 assertThrowsIAE( 274 () -> navigableSet.subSet(last, true, first, false), 275 description 276 + ": Must throw IllegalArgumentException when fromElement is not less than toElement."); 277 278 navigableSet.subSet(first, true, last, false); 279 } 280 281 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testSubSetRanges(String description, NavigableSet navigableSet)282 public void testSubSetRanges(String description, NavigableSet navigableSet) { 283 Object first = isDescending(navigableSet) ? BigInteger.TEN : BigInteger.ZERO; 284 Object last = (BigInteger.ZERO == first) ? BigInteger.TEN : BigInteger.ZERO; 285 286 NavigableSet subSet = navigableSet.subSet(first, true, last, true); 287 288 // same subset 289 subSet.subSet(first, true, last, true); 290 291 // slightly smaller 292 NavigableSet ns = subSet.subSet(first, false, last, false); 293 // slight expansion 294 assertThrowsIAE( 295 () -> ns.subSet(first, true, last, true), 296 description + ": Expansion should not be allowed"); 297 298 // much smaller 299 subSet.subSet(first, false, BigInteger.ONE, false); 300 } 301 302 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testheadSetRanges(String description, NavigableSet navigableSet)303 public void testheadSetRanges(String description, NavigableSet navigableSet) { 304 NavigableSet subSet = navigableSet.headSet(BigInteger.ONE, true); 305 306 // same subset 307 subSet.headSet(BigInteger.ONE, true); 308 309 // slightly smaller 310 NavigableSet ns = subSet.headSet(BigInteger.ONE, false); 311 312 // slight expansion 313 assertThrowsIAE( 314 () -> ns.headSet(BigInteger.ONE, true), 315 description + ": Expansion should not be allowed"); 316 317 // much smaller 318 subSet.headSet(isDescending(subSet) ? BigInteger.TEN : BigInteger.ZERO, true); 319 } 320 321 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testTailSetRanges(String description, NavigableSet navigableSet)322 public void testTailSetRanges(String description, NavigableSet navigableSet) { 323 NavigableSet subSet = navigableSet.tailSet(BigInteger.ONE, true); 324 325 // same subset 326 subSet.tailSet(BigInteger.ONE, true); 327 328 // slightly smaller 329 NavigableSet ns = subSet.tailSet(BigInteger.ONE, false); 330 331 // slight expansion 332 assertThrowsIAE( 333 () -> ns.tailSet(BigInteger.ONE, true), 334 description + ": Expansion should not be allowed"); 335 336 // much smaller 337 subSet.tailSet(isDescending(subSet) ? BigInteger.ZERO : BigInteger.TEN, false); 338 } 339 340 /** 341 * Tests the tailSet() method. 342 */ 343 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testTailSet(String description, NavigableSet navigableSet)344 public void testTailSet(String description, NavigableSet navigableSet) { 345 assertThrowsNPE( 346 () -> navigableSet.tailSet(null), 347 description + ": Must throw NullPointerException for null element"); 348 349 assertThrowsCCE( 350 () -> navigableSet.tailSet(new Object()), 351 description); 352 353 NavigableSet ss = navigableSet.tailSet("1", true); 354 355 assertEmptyNavigableSet(ss, description + ": Returned value is not empty navigable set."); 356 } 357 358 /** 359 * Tests that the array has a size of 0. 360 */ 361 @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class) testToArray(String description, NavigableSet<?> navigableSet)362 public void testToArray(String description, NavigableSet<?> navigableSet) { 363 Object[] emptyNavigableSetArray = navigableSet.toArray(); 364 365 assertTrue(emptyNavigableSetArray.length == 0, "Returned non-empty Array."); 366 367 emptyNavigableSetArray = new Object[20]; 368 369 Object[] result = navigableSet.toArray(emptyNavigableSetArray); 370 371 assertSame(emptyNavigableSetArray, result); 372 373 assertNull(result[0]); 374 } 375 376 @DataProvider(name = "NavigableSet<?>", parallel = true) navigableSetsProvider()377 public static Iterator<Object[]> navigableSetsProvider() { 378 return makeNavigableSets().iterator(); 379 } 380 makeNavigableSets()381 public static Collection<Object[]> makeNavigableSets() { 382 return Arrays.asList( 383 new Object[]{"UnmodifiableNavigableSet(TreeSet)", Collections.unmodifiableNavigableSet(new TreeSet())}, 384 new Object[]{"UnmodifiableNavigableSet(TreeSet.descendingSet()", Collections.unmodifiableNavigableSet(new TreeSet().descendingSet())}, 385 new Object[]{"UnmodifiableNavigableSet(TreeSet.descendingSet().descendingSet()", Collections.unmodifiableNavigableSet(new TreeSet().descendingSet().descendingSet())}, 386 new Object[]{"emptyNavigableSet()", Collections.emptyNavigableSet()}, 387 new Object[]{"emptyNavigableSet().descendingSet()", Collections.emptyNavigableSet().descendingSet()}, 388 new Object[]{"emptyNavigableSet().descendingSet().descendingSet()", Collections.emptyNavigableSet().descendingSet().descendingSet()} 389 ); 390 } 391 } 392