test/java/util/Collections/EmptyNavigableSet.java
Print this page
rev 7291 : 7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Reviewed-by: dmocek, martin
@@ -1,7 +1,7 @@
/*
- * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
@@ -21,331 +21,396 @@
* questions.
*/
/*
* @test
- * @bug 4533691
- * @summary Unit test for Collections.emptySortedSet
+ * @bug 4533691 7129185
+ * @summary Unit test for Collections.emptyNavigableSet
+ * @run testng EmptyNavigableSet
*/
-
-import java.lang.reflect.Method;
import java.math.BigInteger;
+import java.util.Arrays;
+import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NoSuchElementException;
+import java.util.NavigableSet;
import java.util.SortedSet;
import java.util.TreeSet;
+import org.testng.annotations.Test;
+import org.testng.annotations.DataProvider;
-public class EmptySortedSet {
- static int status = 0;
- private static final String FAILED = " failed. ";
- private static final String PERIOD = ".";
- private final String thisClassName = this.getClass().getName();
+import static org.testng.Assert.fail;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertSame;
- public static void main(String[] args) throws Exception {
- new EmptySortedSet();
- }
+public class EmptyNavigableSet {
- public EmptySortedSet() throws Exception {
- run();
+ public static <T> void assertInstance(T actual, Class<? extends T> expected) {
+ assertInstance(expected.isInstance(actual), null);
}
- /**
- * Returns {@code true} if the {@link Object} passed in is an empty
- * {@link SortedSet}.
- *
- * @param obj the object to test
- * @return {@code true} if the {@link Object} is an empty {@link SortedSet}
- * otherwise {@code false}.
- */
- private boolean isEmptySortedSet(Object obj) {
- boolean isEmptySortedSet = false;
-
- // We determine if the object is an empty sorted set by testing if it's
- // an instance of SortedSet, and if so, if it's empty. Currently the
- // testing doesn't include checks of the other methods.
- if (obj instanceof SortedSet) {
- SortedSet ss = (SortedSet) obj;
-
- if ((ss.isEmpty()) && (ss.size() == 0)) {
- isEmptySortedSet = true;
+ public static <T> void assertInstance(T actual, Class<? extends T> expected, String message) {
+ assertTrue(expected.isInstance(actual), ((null != message) ? message : "")
+ + " " + (actual == null ? "<null>" : actual.getClass().getSimpleName()) + " != " + expected.getSimpleName() + ". ");
}
+
+ public static <T extends Throwable> void assertEmptyNavigableSet(Object obj) {
+ assertInstance(obj, NavigableSet.class);
+ assertTrue(((NavigableSet)obj).isEmpty() && (((NavigableSet)obj).size() == 0));
}
- return isEmptySortedSet;
+ public static <T extends Throwable> void assertEmptyNavigableSet(Object obj, String message) {
+ assertInstance(obj, NavigableSet.class, message);
+ assertTrue(((NavigableSet)obj).isEmpty() && (((NavigableSet)obj).size() == 0),
+ ((null != message) ? message : "") + " Not empty. ");
}
- private void run() throws Exception {
- Method[] methods = this.getClass().getDeclaredMethods();
+ public interface Thrower<T extends Throwable> {
- for (int i = 0; i < methods.length; i++) {
- Method method = methods[i];
- String methodName = method.getName();
+ public void run() throws T;
+ }
- if (methodName.startsWith("test")) {
+ public static <T extends Throwable> void assertThrows(Thrower<T> thrower, Class<T> throwable) {
+ assertThrows(thrower, throwable, null);
+ }
+
+ public static <T extends Throwable> void assertThrows(Thrower<T> thrower, Class<T> throwable, String message) {
+ Throwable result;
try {
- Object obj = method.invoke(this, new Object[0]);
- } catch(Exception e) {
- throw new Exception(this.getClass().getName() + "." +
- methodName + " test failed, test exception "
- + "follows\n" + e.getCause());
+ thrower.run();
+ fail(((null != message) ? message : "") + "Failed to throw " + throwable.getCanonicalName() + ". ");
+ return;
+ } catch (Throwable caught) {
+ result = caught;
}
+
+ assertInstance(result, throwable, ((null != message) ? message : "") + "Failed to throw " + throwable.getCanonicalName() + ". ");
}
+
+ public static final boolean isDescending(SortedSet<?> set) {
+ if (null == set.comparator()) {
+ // natural order
+ return false;
}
+
+ if (Collections.reverseOrder() == set.comparator()) {
+ // reverse natural order.
+ return true;
}
- private void throwException(String methodName, String reason)
- throws Exception
- {
- StringBuilder sb = new StringBuilder(thisClassName);
- sb.append(PERIOD);
- sb.append(methodName);
- sb.append(FAILED);
- sb.append(reason);
- throw new Exception(sb.toString());
+ if (set.comparator().equals(Collections.reverseOrder(Collections.reverseOrder(set.comparator())))) {
+ // it's a Collections.reverseOrder(Comparator).
+ return true;
}
- /**
- *
- */
- private void test00() throws Exception {
- //throwException("test00", "This test has not been implemented yet.");
+ throw new IllegalStateException("can't determine ordering for " + set);
}
/**
* Tests that the comparator is {@code null}.
*/
- private void testComparatorIsNull() throws Exception {
- SortedSet sortedSet = Collections.emptySortedSet();
- Comparator comparator = sortedSet.comparator();
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testComparatorIsNull(String description, NavigableSet<?> navigableSet) {
+ Comparator comparator = navigableSet.comparator();
- if (comparator != null) {
- throwException("testComparatorIsNull", "Comparator is not null.");
+ assertTrue(comparator == null || comparator == Collections.reverseOrder(), description + ": Comparator (" + comparator + ") is not null.");
}
+
+ /**
+ * Tests that contains requires Comparable
+ */
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testContainsRequiresComparable(String description, NavigableSet<?> navigableSet) {
+ assertThrows(() -> {
+ navigableSet.contains(new Object());
+ },
+ ClassCastException.class,
+ description + ": Compareable should be required");
}
/**
* Tests that the contains method returns {@code false}.
*/
- private void testContains() throws Exception {
- SortedSet sortedSet = Collections.emptySortedSet();
-
- if (sortedSet.contains(new Object())) {
- throwException("testContains", "Should not contain any elements.");
- }
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testContains(String description, NavigableSet<?> navigableSet) {
+ assertFalse(navigableSet.contains(new Integer(1)),
+ description + ": Should not contain any elements.");
}
/**
* Tests that the containsAll method returns {@code false}.
*/
- private void testContainsAll() throws Exception {
- SortedSet sortedSet = Collections.emptySortedSet();
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testContainsAll(String description, NavigableSet<?> navigableSet) {
TreeSet treeSet = new TreeSet();
treeSet.add("1");
treeSet.add("2");
treeSet.add("3");
- if (sortedSet.containsAll(treeSet)) {
- throwException("testContainsAll",
- "Should not contain any elements.");
- }
+ assertFalse(navigableSet.containsAll(treeSet), "Should not contain any elements.");
}
/**
* Tests that the iterator is empty.
*/
- private void testEmptyIterator() throws Exception {
- SortedSet sortedSet = Collections.emptySortedSet();
- Iterator emptyIterator = sortedSet.iterator();
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testEmptyIterator(String description, NavigableSet<?> navigableSet) {
+ Iterator emptyIterator = navigableSet.iterator();
- if ((emptyIterator != null) && (emptyIterator.hasNext())) {
- throwException("testEmptyIterator", "The iterator is not empty.");
- }
+ assertFalse((emptyIterator != null) && (emptyIterator.hasNext()),
+ "The iterator is not empty.");
}
/**
* Tests that the set is empty.
*/
- private void testIsEmpty() throws Exception {
- SortedSet sortedSet = Collections.emptySortedSet();
-
- if ((sortedSet != null) && (!sortedSet.isEmpty())) {
- throwException("testSizeIsZero", "The set is not empty.");
- }
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testIsEmpty(String description, NavigableSet<?> navigableSet) {
+ assertTrue(navigableSet.isEmpty(), "The set is not empty.");
}
/**
* Tests that the first() method throws NoSuchElementException
*/
- private void testFirst() throws Exception {
- SortedSet sortedSet = Collections.emptySortedSet();
-
- try {
- sortedSet.first();
- throwException("testFirst",
- "NoSuchElemenException was not thrown.");
- } catch(NoSuchElementException nsee) {
- // Do nothing
- }
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testFirst(String description, NavigableSet<?> navigableSet) {
+ assertThrows(() -> {
+ navigableSet.first();
+ }, NoSuchElementException.class, description);
}
/**
* Tests the headSet() method.
*/
- private void testHeadSet() throws Exception {
- SortedSet sortedSet = Collections.emptySortedSet();
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testHeadSet(String description, NavigableSet navigableSet) {
SortedSet ss;
try {
- ss = sortedSet.headSet(null);
- throwException("testHeadSet",
- "Must throw NullPointerException for null element");
- } catch(NullPointerException npe) {
+ ss = navigableSet.headSet(null);
+ fail(description + ": Must throw NullPointerException for null element");
+ } catch (NullPointerException npe) {
// Do nothing
}
try {
- ss = sortedSet.headSet(new Object());
- throwException("testHeadSet",
- "Must throw ClassCastException for non-Comparable element");
- } catch(ClassCastException cce) {
+ ss = navigableSet.headSet(new Object());
+ fail(description + ": Must throw ClassCastException for non-Comparable element");
+ } catch (ClassCastException cce) {
// Do nothing.
}
- ss = sortedSet.headSet("1");
+ ss = navigableSet.headSet("1", false);
- if ((ss == null) || !isEmptySortedSet(ss)) {
- throwException("testHeadSet",
- "Returned value is null or not an EmptySortedSet.");
- }
+ assertEmptyNavigableSet(ss, description + ": Returned value is not empty navigable set.");
}
/**
* Tests that the last() method throws NoSuchElementException
*/
- private void testLast() throws Exception {
- SortedSet sortedSet = Collections.emptySortedSet();
-
- try {
- sortedSet.last();
- throwException("testLast",
- "NoSuchElemenException was not thrown.");
- } catch(NoSuchElementException nsee) {
- // Do nothing
- }
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testLast(String description, NavigableSet<?> navigableSet) {
+ assertThrows(() -> {
+ navigableSet.last();
+ }, NoSuchElementException.class, description);
}
/**
* Tests that the size is 0.
*/
- private void testSizeIsZero() throws Exception {
- SortedSet sortedSet = Collections.emptySortedSet();
- int size = sortedSet.size();
-
- if (size > 0) {
- throwException("testSizeIsZero",
- "The size of the set is greater then 0.");
- }
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testSizeIsZero(String description, NavigableSet<?> navigableSet) {
+ assertTrue(0 == navigableSet.size(), "The size of the set is not 0.");
}
/**
* Tests the subSet() method.
*/
- private void testSubSet() throws Exception {
- SortedSet sortedSet = Collections.emptySortedSet();
- SortedSet ss = sortedSet.headSet("1");
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testSubSet(String description, NavigableSet navigableSet) {
+ assertThrows(
+ () -> {
+ SortedSet ss = navigableSet.subSet(null, BigInteger.TEN);
+ },
+ NullPointerException.class,
+ description + ": Must throw NullPointerException for null element");
+
+ assertThrows(
+ () -> {
+ SortedSet ss = navigableSet.subSet(BigInteger.ZERO, null);
+ },
+ NullPointerException.class,
+ description + ": Must throw NullPointerException for null element");
+
+ assertThrows(
+ () -> {
+ SortedSet ss = navigableSet.subSet(null, null);
+ },
+ NullPointerException.class,
+ description + ": Must throw NullPointerException for null element");
- try {
- ss = sortedSet.subSet(null, BigInteger.TEN);
- ss = sortedSet.subSet(BigInteger.ZERO, null);
- ss = sortedSet.subSet(null, null);
- throwException("testSubSet",
- "Must throw NullPointerException for null element");
- } catch(NullPointerException npe) {
- // Do nothing
- }
-
- try {
Object obj1 = new Object();
Object obj2 = new Object();
- ss = sortedSet.subSet(obj1, BigInteger.TEN);
- ss = sortedSet.subSet(BigInteger.ZERO, obj2);
- ss = sortedSet.subSet(obj1, obj2);
- throwException("testSubSet",
- "Must throw ClassCastException for parameter which is "
- + "not Comparable.");
- } catch(ClassCastException cce) {
- // Do nothing.
- }
-
- try {
- ss = sortedSet.subSet(BigInteger.ZERO, BigInteger.ZERO);
- ss = sortedSet.subSet(BigInteger.TEN, BigInteger.ZERO);
- throwException("testSubSet",
- "Must throw IllegalArgumentException when fromElement is "
- + "not less then then toElement.");
- } catch(IllegalArgumentException iae) {
- // Do nothing.
- }
- ss = sortedSet.subSet(BigInteger.ZERO, BigInteger.TEN);
+ assertThrows(
+ () -> {
+ SortedSet ss = navigableSet.subSet(obj1, BigInteger.TEN);
+ },
+ ClassCastException.class, description
+ + ": Must throw ClassCastException for parameter which is not Comparable.");
+
+ assertThrows(
+ () -> {
+ SortedSet ss = navigableSet.subSet(BigInteger.ZERO, obj2);
+ },
+ ClassCastException.class, description
+ + ": Must throw ClassCastException for parameter which is not Comparable.");
+
+ assertThrows(
+ () -> {
+ SortedSet ss = navigableSet.subSet(obj1, obj2);
+ },
+ ClassCastException.class, description
+ + ": Must throw ClassCastException for parameter which is not Comparable.");
+
+ // minimal range
+ navigableSet.subSet(BigInteger.ZERO, false, BigInteger.ZERO, false);
+ navigableSet.subSet(BigInteger.ZERO, false, BigInteger.ZERO, true);
+ navigableSet.subSet(BigInteger.ZERO, true, BigInteger.ZERO, false);
+ navigableSet.subSet(BigInteger.ZERO, true, BigInteger.ZERO, true);
+
+ Object first = isDescending(navigableSet) ? BigInteger.TEN : BigInteger.ZERO;
+ Object last = (BigInteger.ZERO == first) ? BigInteger.TEN : BigInteger.ZERO;
+
+ assertThrows(
+ () -> {
+ navigableSet.subSet(last, true, first, false);
+ },
+ IllegalArgumentException.class, description
+ + ": Must throw IllegalArgumentException when fromElement is not less then then toElement.");
+
+ navigableSet.subSet(first, true, last, false);
+ }
+
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testSubSetRanges(String description, NavigableSet navigableSet) {
+ Object first = isDescending(navigableSet) ? BigInteger.TEN : BigInteger.ZERO;
+ Object last = (BigInteger.ZERO == first) ? BigInteger.TEN : BigInteger.ZERO;
+
+ NavigableSet subSet = navigableSet.subSet(first, true, last, true);
+
+ // same subset
+ subSet.subSet(first, true, last, true);
+
+ // slightly smaller
+ NavigableSet ns = subSet.subSet(first, false, last, false);
+ // slight exapansion
+ assertThrows(() -> {
+ ns.subSet(first, true, last, true);
+ },
+ IllegalArgumentException.class,
+ description + ": Expansion should not be allowed");
+
+ // much smaller
+ subSet.subSet(first, false, BigInteger.ONE, false);
+ }
+
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testheadSetRanges(String description, NavigableSet navigableSet) {
+ NavigableSet subSet = navigableSet.headSet(BigInteger.ONE, true);
+
+ // same subset
+ subSet.headSet(BigInteger.ONE, true);
+
+ // slightly smaller
+ NavigableSet ns = subSet.headSet(BigInteger.ONE, false);
+
+ // slight exapansion
+ assertThrows(() -> {
+ ns.headSet(BigInteger.ONE, true);
+ },
+ IllegalArgumentException.class,
+ description + ": Expansion should not be allowed");
+
+ // much smaller
+ subSet.headSet(isDescending(subSet) ? BigInteger.TEN : BigInteger.ZERO, true);
+ }
+
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testTailSetRanges(String description, NavigableSet navigableSet) {
+ NavigableSet subSet = navigableSet.tailSet(BigInteger.ONE, true);
+
+ // same subset
+ subSet.tailSet(BigInteger.ONE, true);
+
+ // slightly smaller
+ NavigableSet ns = subSet.tailSet(BigInteger.ONE, false);
+
+ // slight exapansion
+ assertThrows(() -> {
+ ns.tailSet(BigInteger.ONE, true);
+ },
+ IllegalArgumentException.class,
+ description + ": Expansion should not be allowed");
- if (!isEmptySortedSet(ss)) {
- throw new Exception("Returned value is not empty sorted set.");
- }
+ // much smaller
+ subSet.tailSet(isDescending(subSet) ? BigInteger.ZERO : BigInteger.TEN, false);
}
/**
* Tests the tailSet() method.
*/
- private void testTailSet() throws Exception {
- SortedSet sortedSet = Collections.emptySortedSet();
- SortedSet ss;
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testTailSet(String description, NavigableSet navigableSet) {
+ assertThrows(() -> {
+ navigableSet.tailSet(null);
+ },
+ NullPointerException.class,
+ description + ": Must throw NullPointerException for null element");
+
+ assertThrows(() -> {
+ navigableSet.tailSet(new Object());
+ }, ClassCastException.class);
- try {
- ss = sortedSet.tailSet(null);
- throwException("testTailSet",
- "Must throw NullPointerException for null element");
- } catch(NullPointerException npe) {
- // Do nothing
- }
-
- try {
- SortedSet ss2 = sortedSet.tailSet(new Object());
- throwException("testTailSet",
- "Must throw ClassCastException for non-Comparable element");
- } catch(ClassCastException cce) {
- // Do nothing.
- }
+ NavigableSet ss = navigableSet.tailSet("1", true);
- ss = sortedSet.tailSet("1");
-
- if ((ss == null) || !isEmptySortedSet(ss)) {
- throwException("testTailSet",
- "Returned value is null or not an EmptySortedSet.");
- }
+ assertEmptyNavigableSet(ss, description + ": Returned value is not empty navigable set.");
}
/**
* Tests that the array has a size of 0.
*/
- private void testToArray() throws Exception {
- SortedSet sortedSet = Collections.emptySortedSet();
- Object[] emptySortedSetArray = sortedSet.toArray();
-
- if ((emptySortedSetArray == null) || (emptySortedSetArray.length > 0)) {
- throwException("testToArray",
- "Returned null array or array with length > 0.");
- }
-
- String[] strings = new String[2];
- strings[0] = "1";
- strings[1] = "2";
- emptySortedSetArray = sortedSet.toArray(strings);
-
- if ((emptySortedSetArray == null) || (emptySortedSetArray[0] != null)) {
- throwException("testToArray",
- "Returned null array or array with length > 0.");
+ @Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
+ public void testToArray(String description, NavigableSet<?> navigableSet) {
+ Object[] emptyNavigableSetArray = navigableSet.toArray();
+
+ assertTrue(emptyNavigableSetArray.length == 0, "Returned non-empty Array.");
+
+ emptyNavigableSetArray = new Object[20];
+
+ Object[] result = navigableSet.toArray(emptyNavigableSetArray);
+
+ assertSame(emptyNavigableSetArray, result);
+
+ assertTrue(result[0] == null);
+ }
+
+ @DataProvider(name = "NavigableSet<?>", parallel = true)
+ public static Iterator<Object[]> navigableSetsProvider() {
+ return makeNavigableSets().iterator();
}
+
+ public static Collection<Object[]> makeNavigableSets() {
+ return Arrays.asList(
+ new Object[]{"UnmodifiableNavigableSet(TreeSet)", Collections.unmodifiableNavigableSet(new TreeSet())},
+ new Object[]{"UnmodifiableNavigableSet(TreeSet.descendingSet()", Collections.unmodifiableNavigableSet(new TreeSet().descendingSet())},
+ new Object[]{"UnmodifiableNavigableSet(TreeSet.descendingSet().descendingSet()", Collections.unmodifiableNavigableSet(new TreeSet().descendingSet().descendingSet())},
+ new Object[]{"emptyNavigableSet()", Collections.emptyNavigableSet()},
+ new Object[]{"emptyNavigableSet().descendingSet()", Collections.emptyNavigableSet().descendingSet()},
+ new Object[]{"emptyNavigableSet().descendingSet().descendingSet()", Collections.emptyNavigableSet().descendingSet().descendingSet()}
+ );
}
}