Java tutorial
/* * 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(); }