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