/*
* Copyright 2008 Google Inc.
*
* 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 com.google.gwt.emultest.java.util;
import com.google.gwt.testing.TestUtils;
import org.apache.commons.collections.TestSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.NavigableSet;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
/**
* Tests <code>TreeSet</code>.
*
* @param <E> The key type for the underlying TreeSet
*
* TODO(jat): this whole structure needs work. Ideally we would port a new
* Apache collections test to GWT, but that is not an insignificant amount of
* work.
*/
public abstract class TreeSetTest<E extends Comparable<E>> extends TestSet {
/**
* Verify a Set is explicitly and implicitly empty.
*
* @param set
*/
private static <E> void _assertEmpty(Set<E> set) {
assertNotNull(set);
assertTrue(set.isEmpty());
assertEquals(0, set.size());
}
/**
* Verify that two Collections are deeply equivalent. Some of the Sets that
* need to be verified do not implement a sensible equals method
* (TreeSet.values for example).
*
* @param expected
* @param actual
*/
private static <T> void _assertEquals(Collection<T> expected,
Collection<T> actual) {
// verify equivalence using collection interface
assertEquals(expected.isEmpty(), actual.isEmpty());
assertEquals(expected.size(), actual.size());
assertTrue(expected.containsAll(actual));
assertTrue(actual.containsAll(expected));
for (T expectedValue : expected) {
assertTrue(actual.contains(expectedValue));
}
for (T actualValue : actual) {
assertTrue(expected.contains(actualValue));
}
}
/**
* Verify that two SortedMaps are deeply equivalent.
*
* @param expected
* @param actual
*/
private static <E> void _assertEquals(SortedSet<E> expected,
SortedSet<E> actual) {
_assertEquals((Set<E>) expected, (Set<E>) actual);
// verify the order of the associated collections
assertEquals(expected.toArray(), actual.toArray());
}
private static <E> Collection<E> asCollection(Iterator<E> it) {
List<E> list = new ArrayList<E>();
while (it.hasNext()) {
list.add(it.next());
}
return list;
}
private static <E> Collection<E> reverseCollection(Collection<E> c) {
List<E> reversedCollection = new ArrayList<E>(c);
Collections.reverse(reversedCollection);
return reversedCollection;
}
/**
* comparator used when creating the SortedSet.
*/
private Comparator<E> comparator = null;
private boolean isAddSupported = true;
private boolean isClearSupported = true;
private boolean isNullKeySupported = true;
private boolean isPutAllSupported = true;
private boolean isRemoveSupported = true;
public TreeSetTest() {
super("TreeSetTest");
}
@Override
public String getModuleName() {
return "com.google.gwt.emultest.EmulSuite";
}
/**
* Test method for 'java.util.Set.add(Object)'.
*
* @see java.util.Set#put(Object)
*/
public void testAdd() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isAddSupported) {
Set<E> set = createSet();
assertTrue(set.add(getKeys()[0]));
assertFalse(set.isEmpty());
assertEquals(1, set.size());
}
}
/**
* Test method for 'java.util.Set.add(Object)'.
*
* @see java.util.Set#add(Object)
*/
public void testAdd_entries3() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isAddSupported) {
// populate the set
Set<E> set = createSet();
set.add(getKeys()[0]);
set.add(getKeys()[1]);
set.add(getKeys()[2]);
// test contents
assertFalse(set.isEmpty());
assertEquals(3, set.size());
Collection<E> keys = set;
// test contains all keys
assertTrue(keys.contains(getKeys()[0]));
assertTrue(keys.contains(getKeys()[1]));
assertTrue(keys.contains(getKeys()[2]));
}
}
/**
* Test method for 'java.util.Set.add(Object)'.
*
* @see java.util.Set#add(Object)
*/
public void testAdd_replace() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isAddSupported) {
Set<E> set = createSet();
assertTrue(set.add(getKeys()[0]));
assertFalse(set.isEmpty());
assertEquals(1, set.size());
assertFalse(set.add(getKeys()[0]));
assertEquals(1, set.size());
}
}
/**
* Test method for 'java.util.Set.add(Object)'.
*
* @see java.util.Set#add(Object)
*/
@SuppressWarnings("unchecked")
public void testAdd_throwsClassCastException_key() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isAddSupported) {
Set<E> set = createSet();
set.add(getKeys()[0]);
try {
Set untypedSet = set;
untypedSet.add(getConflictingKey());
assertTrue("CCE expected in Development Mode", !TestUtils.isJvm());
} catch (ClassCastException e) {
// expected outcome
}
}
}
/**
* Test method for 'java.util.Set.add(Object)'.
*
* @see java.util.Set#add(Object)
*/
@SuppressWarnings("unchecked")
public void testAdd_throwsClassCastException_value() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isAddSupported) {
Set<E> set = createSet();
set.add(getKeys()[0]);
Set untypedSet = set;
untypedSet.add(getKeys()[1]);
// You might think this should throw an exception here but, no. Makes
// sense since the class cast is attributed to comparability of the
// keys... generics really have nothing to do with it .
}
}
/**
* Test method for 'java.util.Set.add(Object)'.
*
* @see java.util.Set#add(Object)
*/
public void testAdd_throwsUnsupportedOperationException() {
if (!isAddSupported) {
Set<E> set = createSet();
try {
set.add(getKeys()[0]);
fail("expected exception");
} catch (UnsupportedOperationException e) {
// expected outcome
}
}
}
/**
* Test method for 'java.util.Set.addAll(Map)'.
*
* @see java.util.Set#addAll(Map)
*/
public void testAddAll() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isPutAllSupported) {
Set<E> sourceSet = createSet();
sourceSet.add(getKeys()[0]);
sourceSet.add(getKeys()[1]);
sourceSet.add(getKeys()[2]);
Set<E> destSet = createSet();
destSet.addAll(sourceSet);
// Make sure that the data is copied correctly
_assertEquals(sourceSet, destSet);
}
}
/**
* Test method for 'java.util.Set.addAll(Map)'.
*
* @see java.util.Set#addAll(Map)
*/
public void testAddAll_addEntries() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isPutAllSupported) {
Set<E> sourceMap = createSet();
sourceMap.add(getKeys()[0]);
Set<E> destSet = createSet();
destSet.addAll(sourceMap);
// Verify that entries get added.
sourceMap.add(getKeys()[1]);
destSet.addAll(sourceMap);
_assertEquals(sourceMap, destSet);
}
}
/**
* Test method for 'java.util.Set.addAll(Map)'.
*
* @see java.util.Set#addAll(Map)
*/
public void testAddAll_emptyMap() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isPutAllSupported) {
Set<E> sourceSet = createSet();
sourceSet.add(getKeys()[0]);
Set<E> destSet = createSet();
destSet.addAll(sourceSet);
// Verify that putting an empty set does not clear.
destSet.addAll(createSet());
_assertEquals(sourceSet, destSet);
}
}
/**
* Test method for 'java.util.Set.addAll(Map)'.
*
* @see java.util.Set#addAll(Map)
*/
public void testAddAll_overwrite() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isPutAllSupported) {
Set<E> sourceSet = createSet();
sourceSet.add(getKeys()[0]);
Set<E> destSet = createSet();
destSet.addAll(sourceSet);
// Verify that entries get replaced.
sourceSet.add(getKeys()[0]);
destSet.addAll(sourceSet);
_assertEquals(sourceSet, destSet);
}
}
/**
* Test method for 'java.util.Set.addAll(Map)'.
*
* @see java.util.Set#addAll(Map)
*/
@SuppressWarnings("ModifyingCollectionWithItself")
public void testAddAll_self() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isPutAllSupported) {
Set<E> sourceSet = createSet();
sourceSet.add(getKeys()[0]);
sourceSet.addAll(sourceSet);
// verify putAll with self succeeds and has no effect.
assertEquals(1, sourceSet.size());
assertEquals(getKeys()[0], sourceSet.iterator().next());
}
}
/**
* Test method for 'java.util.Set.addAll(Map)'.
*
* @see java.util.Set#addAll(Map)
*/
@SuppressWarnings("unchecked")
public void testAddAll_throwsClassCastException() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isPutAllSupported) {
Set sourceSet = new HashSet();
sourceSet.add(getConflictingKey());
Set<E> destSet = createSet();
destSet.add(getKeys()[0]);
try {
// This throws in dev mode because we're putting a second entry in
// the set and TreeSet calls the compare method to order them.
destSet.addAll(sourceSet);
assertTrue("CCE expected in Development Mode", !TestUtils.isJvm());
} catch (ClassCastException e) {
// expected outcome
}
}
}
/**
* Test method for 'java.util.Set.addAll(Map)'.
*
* @see java.util.Set#addAll(Map)
*/
public void testAddAll_throwsNullPointerException() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isPutAllSupported) {
Set<E> set = createSet();
try {
set.addAll(null);
fail("expected exception");
} catch (NullPointerException e) {
// expected outcome
}
}
}
/**
* Test method for 'java.util.Set.addAll(Map)'.
*
* @see java.util.Set#addAll(Map)
*/
public void testAddAll_throwsUnsupportedOperationException() {
Set<E> set = createSet();
if (!isPutAllSupported) {
try {
set.addAll(createSet());
fail("expected exception");
} catch (UnsupportedOperationException e) {
// expected outcome
}
}
}
public void testCeiling() {
NavigableSet<E> set = createNavigableSet();
set.add(getKeys()[0]);
assertEquals(getKeys()[0], set.ceiling(getKeys()[0]));
assertEquals(getKeys()[0], set.ceiling(getLessThanMinimumKey()));
assertEquals(set.toArray()[0], set.ceiling(getLessThanMinimumKey()));
set.add(getKeys()[1]);
assertEquals(getKeys()[0], set.ceiling(getLessThanMinimumKey()));
assertEquals(getKeys()[0], set.ceiling(getKeys()[0]));
assertEquals(getKeys()[1], set.ceiling(getKeys()[1]));
assertEquals(null, set.ceiling(getGreaterThanMaximumKey()));
}
/**
* Test method for 'java.util.Set.clear()'.
*
* @see java.util.Set#clear()
*/
public void testClear() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isClearSupported) {
// Execute this test only if supported.
Set<E> set = createSet();
set.add(getKeys()[0]);
assertFalse(set.isEmpty());
set.clear();
_assertEmpty(set);
}
}
/**
* Test method for 'java.util.Set.clear()'.
*
* @see java.util.Set#clear()
*/
public void testClear_throwsUnsupportedOperationException() {
Set<E> set = createSet();
if (!isClearSupported) {
try {
set.clear();
fail("expected exception");
} catch (UnsupportedOperationException e) {
// expected outcome
}
}
}
/**
* Test method for 'java.util.SortedSet.comparator()'.
*
* @see java.util.SortedSet#comparator()
*/
public void testComparator() {
SortedSet<E> sortedSet = createNavigableSet();
if (isNaturalOrder()) {
assertEquals(null, sortedSet.comparator());
} else {
assertEquals(getComparator(), sortedSet.comparator());
}
}
/**
* Test method for default constructor.
*
* @see java.util.TreeSet#TreeSet()
*/
public void testConstructor() {
TreeSet<E> treeSet = new TreeSet<E>();
_assertEmpty(treeSet);
}
/**
* Test method for 'java.util.TreeSet.TreeSet(Comparator)'.
*
* @see java.util.TreeSet#TreeSet(Comparator)
*/
public void testConstructor_comparator() {
TreeSet<E> TreeSet = new TreeSet<E>(getComparator());
_assertEmpty(TreeSet);
if (isNaturalOrder()) {
assertNull(TreeSet.comparator());
} else {
assertSame(getComparator(), TreeSet.comparator());
}
}
/**
* Test method for 'java.util.TreeSet.TreeSet(Set)'.
*
* @see java.util.TreeSet#TreeSet(Set)
*/
public void testConstructor_Set() {
// The source set should be just a Map. Not a sorted set.
Set<E> sourceMap = new HashSet<E>();
// populate the source set
sourceMap.add(getKeys()[0]);
sourceMap.add(getKeys()[1]);
sourceMap.add(getKeys()[2]);
TreeSet<E> copyConstructed = new TreeSet<E>(sourceMap);
_assertEquals(sourceMap, copyConstructed);
}
/**
* Test method for 'java.util.TreeSet.TreeSet(Set)'.
*
* @see java.util.TreeSet#TreeSet(Set)
*/
@SuppressWarnings("unchecked")
public void testConstructor_Set_rawType() {
Set sourceSet = new HashSet();
sourceSet.add(getConflictingKey());
// Raw types can be used to defeat the type system, and this will work
// so long as the key is Comparable and there's only one entry (so compare()
// won't be called.)
new TreeSet<E>(sourceSet);
}
/**
* Test method for 'java.util.TreeSet.TreeSet(Set)'.
*
* @see java.util.TreeSet#TreeSet(Set)
*/
public void testConstructor_Set_throwsNullPointerException() {
try {
new TreeSet<E>((Set<E>) null);
fail("expected exception");
} catch (NullPointerException e) {
// expected outcome
}
}
/**
* Test method for 'java.util.TreeSet.TreeSet(SortedSet).
*
* @see java.util.TreeSet#TreeSet(SortedSet)
*/
public void testConstructor_SortedMap_throwsNullPointerException() {
try {
new TreeSet<E>((SortedSet<E>) null);
fail("expected exception");
} catch (NullPointerException e) {
// expected outcome
}
}
/**
* Test method for 'java.util.TreeSet.TreeSet(SortedSet)'.
*
* @see java.util.TreeSet#TreeSet(SortedSet)
*/
public void testConstructor_SortedSet() {
SortedSet<E> sourceMap = new TreeSet<E>();
_assertEmpty(sourceMap);
// populate the source set
sourceMap.add(getKeys()[0]);
sourceMap.add(getKeys()[1]);
sourceMap.add(getKeys()[2]);
TreeSet<E> copyConstructed = new TreeSet<E>(sourceMap);
_assertEquals(sourceMap, copyConstructed);
}
/**
* Test method for 'java.util.Set.contains(Object)'. *
*
* @see java.util.Set#contains(Object)
*/
public void testContains() {
Set<E> set = createSet();
assertFalse(set.contains(getKeys()[0]));
assertTrue(set.add(getKeys()[0]));
assertEquals(1, set.size());
assertTrue(set.contains(getKeys()[0]));
assertFalse(set.contains(getKeys()[1]));
}
/**
* Test method for 'java.util.Set.contains(Object)'.
*
* @see java.util.Set#contains(Object)
*/
public void testContains_throwsClassCastException() {
Set<E> set = createSet();
set.add(getKeys()[0]);
try {
set.contains(getConflictingKey());
assertTrue("CCE expected in Development Mode", !TestUtils.isJvm());
} catch (ClassCastException e) {
// expected outcome
}
}
/**
* Test method for 'java.util.Set.contains(Object)'.
*
* @see java.util.Set#contains(Object)
*/
public void testContains_throwsNullPointerException() {
Set<E> set = createSet();
if (isNaturalOrder() && !isNullKeySupported) {
try {
set.contains(null);
fail("expected exception");
} catch (NullPointerException e) {
// expected outcome
}
}
}
public void testDescendingIterator() {
NavigableSet<E> set = createNavigableSet();
set.add(getKeys()[0]);
Iterator<E> descendingIterator = set.descendingIterator();
_assertEquals(set, reverseCollection(asCollection(descendingIterator)));
set.add(getKeys()[1]);
set.add(getKeys()[2]);
descendingIterator = set.descendingIterator();
_assertEquals(set, reverseCollection(asCollection(descendingIterator)));
descendingIterator = set.descendingIterator();
while (descendingIterator.hasNext()) {
descendingIterator.next();
descendingIterator.remove();
}
assertEquals(0, set.size());
}
public void testDescendingSet() {
NavigableSet<E> set = createNavigableSet();
set.add(getKeys()[0]);
NavigableSet<E> descendingSet = set.descendingSet();
_assertEquals(descendingSet, descendingSet);
_assertEquals(set.descendingSet(), descendingSet);
set.add(getKeys()[1]);
set.add(getKeys()[2]);
_assertEquals(reverseCollection(set), descendingSet);
_assertEquals(set, descendingSet.descendingSet());
set.remove(getKeys()[1]);
_assertEquals(reverseCollection(set), descendingSet);
descendingSet.add(getKeys()[0]);
_assertEquals(reverseCollection(set), descendingSet);
descendingSet.remove(getKeys()[1]);
_assertEquals(reverseCollection(set), descendingSet);
descendingSet.clear();
assertEquals(0, descendingSet.size());
_assertEquals(set, descendingSet);
}
/**
* Test method for 'java.util.Object.equals(Object)'.
*
* @see java.util.Set#equals(Object)
*/
public void testEquals() {
Set<E> set0 = createSet();
Set<E> set1 = createSet();
assertTrue(set0.equals(set1));
set0.add(getKeys()[0]);
set1.add(getKeys()[0]);
assertTrue(set0.equals(set0));
assertTrue(set0.equals(set1));
set0.add(getKeys()[1]);
assertFalse(set0.equals(set1));
}
/**
* Test method for 'java.util.SortedSet.first()'.
*
* @see java.util.SortedSet#first()
*/
public void testFirst() {
SortedSet<E> sortedSet = createNavigableSet();
// test with a single entry set
sortedSet.add(getKeys()[0]);
assertEquals(getKeys()[0], sortedSet.first());
// is it consistent with other methods
assertEquals(sortedSet.toArray()[0], sortedSet.first());
assertEquals(getKeys()[0], sortedSet.last());
assertEquals(sortedSet.last(), sortedSet.first());
// test with two entry set
sortedSet.add(getKeys()[1]);
assertEquals(getKeys()[0], sortedSet.first());
assertFalse(getKeys()[1].equals(sortedSet.first()));
// is it consistent with other methods
assertEquals(sortedSet.toArray()[0], sortedSet.first());
assertFalse(getKeys()[0].equals(sortedSet.last()));
assertFalse(sortedSet.last().equals(sortedSet.first()));
}
/**
* Test method for 'java.util.SortedSet.first()'.
*
* @see java.util.SortedSet#first()
*/
public void testFirstKey_throwsNoSuchElementException() {
SortedSet<E> SortedSet = createNavigableSet();
// test with no entries
try {
SortedSet.first();
fail("expected exception");
} catch (NoSuchElementException e) {
// expected outcome
}
}
public void testFloor() {
NavigableSet<E> set = createNavigableSet();
set.add(getKeys()[0]);
assertEquals(null, set.floor(getLessThanMinimumKey()));
assertEquals(getKeys()[0], set.floor(getKeys()[0]));
assertEquals(getKeys()[0], set.floor(getKeys()[1]));
assertEquals(getKeys()[0], set.floor(getGreaterThanMaximumKey()));
assertEquals(set.toArray()[0], set.floor(getKeys()[1]));
set.add(getKeys()[1]);
assertEquals(null, set.floor(getLessThanMinimumKey()));
assertEquals(getKeys()[0], set.floor(getKeys()[0]));
assertEquals(getKeys()[1], set.floor(getKeys()[1]));
assertEquals(getKeys()[1], set.floor(getGreaterThanMaximumKey()));
}
/**
* Test method for 'java.lang.Object.hashCode()'.
*
* @see java.util.Set#hashCode()
*/
public void testHashCode() {
Set<E> set0 = createSet();
Set<E> set1 = createSet();
int hashCode0 = set0.hashCode();
int hashCode1 = set1.hashCode();
assertTrue("empty maps have different hash codes", hashCode0 == hashCode1);
// Check that hashCode changes
set0.add(getKeys()[0]);
hashCode0 = set0.hashCode();
assertTrue("hash code didn't change", hashCode0 != hashCode1);
Set<String> set2 = new TreeSet<String>();
set2.add("");
Set<Integer> set3 = new TreeSet<Integer>();
set3.add(0);
int hashCode2 = set2.hashCode();
int hashCode3 = set3.hashCode();
assertEquals("empty string/0 hash codes not the same", hashCode2, hashCode3);
}
/**
* Test method for 'java.util.SortedSet.headSet(Object, Object)'.
*
* @see java.util.SortedSet#headSet(Object)
*/
@SuppressWarnings("unchecked")
public void testHeadMap_throwsClassCastException() {
SortedSet SortedSet = createNavigableSet();
SortedSet.add(getKeys()[0]);
if (isNaturalOrder()) {
// TODO Why does this succeed with natural ordering when subSet doesn't?
SortedSet.headSet(getConflictingKey());
} else {
try {
SortedSet.headSet(getConflictingKey());
assertTrue("CCE expected in Development Mode", !TestUtils.isJvm());
} catch (ClassCastException e) {
// expected outcome
}
}
}
/**
* Test method for 'java.util.SortedSet.headSet(Object)' and
* 'java.util.NavigableSet.headSet(Object, boolean)'.
*
* @see java.util.SortedSet#headSet(Object)
* @see java.util.NavigableSet#headSet(Object, boolean)
*/
public void testHeadSet() {
// test with no entries
NavigableSet<E> set = createNavigableSet();
assertNotNull(set.headSet(getKeys()[0]));
assertNotNull(set.headSet(getKeys()[0], false));
assertNotNull(set.headSet(getKeys()[0], true));
}
/**
* Test method for 'java.util.SortedSet.headSet(Object)' and
* 'java.util.NavigableSet.headSet(Object, boolean)'.
*
* @see java.util.SortedSet#headSet(Object)
* @see java.util.NavigableSet#headSet(Object, boolean)
*/
public void testHeadSet_entries0_size() {
// test with no entries
NavigableSet<E> set = createNavigableSet();
assertEquals(0, set.headSet(getKeys()[0]).size());
assertEquals(0, set.headSet(getKeys()[0], false).size());
assertEquals(0, set.headSet(getKeys()[0], true).size());
}
/**
* Test method for 'java.util.SortedSet.headSet(Object)' and
* 'java.util.NavigableSet.headSet(Object, boolean)'.
*
* @see java.util.SortedSet#headSet(Object)
* @see java.util.NavigableSet#headSet(Object, boolean)
*/
public void testHeadSet_entries1() {
NavigableSet<E> set = createNavigableSet();
// test with a single entry set
set.add(getKeys()[0]);
assertEquals(0, set.headSet(getKeys()[0]).size());
assertEquals(0, set.headSet(getKeys()[0], false).size());
assertEquals(1, set.headSet(getKeys()[0], true).size());
}
/**
* Test method for 'java.util.SortedSet.headSet(Object)' and
* 'java.util.NavigableSet.headSet(Object, boolean)'.
*
* @see java.util.SortedSet#headSet(Object)
* @see java.util.NavigableSet#headSet(Object, boolean)
*/
public void testHeadSet_entries2() {
NavigableSet<E> set = createNavigableSet();
// test with two entry set
set.add(getKeys()[0]);
set.add(getKeys()[1]);
assertEquals(0, set.headSet(getKeys()[0]).size());
assertEquals(1, set.headSet(getKeys()[1]).size());
assertEquals(getKeys()[0], set.tailSet(getKeys()[0]).toArray()[0]);
assertEquals(0, set.headSet(getKeys()[0], false).size());
assertEquals(1, set.headSet(getKeys()[1], false).size());
assertEquals(getKeys()[0], set.headSet(getKeys()[0], true).toArray()[0]);
assertEquals(1, set.headSet(getKeys()[0], true).size());
assertEquals(2, set.headSet(getKeys()[1], true).size());
assertEquals(getKeys()[0], set.headSet(getKeys()[1], false).toArray()[0]);
assertEquals(getKeys()[1], set.headSet(getKeys()[1], true).toArray()[1]);
assertEquals(0, set.headSet(getKeys()[0], false).size());
assertEquals(getKeys()[1], set.headSet(getKeys()[1], true).toArray()[1]);
}
public void testHigher() {
NavigableSet<E> set = createNavigableSet();
set.add(getKeys()[0]);
assertEquals(null, set.higher(getKeys()[0]));
assertEquals(getKeys()[0], set.higher(getLessThanMinimumKey()));
assertEquals(set.toArray()[0], set.higher(getLessThanMinimumKey()));
set.add(getKeys()[1]);
assertEquals(getKeys()[0], set.higher(getLessThanMinimumKey()));
assertEquals(getKeys()[1], set.higher(getKeys()[0]));
assertEquals(null, set.higher(getKeys()[1]));
assertEquals(null, set.higher(getGreaterThanMaximumKey()));
}
/**
* Test method for 'java.util.Set.isEmpty()'. *
*
* @see java.util.Set#isEmpty()
*
*/
public void testIsEmpty() {
Set<E> sourceSet = createSet();
Set<E> destSet = createSet();
destSet.addAll(sourceSet);
assertTrue(destSet.isEmpty());
destSet.add(getKeys()[0]);
assertFalse(destSet.isEmpty());
destSet.remove(getKeys()[0]);
assertTrue(destSet.isEmpty());
assertEquals(destSet.size(), 0);
}
/**
* Test method for 'java.util.SortedSet.last()'.
*
* @see java.util.SortedSet#last()
*/
public void testLastKey() {
SortedSet<E> sortedSet = createNavigableSet();
// test with a single entry set
sortedSet.add(getKeys()[0]);
assertEquals(getKeys()[0], sortedSet.last());
// is it consistent with other methods
assertEquals(sortedSet.toArray()[0], sortedSet.last());
assertEquals(getKeys()[0], sortedSet.first());
assertEquals(sortedSet.first(), sortedSet.last());
// test with two entry set
sortedSet.add(getKeys()[1]);
assertEquals(getKeys()[1], sortedSet.last());
assertFalse(getKeys()[0].equals(sortedSet.last()));
// is it consistent with other methods
assertEquals(sortedSet.toArray()[1], sortedSet.last());
assertEquals(getKeys()[0], sortedSet.first());
assertFalse(sortedSet.first().equals(sortedSet.last()));
}
/**
* Test method for 'java.util.SortedSet.last()'.
*
* @see java.util.SortedSet#last()
*/
public void testLastKey_throwsNoSuchElementException() {
SortedSet<E> SortedSet = createNavigableSet();
// test with no entries
try {
SortedSet.last();
fail("expected exception");
} catch (NoSuchElementException e) {
// expected outcome
}
}
public void testLower() {
NavigableSet<E> set = createNavigableSet();
set.add(getKeys()[0]);
assertEquals(null, set.lower(getLessThanMinimumKey()));
assertEquals(null, set.lower(getKeys()[0]));
assertEquals(getKeys()[0], set.lower(getKeys()[1]));
assertEquals(getKeys()[0], set.lower(getGreaterThanMaximumKey()));
assertEquals(set.toArray()[0], set.lower(getKeys()[1]));
set.add(getKeys()[1]);
assertEquals(null, set.lower(getLessThanMinimumKey()));
assertEquals(null, set.lower(getKeys()[0]));
assertEquals(getKeys()[0], set.lower(getKeys()[1]));
assertEquals(getKeys()[1], set.lower(getGreaterThanMaximumKey()));
}
public void testPollFirst() {
NavigableSet<E> set = createNavigableSet();
assertNull(set.pollFirst());
assertEquals(0, set.size());
set.add(getKeys()[0]);
assertEquals(getKeys()[0], set.pollFirst());
assertEquals(0, set.size());
set.add(getKeys()[0]);
set.add(getKeys()[1]);
assertEquals(getKeys()[0], set.pollFirst());
assertEquals(1, set.size());
assertEquals(getKeys()[1], set.pollFirst());
assertEquals(0, set.size());
assertNull(set.pollFirst());
}
public void testPollLast() {
NavigableSet<E> set = createNavigableSet();
assertNull(set.pollLast());
assertEquals(0, set.size());
set.add(getKeys()[0]);
assertEquals(getKeys()[0], set.pollLast());
assertEquals(0, set.size());
set.add(getKeys()[0]);
set.add(getKeys()[1]);
assertEquals(getKeys()[1], set.pollLast());
assertEquals(1, set.size());
assertEquals(getKeys()[0], set.pollLast());
assertEquals(0, set.size());
assertNull(set.pollLast());
}
/**
* Test method for 'java.util.Set.remove(Object)'.
*
* @see java.util.Set#remove(Object)
*/
public void testRemove() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isRemoveSupported) {
Set<E> set = createSet();
assertFalse(set.remove(getKeys()[0]));
assertTrue(set.add(getKeys()[0]));
assertTrue(set.remove(getKeys()[0]));
assertFalse(set.remove(getKeys()[0]));
}
}
/**
* Test method for 'java.util.Set.remove(Object)'.
*
* @see java.util.Set#remove(Object)
*/
public void testRemove_throwsClassCastException() {
// The _throwsUnsupportedOperationException version of this test will
// verify that the method is not supported.
if (isRemoveSupported) {
Set<E> set = createSet();
set.add(getKeys()[0]);
try {
set.remove(getConflictingKey());
assertTrue("CCE expected in Development Mode", !TestUtils.isJvm());
} catch (ClassCastException e) {
// expected outcome
}
}
}
/**
* Test method for 'java.util.Set.remove(Object)'.
*
* @see java.util.Set#remove(Object)
*/
public void testRemove_throwsUnsupportedOperationException() {
Set<E> set = createSet();
if (!isRemoveSupported) {
try {
set.remove(getKeys()[0]);
fail("expected exception");
} catch (UnsupportedOperationException e) {
// expected outcome
}
}
}
/**
* Test method for 'java.util.Set.size()'.
*
* @see java.util.Set#size()
*/
public void testSize() {
Set<E> set = createSet();
// Test size behavior on add
set.add(getKeys()[0]);
assertEquals(1, set.size());
set.add(getKeys()[1]);
assertEquals(2, set.size());
set.add(getKeys()[2]);
assertEquals(3, set.size());
// Test size behavior on remove
set.remove(getKeys()[0]);
assertEquals(2, set.size());
set.remove(getKeys()[1]);
assertEquals(1, set.size());
set.remove(getKeys()[2]);
assertEquals(0, set.size());
// Test size behavior on putAll
set.add(getKeys()[0]);
set.add(getKeys()[1]);
set.add(getKeys()[2]);
assertEquals(3, set.size());
// Test size behavior on clear
set.clear();
_assertEmpty(set);
}
/**
* Test method for 'java.util.SortedSet.subSet(Object, Object)'.
*
* @see java.util.SortedSet#subSet(Object, Object)
*/
@SuppressWarnings("unchecked")
public void testSubMap_throwsClassCastException() {
SortedSet SortedSet = createNavigableSet();
SortedSet.add(getKeys()[0]);
try {
SortedSet.subSet(getConflictingKey(), getKeys()[0]);
assertTrue("CCE expected in Development Mode", !TestUtils.isJvm());
} catch (IllegalArgumentException e) {
// since we can't ensure CCEs in Production Mode, we may get IAE
assertTrue("IllegalArgumentException in Development Mode", !TestUtils.isJvm());
} catch (ClassCastException e) {
// expected outcome
}
try {
SortedSet.subSet(getKeys()[0], getConflictingKey());
assertTrue("CCE expected in Development Mode", !TestUtils.isJvm());
} catch (IllegalArgumentException e) {
// since we can't ensure CCEs in Production Mode, we may get IAE
assertTrue("IllegalArgumentException in Development Mode", !TestUtils.isJvm());
} catch (ClassCastException e) {
// expected outcome
}
}
/**
* Test method for 'java.util.SortedSet.subSet(Object, Object)'.
*
* @see java.util.SortedSet#subSet(Object, Object)
*/
public void testSubMap_throwsIllegalArgumentException() {
SortedSet<E> SortedSet = createNavigableSet();
try {
SortedSet.subSet(getGreaterThanMaximumKey(), getLessThanMinimumKey());
fail("expected exception");
} catch (IllegalArgumentException e) {
// from key is greater than the to key
// expected outcome
}
}
/**
* Test method for 'java.util.SortedSet.subSet(Object, Object)' and
* 'java.util.NavigableSet.subSet(Object, boolean, Object, boolean)'.
*
* @see java.util.SortedSet#subSet(Object, Object)
* @see java.util.NavigableSet#subSet(Object, boolean, Object, boolean)
*/
public void testSubSet() {
NavigableSet<E> sortedSet = createNavigableSet();
// test with no entries
assertEquals(0, sortedSet.subSet(getKeys()[0], getKeys()[0]).size());
assertEquals(0, sortedSet.subSet(getKeys()[0], false, getKeys()[0], false).size());
assertEquals(0, sortedSet.subSet(getKeys()[0], true, getKeys()[0], false).size());
assertEquals(0, sortedSet.subSet(getKeys()[0], false, getKeys()[0], true).size());
assertEquals(0, sortedSet.subSet(getKeys()[0], true, getKeys()[0], true).size());
// test with a single entry set
sortedSet.add(getKeys()[0]);
assertEquals(0, sortedSet.subSet(getKeys()[0], getKeys()[0]).size());
// bounded by a "wide" range
assertEquals(1, sortedSet.subSet(getLessThanMinimumKey(),
getGreaterThanMaximumKey()).size());
assertEquals(1, sortedSet.subSet(getLessThanMinimumKey(), false,
getGreaterThanMaximumKey(), false).size());
assertEquals(1, sortedSet.subSet(getLessThanMinimumKey(), true,
getGreaterThanMaximumKey(), false).size());
assertEquals(1, sortedSet.subSet(getLessThanMinimumKey(), false,
getGreaterThanMaximumKey(), true).size());
assertEquals(1, sortedSet.subSet(getLessThanMinimumKey(), true,
getGreaterThanMaximumKey(), true).size());
// test with two entry set
sortedSet.add(getKeys()[1]);
assertEquals(1, sortedSet.subSet(getKeys()[0], getKeys()[1]).size());
assertEquals(getKeys()[0],
sortedSet.subSet(getKeys()[0], getKeys()[1]).toArray()[0]);
assertEquals(0, sortedSet.subSet(getKeys()[0], false, getKeys()[1], false).size());
assertEquals(1, sortedSet.subSet(getKeys()[0], false, getKeys()[1], true).size());
assertEquals(getKeys()[1], sortedSet.subSet(getKeys()[0], false,
getKeys()[1], true).toArray()[0]);
assertEquals(1, sortedSet.subSet(getKeys()[0], true, getKeys()[1], false).size());
assertEquals(getKeys()[0], sortedSet.subSet(getKeys()[0], true,
getKeys()[1], false).toArray()[0]);
assertEquals(2, sortedSet.subSet(getKeys()[0], true, getKeys()[1], true).size());
assertEquals(getKeys()[0], sortedSet.subSet(getKeys()[0], true,
getKeys()[1], true).toArray()[0]);
assertEquals(getKeys()[1], sortedSet.subSet(getKeys()[0], true,
getKeys()[1], true).toArray()[1]);
// bounded by a "wide" range
SortedSet<E> subSet = sortedSet.subSet(getLessThanMinimumKey(),
getGreaterThanMaximumKey());
assertEquals(2, subSet.size());
assertEquals(2, sortedSet.subSet(getLessThanMinimumKey(), false,
getGreaterThanMaximumKey(), false).size());
assertEquals(1, sortedSet.subSet(getKeys()[0], false,
getGreaterThanMaximumKey(), false).size());
assertEquals(0, sortedSet.subSet(getKeys()[0], false,
getKeys()[1], false).size());
assertEquals(2, sortedSet.subSet(getKeys()[0], true,
getGreaterThanMaximumKey(), false).size());
assertEquals(1, sortedSet.subSet(getKeys()[0], true,
getKeys()[1], false).size());
assertEquals(2, sortedSet.subSet(getKeys()[0], true,
getGreaterThanMaximumKey(), true).size());
assertEquals(2, sortedSet.subSet(getKeys()[0], true,
getKeys()[1], true).size());
}
/**
* Test method for 'java.util.SortedSet.tailSet(Object)' and
* '@see java.util.NavigableSet.tailSet(Object, boolean)'.
*
* @see java.util.SortedSet#tailSet(Object)
* @see java.util.NavigableSet#tailSet(Object, boolean)
*/
public void testTailSet_entries0() {
// test with no entries
NavigableSet<E> navigableSet = createNavigableSet();
assertNotNull(navigableSet.tailSet(getKeys()[0]));
assertNotNull(navigableSet.tailSet(getKeys()[0], false));
assertNotNull(navigableSet.tailSet(getKeys()[0], true));
}
/**
* Test method for 'java.util.SortedSet.tailSet(Object)' and
* '@see java.util.NavigableSet.tailSet(Object, boolean)'.
*
* @see java.util.SortedSet#tailSet(Object)
* @see java.util.NavigableSet#tailSet(Object, boolean)
*/
public void testTailSet_entries0_size() {
// test with no entries
NavigableSet<E> navigableSet = createNavigableSet();
Set<E> tailSet = navigableSet.tailSet(getKeys()[0]);
assertNotNull(tailSet);
assertEquals(0, tailSet.size());
Set<E> exclusiveTailSet = navigableSet.tailSet(getKeys()[0], false);
assertNotNull(exclusiveTailSet);
assertEquals(0, exclusiveTailSet.size());
Set<E> inclusiveTailSet = navigableSet.tailSet(getKeys()[0], true);
assertNotNull(inclusiveTailSet);
assertEquals(0, inclusiveTailSet.size());
}
/**
* Test method for 'java.util.SortedSet.tailSet(Object)' and
* '@see java.util.NavigableSet.tailSet(Object, boolean)'.
*
* @see java.util.SortedSet#tailSet(Object)
* @see java.util.NavigableSet#tailSet(Object, boolean)
*/
public void testTailSet_entries1_size_keyValue() {
NavigableSet<E> sortedSet = createNavigableSet();
// test with a single entry set
sortedSet.add(getKeys()[0]);
Set<E> tailSet = sortedSet.tailSet(getKeys()[0]);
assertEquals(1, tailSet.size());
assertEquals(getKeys()[0], tailSet.toArray()[0]);
Set<E> exclusiveTailSet = sortedSet.tailSet(getKeys()[0], false);
assertEquals(0, exclusiveTailSet.size());
assertEquals(0, exclusiveTailSet.size());
Set<E> inclusiveTailSet = sortedSet.tailSet(getKeys()[0], true);
assertEquals(1, inclusiveTailSet.size());
assertEquals(getKeys()[0], inclusiveTailSet.toArray()[0]);
}
/**
* Test method for 'java.util.SortedSet.tailSet(Object)' and
* '@see java.util.NavigableSet.tailSet(Object, boolean)'.
*
* @see java.util.SortedSet#tailSet(Object)
* @see java.util.NavigableSet#tailSet(Object, boolean)
*/
public void testTailSet_entries2_size_keyValue() {
NavigableSet<E> sortedSet = createNavigableSet();
// test with two entry set
sortedSet.add(getKeys()[0]);
Set<E> tailSet = sortedSet.tailSet(getKeys()[0]);
assertEquals(1, tailSet.size());
Set<E> exclusiveTailMap = sortedSet.tailSet(getKeys()[0], false);
assertEquals(0, exclusiveTailMap.size());
Set<E> inclusiveTailMap = sortedSet.tailSet(getKeys()[0], true);
assertEquals(1, inclusiveTailMap.size());
sortedSet.add(getKeys()[1]);
tailSet = sortedSet.tailSet(getKeys()[1]);
assertEquals(1, tailSet.size());
exclusiveTailMap = sortedSet.tailSet(getKeys()[1], false);
assertEquals(0, exclusiveTailMap.size());
inclusiveTailMap = sortedSet.tailSet(getKeys()[1], true);
assertEquals(1, inclusiveTailMap.size());
tailSet = sortedSet.tailSet(getKeys()[0]);
assertEquals(2, tailSet.size());
assertEquals(getKeys()[0], tailSet.toArray()[0]);
assertEquals(getKeys()[1], tailSet.toArray()[1]);
exclusiveTailMap = sortedSet.tailSet(getKeys()[0], false);
assertEquals(1, exclusiveTailMap.size());
assertEquals(getKeys()[1], exclusiveTailMap.toArray()[0]);
inclusiveTailMap = sortedSet.tailSet(getKeys()[0], true);
assertEquals(2, inclusiveTailMap.size());
assertEquals(getKeys()[0], inclusiveTailMap.toArray()[0]);
assertEquals(getKeys()[1], inclusiveTailMap.toArray()[1]);
}
/**
* Test method for 'java.util.SortedSet.tailSet(Object, Object)'.
*
* @see java.util.SortedSet#tailSet(Object)
*/
@SuppressWarnings("unchecked")
public void testTailSet_throwsClassCastException() {
SortedSet SortedSet = createNavigableSet();
SortedSet.add(getKeys()[0]);
if (isNaturalOrder()) {
// TODO Why does this succeed with natural ordering when subSet doesn't?
SortedSet.tailSet(getConflictingKey());
} else {
try {
SortedSet.tailSet(getConflictingKey());
assertTrue("CCE expected in Development Mode", !TestUtils.isJvm());
} catch (ClassCastException e) {
// expected outcome
}
}
}
/**
* Test method for 'java.util.SortedSet.tailSet(Object, Object)'.
*
* @see java.util.SortedSet#tailSet(Object)
*/
public void testTailSet_throwsIllegalArgumentException() {
// TODO I don't know of any case where this could happen.
}
protected Comparator<E> getComparator() {
return comparator;
}
protected abstract Object getConflictingKey();
protected abstract Object getConflictingValue();
@Override
protected Object[] getFullElements() {
return getKeys();
}
@Override
protected Object[] getOtherElements() {
return getKeys2();
}
@Override
protected void gwtSetUp() throws Exception {
setComparator(null);
}
protected boolean isNaturalOrder() {
return comparator == null;
}
@SuppressWarnings("unchecked")
@Override
protected Set makeEmptySet() {
return createTreeSet();
}
protected void setComparator(Comparator<E> comparator) {
this.comparator = comparator;
}
NavigableSet<E> createNavigableSet() {
return createTreeSet();
}
Set<E> createSet() {
return createNavigableSet();
}
TreeSet<E> createTreeSet() {
if (isNaturalOrder()) {
return new TreeSet<E>();
} else {
return new TreeSet<E>(getComparator());
}
}
abstract E getGreaterThanMaximumKey();
abstract E[] getKeys();
abstract E[] getKeys2();
abstract E getLessThanMinimumKey();
}