Move apache originated testing helpers into emultest
...format them properly and make them pass the style checks.
PiperOrigin-RevId: 339796285
Change-Id: I307b790c12e792dff92817af872a474f309f8262
diff --git a/user/test/com/google/gwt/emultest/EmulSuite.gwt.xml b/user/test/com/google/gwt/emultest/EmulSuite.gwt.xml
index 151b673..550ef4b 100644
--- a/user/test/com/google/gwt/emultest/EmulSuite.gwt.xml
+++ b/user/test/com/google/gwt/emultest/EmulSuite.gwt.xml
@@ -15,7 +15,6 @@
<module>
<inherits name='com.google.gwt.junit.JUnit' />
<inherits name='com.google.gwt.testing.TestUtils' />
- <inherits name='org.apache.commons.Collections' />
<source path='java' />
<source path='java8' />
diff --git a/user/test/org/apache/commons/collections/AbstractTestListIterator.java b/user/test/com/google/gwt/emultest/java/util/AbstractTestListIterator.java
similarity index 86%
rename from user/test/org/apache/commons/collections/AbstractTestListIterator.java
rename to user/test/com/google/gwt/emultest/java/util/AbstractTestListIterator.java
index 7f61132..2fde145 100755
--- a/user/test/org/apache/commons/collections/AbstractTestListIterator.java
+++ b/user/test/com/google/gwt/emultest/java/util/AbstractTestListIterator.java
@@ -1,3 +1,4 @@
+// CHECKSTYLE_OFF: Copyrighted to ASF
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with this
@@ -5,18 +6,19 @@
* licenses this file to You 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.
- *
- * THIS CODE HAS BEEN EXTENSIVELY HACKED BY GOOGLE TO WORK WITH GWT.
+ *
+ * THIS CODE HAS BEEN EXTENSIVELY HACKED BY GOOGLE TO WORK WITH GWT.
*/
-package org.apache.commons.collections;
+// CHECKSTYLE_ON
+package com.google.gwt.emultest.java.util;
import java.util.ArrayList;
import java.util.Iterator;
@@ -25,40 +27,32 @@
/**
* Abstract class for testing the ListIterator interface.
- * <p>
- * This class provides a framework for testing an implementation of
- * ListIterator. Concrete subclasses must provide the list iterator to be
- * tested. They must also specify certain details of how the list iterator
- * operates by overriding the supportsXxx() methods if necessary.
- *
- * @since Commons Collections 3.0
- * @version $Revision$ $Date$
- *
- * @author Rodney Waldhoff
- * @author Stephen Colebourne
+ *
+ * <p>This class provides a framework for testing an implementation of ListIterator. Concrete
+ * subclasses must provide the list iterator to be tested. They must also specify certain details of
+ * how the list iterator operates by overriding the supportsXxx() methods if necessary.
*/
@SuppressWarnings({"unchecked", "rawtypes"})
-public abstract class AbstractTestListIterator extends TestIterator {
+abstract class AbstractTestListIterator extends TestIterator {
// -----------------------------------------------------------------------
/**
* Implement this method to return a list iterator over an empty collection.
- *
+ *
* @return an empty iterator
*/
public abstract ListIterator makeEmptyListIterator();
/**
- * Implement this method to return a list iterator over a collection with
- * elements.
- *
+ * Implement this method to return a list iterator over a collection with elements.
+ *
* @return a full iterator
*/
public abstract ListIterator makeFullListIterator();
/**
* Implements the abstract superclass method to return the list iterator.
- *
+ *
* @return an empty iterator
*/
@Override
@@ -68,7 +62,7 @@
/**
* Implements the abstract superclass method to return the list iterator.
- *
+ *
* @return a full iterator
*/
@Override
@@ -77,9 +71,8 @@
}
/**
- * Whether or not we are testing an iterator that supports add(). Default is
- * true.
- *
+ * Whether or not we are testing an iterator that supports add(). Default is true.
+ *
* @return true if Iterator supports add
*/
public boolean supportsAdd() {
@@ -87,26 +80,21 @@
}
/**
- * Whether or not we are testing an iterator that supports set(). Default is
- * true.
- *
+ * Whether or not we are testing an iterator that supports set(). Default is true.
+ *
* @return true if Iterator supports set
*/
public boolean supportsSet() {
return true;
}
- /**
- * The value to be used in the add and set tests. Default is null.
- */
+ /** The value to be used in the add and set tests. Default is null. */
public Object addSetValue() {
return null;
}
// -----------------------------------------------------------------------
- /**
- * Test that the empty list iterator contract is correct.
- */
+ /** Test that the empty list iterator contract is correct. */
public void testEmptyListIteratorIsIndeedEmpty() {
if (supportsEmptyIterator() == false) {
return;
@@ -134,9 +122,7 @@
}
}
- /**
- * Test navigation through the iterator.
- */
+ /** Test navigation through the iterator. */
public void testWalkForwardAndBack() {
ArrayList list = new ArrayList();
ListIterator it = makeFullListIterator();
@@ -172,9 +158,7 @@
}
}
- /**
- * Test add behaviour.
- */
+ /** Test add behaviour. */
public void testAdd() {
ListIterator it = makeFullListIterator();
@@ -209,9 +193,7 @@
}
}
- /**
- * Test set behaviour.
- */
+ /** Test set behaviour. */
public void testSet() {
ListIterator it = makeFullListIterator();
@@ -237,7 +219,6 @@
// repeated set calls should be fine
it.set(addSetValue());
-
}
public void testRemoveThenSet() {
@@ -267,9 +248,7 @@
}
}
- /**
- * Test remove after add behaviour.
- */
+ /** Test remove after add behaviour. */
public void testAddThenRemove() {
ListIterator it = makeFullListIterator();
@@ -284,5 +263,4 @@
}
}
}
-
}
diff --git a/user/test/com/google/gwt/emultest/java/util/ArrayDequeTest.java b/user/test/com/google/gwt/emultest/java/util/ArrayDequeTest.java
index 988523f..be4db76 100644
--- a/user/test/com/google/gwt/emultest/java/util/ArrayDequeTest.java
+++ b/user/test/com/google/gwt/emultest/java/util/ArrayDequeTest.java
@@ -18,11 +18,7 @@
import static java.util.Arrays.asList;
import com.google.gwt.core.client.JavaScriptException;
-
import com.google.gwt.testing.TestUtils;
-
-import org.apache.commons.collections.TestCollection;
-
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
@@ -31,9 +27,7 @@
import java.util.Iterator;
import java.util.NoSuchElementException;
-/**
- * Tests ArrayDeque class.
- */
+/** Tests ArrayDeque class. */
public class ArrayDequeTest extends TestCollection {
public void testAdd() throws Exception {
@@ -52,7 +46,8 @@
try {
deque.add(null);
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
}
public void testAddAll() throws Exception {
@@ -67,7 +62,8 @@
deque = new ArrayDeque<>();
deque.addAll(asList(o1, null, o2));
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
}
public void testAddFirst() {
@@ -86,7 +82,8 @@
try {
deque.addFirst(null);
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
}
public void testAddLast() {
@@ -105,7 +102,8 @@
try {
deque.addLast(null);
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
}
public void testConstructorFromCollection() {
@@ -122,7 +120,8 @@
try {
new ArrayDeque<>(asList(new Object(), null, new Object()));
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
Collection<Object> collection = new ArrayList<>(asList(getFullNonNullElements()));
checkDequeSizeAndContent(new ArrayDeque<>(collection), getFullNonNullElements());
@@ -163,7 +162,8 @@
try {
it.next();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
deque.add(o1);
deque.add(o2);
@@ -179,7 +179,8 @@
try {
it.next();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
checkDequeSizeAndContent(deque, o1, o2, o3);
deque = new ArrayDeque<>();
@@ -207,7 +208,8 @@
try {
deque.element();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
deque.add(o1);
assertEquals(o1, deque.element());
@@ -222,7 +224,8 @@
try {
deque.element();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
}
public void testFailFastIterator() {
@@ -241,7 +244,8 @@
if (TestUtils.getJdkVersion() < 11) {
fail();
}
- } catch (ConcurrentModificationException expected) { }
+ } catch (ConcurrentModificationException expected) {
+ }
deque = new ArrayDeque<>(asList(getFullNonNullElements()));
it = deque.iterator();
@@ -250,7 +254,8 @@
try {
it.next();
fail();
- } catch (ConcurrentModificationException expected) { }
+ } catch (ConcurrentModificationException expected) {
+ }
deque = new ArrayDeque<>(asList(getFullNonNullElements()));
it = deque.iterator();
@@ -267,7 +272,8 @@
if (TestUtils.getJdkVersion() < 11) {
fail();
}
- } catch (ConcurrentModificationException expected) { }
+ } catch (ConcurrentModificationException expected) {
+ }
deque = new ArrayDeque<>(asList(getFullNonNullElements()));
it = deque.iterator();
@@ -291,7 +297,8 @@
if (TestUtils.getJdkVersion() < 11) {
fail();
}
- } catch (ConcurrentModificationException expected) { }
+ } catch (ConcurrentModificationException expected) {
+ }
}
public void testFailFastDescendingIterator() {
@@ -310,7 +317,8 @@
if (TestUtils.getJdkVersion() < 11) {
fail();
}
- } catch (ConcurrentModificationException expected) { }
+ } catch (ConcurrentModificationException expected) {
+ }
deque = new ArrayDeque<>(asList(getFullNonNullElements()));
it = deque.descendingIterator();
@@ -319,7 +327,8 @@
try {
it.next();
fail();
- } catch (ConcurrentModificationException expected) { }
+ } catch (ConcurrentModificationException expected) {
+ }
deque = new ArrayDeque<>(asList(getFullNonNullElements()));
it = deque.descendingIterator();
@@ -336,7 +345,8 @@
try {
it.next();
fail();
- } catch (ConcurrentModificationException expected) { }
+ } catch (ConcurrentModificationException expected) {
+ }
deque = new ArrayDeque<>(asList(getFullNonNullElements()));
it = deque.descendingIterator();
@@ -360,7 +370,8 @@
if (TestUtils.getJdkVersion() < 11) {
fail();
}
- } catch (ConcurrentModificationException expected) { }
+ } catch (ConcurrentModificationException expected) {
+ }
}
public void testGetFirst() {
@@ -371,7 +382,8 @@
try {
deque.getFirst();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
deque.add(o1);
assertEquals(o1, deque.getFirst());
@@ -386,7 +398,8 @@
try {
deque.getFirst();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
}
public void testGetLast() {
@@ -397,7 +410,8 @@
try {
deque.getLast();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
deque.add(o1);
assertEquals(o1, deque.getLast());
@@ -412,7 +426,8 @@
try {
deque.getLast();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
}
public void testOffer() {
@@ -431,7 +446,8 @@
try {
deque.offer(null);
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
}
public void testOfferFirst() {
@@ -450,7 +466,8 @@
try {
deque.offerFirst(null);
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
}
public void testOfferLast() {
@@ -469,7 +486,8 @@
try {
deque.offerLast(null);
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
}
public void testPeek() {
@@ -619,7 +637,8 @@
try {
deque.pop();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
deque.add(o1);
assertEquals(o1, deque.pop());
@@ -634,7 +653,8 @@
try {
deque.pop();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
}
public void testPush() {
@@ -653,7 +673,8 @@
try {
deque.push(null);
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
}
public void testRemove() {
@@ -664,7 +685,8 @@
try {
deque.remove();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
deque.add(o1);
assertEquals(o1, deque.remove());
@@ -680,7 +702,8 @@
try {
deque.remove();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
}
public void testRemoveElement() {
@@ -712,7 +735,8 @@
try {
deque.removeFirst();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
deque.add(o1);
assertEquals(o1, deque.removeFirst());
@@ -728,7 +752,8 @@
try {
deque.removeFirst();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
}
public void testRemoveFirstOccurrence() {
@@ -778,7 +803,8 @@
try {
deque.removeLast();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
deque.add(o1);
assertEquals(o1, deque.removeLast());
@@ -794,7 +820,8 @@
try {
deque.removeLast();
fail();
- } catch (NoSuchElementException expected) { }
+ } catch (NoSuchElementException expected) {
+ }
}
public void testRemoveLastOccurrence() {
@@ -858,9 +885,7 @@
assertTrue(deque.isEmpty());
}
- /**
- * Null elements are prohibited in ArrayDeque.
- */
+ /** Null elements are prohibited in ArrayDeque. */
@Override
protected Object[] getFullElements() {
return getFullNonNullElements();
diff --git a/user/test/com/google/gwt/emultest/java/util/ComparatorTest.java b/user/test/com/google/gwt/emultest/java/util/ComparatorTest.java
index 5ed1eec..0bfc0ed 100644
--- a/user/test/com/google/gwt/emultest/java/util/ComparatorTest.java
+++ b/user/test/com/google/gwt/emultest/java/util/ComparatorTest.java
@@ -1,12 +1,12 @@
/*
* Copyright 2007 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
@@ -15,15 +15,11 @@
*/
package com.google.gwt.emultest.java.util;
-import org.apache.commons.collections.TestComparator;
-
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
-/**
- * TODO: document me.
- */
+/** TODO: document me. */
public class ComparatorTest extends TestComparator {
@Override
public Comparator<Object> makeComparator() {
@@ -40,13 +36,9 @@
}
}
-/**
- * List comparator for testing.
- */
+/** List comparator for testing. */
class DummyComparator implements Comparator<Object> {
- /**
- * Compares returns reverse hash order.
- */
+ /** Compares returns reverse hash order. */
@Override
public int compare(Object arg0, Object arg1) {
int a = arg0.hashCode();
@@ -61,4 +53,4 @@
}
return accum;
}
-}
\ No newline at end of file
+}
diff --git a/user/test/com/google/gwt/emultest/java/util/DefaultMapEntry.java b/user/test/com/google/gwt/emultest/java/util/DefaultMapEntry.java
new file mode 100644
index 0000000..96a3717
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/util/DefaultMapEntry.java
@@ -0,0 +1,116 @@
+// CHECKSTYLE_OFF: Copyrighted to ASF
+/*
+ * Copyright 1999-2004 The Apache Software Foundation
+ *
+ * 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.
+ */
+// CHECKSTYLE_ON
+package com.google.gwt.emultest.java.util;
+
+import java.util.Map;
+
+/** A default implementation of {@link java.util.Map.Entry} */
+@SuppressWarnings("rawtypes")
+class DefaultMapEntry implements Map.Entry {
+
+ private Object key;
+ private Object value;
+
+ /** Constructs a new <Code>DefaultMapEntry</Code> with a null key and null value. */
+ public DefaultMapEntry() {}
+
+ /**
+ * Constructs a new <Code>DefaultMapEntry</Code> with the given key and given value.
+ *
+ * @param key the key for the entry, may be null
+ * @param value the value for the entyr, may be null
+ */
+ public DefaultMapEntry(Object key, Object value) {
+ this.key = key;
+ this.value = value;
+ }
+
+ /** Implemented per API documentation of {@link java.util.Map.Entry#equals(Object)} */
+ @Override
+ public boolean equals(Object o) {
+ if (o == null) {
+ return false;
+ }
+ if (o == this) {
+ return true;
+ }
+
+ if (!(o instanceof Map.Entry)) {
+ return false;
+ }
+ Map.Entry e2 = (Map.Entry) o;
+ return ((getKey() == null ? e2.getKey() == null : getKey().equals(e2.getKey()))
+ && (getValue() == null ? e2.getValue() == null : getValue().equals(e2.getValue())));
+ }
+
+ /** Implemented per API documentation of {@link java.util.Map.Entry#hashCode()} */
+ @Override
+ public int hashCode() {
+ return ((getKey() == null ? 0 : getKey().hashCode())
+ ^ (getValue() == null ? 0 : getValue().hashCode()));
+ }
+
+ // Map.Entry interface
+ // -------------------------------------------------------------------------
+
+ /**
+ * Returns the key.
+ *
+ * @return the key
+ */
+ @Override
+ public Object getKey() {
+ return key;
+ }
+
+ /**
+ * Returns the value.
+ *
+ * @return the value
+ */
+ @Override
+ public Object getValue() {
+ return value;
+ }
+
+ // Properties
+ // -------------------------------------------------------------------------
+
+ /**
+ * Sets the key. This method does not modify any map.
+ *
+ * @param key the new key
+ */
+ public void setKey(Object key) {
+ this.key = key;
+ }
+
+ /**
+ * Note that this method only sets the local reference inside this object and does not modify the
+ * original Map.
+ *
+ * @return the old value of the value
+ * @param value the new value
+ */
+ @Override
+ public Object setValue(Object value) {
+ Object previous = this.value;
+ this.value = value;
+ return previous;
+ }
+}
diff --git a/user/test/com/google/gwt/emultest/java/util/HashMapTest.java b/user/test/com/google/gwt/emultest/java/util/HashMapTest.java
index 466aea8..d47398c 100644
--- a/user/test/com/google/gwt/emultest/java/util/HashMapTest.java
+++ b/user/test/com/google/gwt/emultest/java/util/HashMapTest.java
@@ -15,8 +15,6 @@
*/
package com.google.gwt.emultest.java.util;
-import org.apache.commons.collections.TestMap;
-
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
@@ -27,9 +25,7 @@
import java.util.NoSuchElementException;
import java.util.Set;
-/**
- * Tests <code>HashMap</code>.
- */
+/** Tests <code>HashMap</code>. */
public class HashMapTest extends TestMap {
private static final int CAPACITY_16 = 16;
private static final int CAPACITY_NEG_ONE_HALF = -1;
@@ -58,12 +54,13 @@
private static final float LOAD_FACTOR_ONE_HALF = 0.5F;
private static final float LOAD_FACTOR_ONE_TENTH = 0.1F;
private static final float LOAD_FACTOR_ZERO = 0.0F;
- private static final Object ODD_ZERO_KEY = new Object() {
- @Override
- public int hashCode() {
- return 0;
- }
- };
+ private static final Object ODD_ZERO_KEY =
+ new Object() {
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+ };
private static final String ODD_ZERO_VALUE = "odd zero";
private static final int SIZE_ONE = 1;
private static final int SIZE_THREE = 3;
@@ -77,13 +74,10 @@
private static final String VALUE_4 = "val4";
private static final String VALUE_TEST_CONTAINS_DOES_NOT_EXIST = "does not exist";
private static final Integer VALUE_TEST_CONTAINS_KEY = new Integer(5);
- private static final String VALUE_TEST_ENTRY_SET_1 = KEY_TEST_ENTRY_SET
- + " - value1";
- private static final String VALUE_TEST_ENTRY_SET_2 = KEY_TEST_ENTRY_SET
- + " - value2";
+ private static final String VALUE_TEST_ENTRY_SET_1 = KEY_TEST_ENTRY_SET + " - value1";
+ private static final String VALUE_TEST_ENTRY_SET_2 = KEY_TEST_ENTRY_SET + " - value2";
private static final String VALUE_TEST_GET = KEY_TEST_GET + " - Value";
- private static final String VALUE_TEST_KEY_SET = KEY_TEST_KEY_SET
- + " - value";
+ private static final String VALUE_TEST_KEY_SET = KEY_TEST_KEY_SET + " - value";
private static final String VALUE_TEST_PUT_1 = KEY_TEST_PUT + " - value 1";
private static final String VALUE_TEST_PUT_2 = KEY_TEST_PUT + " - value 2";
private static final String VALUE_TEST_REMOVE = KEY_TEST_REMOVE + " - value";
@@ -215,11 +209,10 @@
HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
checkEmptyHashMapAssumptions(hashMap);
- assertFalse("check contains of empty map",
- hashMap.containsValue(VALUE_TEST_CONTAINS_KEY));
+ assertFalse("check contains of empty map", hashMap.containsValue(VALUE_TEST_CONTAINS_KEY));
hashMap.put(KEY_TEST_CONTAINS_VALUE, VALUE_TEST_CONTAINS_KEY);
- assertTrue("check contains of map with element",
- hashMap.containsValue(VALUE_TEST_CONTAINS_KEY));
+ assertTrue(
+ "check contains of map with element", hashMap.containsValue(VALUE_TEST_CONTAINS_KEY));
assertFalse(
"check contains of map other element",
hashMap.containsValue(
@@ -604,9 +597,7 @@
assertEquals(VALUE_TEST_PUT_1, hashMap.put(null, VALUE_TEST_PUT_2));
}
- /**
- * Test method for 'java.util.HashMap.putAll(Map)'.
- */
+ /** Test method for 'java.util.HashMap.putAll(Map)'. */
public void testPutAll() {
HashMap<String, String> srcMap = new HashMap<String, String>();
checkEmptyHashMapAssumptions(srcMap);
@@ -669,9 +660,7 @@
dstMap.putAll(dstMap);
}
- /**
- * Test method for 'java.util.HashMap.remove(Object)'.
- */
+ /** Test method for 'java.util.HashMap.remove(Object)'. */
public void testRemove() {
HashMap<String, String> hashMap = new HashMap<String, String>();
checkEmptyHashMapAssumptions(hashMap);
@@ -685,9 +674,7 @@
assertNull(hashMap.remove(KEY_TEST_REMOVE));
}
- /**
- * Test method for 'java.util.HashMap.size()'.
- */
+ /** Test method for 'java.util.HashMap.size()'. */
public void testSize() {
HashMap<String, String> hashMap = new HashMap<String, String>();
checkEmptyHashMapAssumptions(hashMap);
@@ -722,9 +709,7 @@
assertEquals(SIZE_ZERO, hashMap.size());
}
- /**
- * Test method for 'java.util.AbstractMap.toString()'.
- */
+ /** Test method for 'java.util.AbstractMap.toString()'. */
public void testToString() {
HashMap<String, String> hashMap = new HashMap<String, String>();
checkEmptyHashMapAssumptions(hashMap);
@@ -733,9 +718,7 @@
assertTrue(entryString.equals(hashMap.toString()));
}
- /**
- * Test method for 'java.util.AbstractMap.values()'.
- */
+ /** Test method for 'java.util.AbstractMap.values()'. */
public void testValues() {
HashMap<String, String> hashMap = new HashMap<String, String>();
checkEmptyHashMapAssumptions(hashMap);
diff --git a/user/test/com/google/gwt/emultest/java/util/HashSetTest.java b/user/test/com/google/gwt/emultest/java/util/HashSetTest.java
index ff45396..8defe14 100644
--- a/user/test/com/google/gwt/emultest/java/util/HashSetTest.java
+++ b/user/test/com/google/gwt/emultest/java/util/HashSetTest.java
@@ -1,12 +1,12 @@
/*
* Copyright 2007 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
@@ -15,16 +15,12 @@
*/
package com.google.gwt.emultest.java.util;
-import org.apache.commons.collections.TestSet;
-
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
-/**
- * TODO: document me.
- */
+/** Tests <code>HashSet</code>. */
public class HashSetTest extends TestSet {
public HashSetTest() {
@@ -54,5 +50,4 @@
public Object makeObject() {
return new HashSet();
}
-
}
diff --git a/user/test/com/google/gwt/emultest/java/util/IdentityHashMapTest.java b/user/test/com/google/gwt/emultest/java/util/IdentityHashMapTest.java
index 3cf9476..d4957bb 100644
--- a/user/test/com/google/gwt/emultest/java/util/IdentityHashMapTest.java
+++ b/user/test/com/google/gwt/emultest/java/util/IdentityHashMapTest.java
@@ -24,17 +24,14 @@
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-import org.apache.commons.collections.TestMap;
-/**
- * Tests <code>IdentityHashMap</code>.
- */
+/** Tests <code>IdentityHashMap</code>. */
@SuppressWarnings({"unchecked", "rawtypes"})
public class IdentityHashMapTest extends TestMap {
/**
- * A class that is equal to all other instances of itself; used to ensure that
- * identity rather than equality is being checked.
+ * A class that is equal to all other instances of itself; used to ensure that identity rather
+ * than equality is being checked.
*/
private static class Foo {
@Override
@@ -69,12 +66,13 @@
private static final String KEY_TEST_KEY_SET = "testKeySet";
private static final String KEY_TEST_PUT = "testPut";
private static final String KEY_TEST_REMOVE = "testRemove";
- private static final Object ODD_ZERO_KEY = new Object() {
- @Override
- public int hashCode() {
- return 0;
- }
- };
+ private static final Object ODD_ZERO_KEY =
+ new Object() {
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+ };
private static final String ODD_ZERO_VALUE = "odd zero";
private static final int SIZE_ONE = 1;
private static final int SIZE_THREE = 3;
@@ -88,13 +86,10 @@
private static final String VALUE_4 = "val4";
private static final String VALUE_TEST_CONTAINS_DOES_NOT_EXIST = "does not exist";
private static final Integer VALUE_TEST_CONTAINS_KEY = new Integer(5);
- private static final String VALUE_TEST_ENTRY_SET_1 = KEY_TEST_ENTRY_SET
- + " - value1";
- private static final String VALUE_TEST_ENTRY_SET_2 = KEY_TEST_ENTRY_SET
- + " - value2";
+ private static final String VALUE_TEST_ENTRY_SET_1 = KEY_TEST_ENTRY_SET + " - value1";
+ private static final String VALUE_TEST_ENTRY_SET_2 = KEY_TEST_ENTRY_SET + " - value2";
private static final String VALUE_TEST_GET = KEY_TEST_GET + " - Value";
- private static final String VALUE_TEST_KEY_SET = KEY_TEST_KEY_SET
- + " - value";
+ private static final String VALUE_TEST_KEY_SET = KEY_TEST_KEY_SET + " - value";
private static final String VALUE_TEST_PUT_1 = KEY_TEST_PUT + " - value 1";
private static final String VALUE_TEST_PUT_2 = KEY_TEST_PUT + " - value 2";
private static final String VALUE_TEST_REMOVE = KEY_TEST_REMOVE + " - value";
@@ -217,12 +212,12 @@
IdentityHashMap hashMap = new IdentityHashMap();
checkEmptyHashMapAssumptions(hashMap);
- assertFalse("check contains of empty map",
- hashMap.containsValue(VALUE_TEST_CONTAINS_KEY));
+ assertFalse("check contains of empty map", hashMap.containsValue(VALUE_TEST_CONTAINS_KEY));
hashMap.put(KEY_TEST_CONTAINS_VALUE, VALUE_TEST_CONTAINS_KEY);
- assertTrue("check contains of map with element",
- hashMap.containsValue(VALUE_TEST_CONTAINS_KEY));
- assertFalse("check contains of map other element",
+ assertTrue(
+ "check contains of map with element", hashMap.containsValue(VALUE_TEST_CONTAINS_KEY));
+ assertFalse(
+ "check contains of map other element",
hashMap.containsValue(VALUE_TEST_CONTAINS_DOES_NOT_EXIST));
if (useNullValue()) {
@@ -453,10 +448,7 @@
assertTrue(keyColl.contains(INTEGER_3));
}
- /**
- * Test that the implementation differs from a standard map in demanding
- * identity.
- */
+ /** Test that the implementation differs from a standard map in demanding identity. */
public void testIdentity() {
IdentityHashMap hashMap = new IdentityHashMap();
checkEmptyHashMapAssumptions(hashMap);
@@ -471,10 +463,7 @@
assertNull(hashMap.get(foo2));
}
- /**
- * Test that the implementation differs from a standard map in demanding
- * identity.
- */
+ /** Test that the implementation differs from a standard map in demanding identity. */
public void testIdentityBasedEquality() {
IdentityHashMap hashMap1 = new IdentityHashMap();
checkEmptyHashMapAssumptions(hashMap1);
@@ -487,10 +476,7 @@
assertFalse(hashMap1.equals(hashMap2));
}
- /**
- * Test that the implementation differs from a standard map in demanding
- * identity.
- */
+ /** Test that the implementation differs from a standard map in demanding identity. */
public void testIdentityBasedHashCode() {
IdentityHashMap hashMap1 = new IdentityHashMap();
checkEmptyHashMapAssumptions(hashMap1);
@@ -585,9 +571,7 @@
assertEquals(VALUE_TEST_PUT_1, hashMap.put(null, VALUE_TEST_PUT_2));
}
- /**
- * Test method for 'java.util.IdentityHashMap.putAll(Map)'.
- */
+ /** Test method for 'java.util.IdentityHashMap.putAll(Map)'. */
public void testPutAll() {
IdentityHashMap srcMap = new IdentityHashMap();
checkEmptyHashMapAssumptions(srcMap);
@@ -650,9 +634,7 @@
dstMap.putAll(dstMap);
}
- /**
- * Test method for 'java.util.IdentityHashMap.remove(Object)'.
- */
+ /** Test method for 'java.util.IdentityHashMap.remove(Object)'. */
public void testRemove() {
IdentityHashMap hashMap = new IdentityHashMap();
checkEmptyHashMapAssumptions(hashMap);
@@ -666,9 +648,7 @@
assertNull(hashMap.remove(KEY_TEST_REMOVE));
}
- /**
- * Test method for 'java.util.IdentityHashMap.size()'.
- */
+ /** Test method for 'java.util.IdentityHashMap.size()'. */
public void testSize() {
IdentityHashMap hashMap = new IdentityHashMap();
checkEmptyHashMapAssumptions(hashMap);
@@ -703,9 +683,7 @@
assertEquals(SIZE_ZERO, hashMap.size());
}
- /**
- * Test method for 'java.util.AbstractMap.toString()'.
- */
+ /** Test method for 'java.util.AbstractMap.toString()'. */
public void testToString() {
IdentityHashMap hashMap = new IdentityHashMap();
checkEmptyHashMapAssumptions(hashMap);
@@ -714,9 +692,7 @@
assertTrue(entryString.equals(hashMap.toString()));
}
- /**
- * Test method for 'java.util.AbstractMap.values()'.
- */
+ /** Test method for 'java.util.AbstractMap.values()'. */
public void testValues() {
IdentityHashMap hashMap = new IdentityHashMap();
checkEmptyHashMapAssumptions(hashMap);
diff --git a/user/test/com/google/gwt/emultest/java/util/LinkedHashMapTest.java b/user/test/com/google/gwt/emultest/java/util/LinkedHashMapTest.java
index 972ea8b..e6a11a2 100644
--- a/user/test/com/google/gwt/emultest/java/util/LinkedHashMapTest.java
+++ b/user/test/com/google/gwt/emultest/java/util/LinkedHashMapTest.java
@@ -16,9 +16,6 @@
package com.google.gwt.emultest.java.util;
import com.google.gwt.testing.TestUtils;
-
-import org.apache.commons.collections.TestMap;
-
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
@@ -27,9 +24,7 @@
import java.util.Map.Entry;
import java.util.Set;
-/**
- * Tests <code>LinkedHashMap</code>.
- */
+/** Tests <code>LinkedHashMap</code>. */
public class LinkedHashMapTest extends TestMap {
// should be a method-level class, however to avoid serialization warning made
// static instead.
@@ -84,12 +79,13 @@
private static final float LOAD_FACTOR_ONE_HALF = 0.5F;
private static final float LOAD_FACTOR_ONE_TENTH = 0.1F;
private static final float LOAD_FACTOR_ZERO = 0.0F;
- private static final Object ODD_ZERO_KEY = new Object() {
- @Override
- public int hashCode() {
- return 0;
- }
- };
+ private static final Object ODD_ZERO_KEY =
+ new Object() {
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+ };
private static final String ODD_ZERO_VALUE = "odd zero";
private static final int SIZE_ONE = 1;
private static final int SIZE_THREE = 3;
@@ -103,13 +99,10 @@
private static final String VALUE_4 = "val4";
private static final String VALUE_TEST_CONTAINS_DOES_NOT_EXIST = "does not exist";
private static final Integer VALUE_TEST_CONTAINS_KEY = new Integer(5);
- private static final String VALUE_TEST_ENTRY_SET_1 = KEY_TEST_ENTRY_SET
- + " - value1";
- private static final String VALUE_TEST_ENTRY_SET_2 = KEY_TEST_ENTRY_SET
- + " - value2";
+ private static final String VALUE_TEST_ENTRY_SET_1 = KEY_TEST_ENTRY_SET + " - value1";
+ private static final String VALUE_TEST_ENTRY_SET_2 = KEY_TEST_ENTRY_SET + " - value2";
private static final String VALUE_TEST_GET = KEY_TEST_GET + " - Value";
- private static final String VALUE_TEST_KEY_SET = KEY_TEST_KEY_SET
- + " - value";
+ private static final String VALUE_TEST_KEY_SET = KEY_TEST_KEY_SET + " - value";
private static final String VALUE_TEST_PUT_1 = KEY_TEST_PUT + " - value 1";
private static final String VALUE_TEST_PUT_2 = KEY_TEST_PUT + " - value 2";
private static final String VALUE_TEST_REMOVE = KEY_TEST_REMOVE + " - value";
@@ -232,11 +225,10 @@
LinkedHashMap<String, Integer> hashMap = new LinkedHashMap<String, Integer>();
checkEmptyLinkedHashMapAssumptions(hashMap);
- assertFalse("check contains of empty map",
- hashMap.containsValue(VALUE_TEST_CONTAINS_KEY));
+ assertFalse("check contains of empty map", hashMap.containsValue(VALUE_TEST_CONTAINS_KEY));
hashMap.put(KEY_TEST_CONTAINS_VALUE, VALUE_TEST_CONTAINS_KEY);
- assertTrue("check contains of map with element",
- hashMap.containsValue(VALUE_TEST_CONTAINS_KEY));
+ assertTrue(
+ "check contains of map with element", hashMap.containsValue(VALUE_TEST_CONTAINS_KEY));
assertFalse(
"check contains of map other element",
hashMap.containsValue(
@@ -453,8 +445,8 @@
*/
public void testLinkedHashMapIntFloat() {
- LinkedHashMap<String, String> hashMap = new LinkedHashMap<String, String>(CAPACITY_16,
- LOAD_FACTOR_ONE_HALF);
+ LinkedHashMap<String, String> hashMap =
+ new LinkedHashMap<String, String>(CAPACITY_16, LOAD_FACTOR_ONE_HALF);
checkEmptyLinkedHashMapAssumptions(hashMap);
// TODO(mmendez): how do we verify capacity and load factor?
@@ -520,8 +512,7 @@
}
public void testLRU() {
- LinkedHashMap<String, String> m = new LinkedHashMap<String, String>(10,
- .5f, true);
+ LinkedHashMap<String, String> m = new LinkedHashMap<String, String>(10, .5f, true);
m.put("A", "A");
m.put("B", "B");
m.put("C", "C");
@@ -553,9 +544,7 @@
assertEquals(VALUE_TEST_PUT_1, hashMap.put(null, VALUE_TEST_PUT_2));
}
- /**
- * Test method for 'java.util.LinkedHashMap.putAll(Map)'.
- */
+ /** Test method for 'java.util.LinkedHashMap.putAll(Map)'. */
public void testPutAll() {
LinkedHashMap<String, String> srcMap = new LinkedHashMap<String, String>();
checkEmptyLinkedHashMapAssumptions(srcMap);
@@ -618,9 +607,7 @@
dstMap.putAll(dstMap);
}
- /**
- * Test method for 'java.util.LinkedHashMap.remove(Object)'.
- */
+ /** Test method for 'java.util.LinkedHashMap.remove(Object)'. */
public void testRemove() {
LinkedHashMap<String, String> hashMap = new LinkedHashMap<String, String>();
checkEmptyLinkedHashMapAssumptions(hashMap);
@@ -674,9 +661,7 @@
assertEquals("New-C", entries.next().getValue());
}
- /**
- * Test method for 'java.util.LinkedHashMap.size()'.
- */
+ /** Test method for 'java.util.LinkedHashMap.size()'. */
public void testSize() {
LinkedHashMap<String, String> hashMap = new LinkedHashMap<String, String>();
checkEmptyLinkedHashMapAssumptions(hashMap);
@@ -711,9 +696,7 @@
assertEquals(SIZE_ZERO, hashMap.size());
}
- /**
- * Test method for 'java.util.AbstractMap.toString()'.
- */
+ /** Test method for 'java.util.AbstractMap.toString()'. */
public void testToString() {
LinkedHashMap<String, String> hashMap = new LinkedHashMap<String, String>();
checkEmptyLinkedHashMapAssumptions(hashMap);
@@ -722,9 +705,7 @@
assertTrue(entryString.equals(hashMap.toString()));
}
- /**
- * Test method for 'java.util.AbstractMap.values()'.
- */
+ /** Test method for 'java.util.AbstractMap.values()'. */
public void testValues() {
LinkedHashMap<String, String> hashMap = new LinkedHashMap<String, String>();
checkEmptyLinkedHashMapAssumptions(hashMap);
@@ -748,10 +729,9 @@
}
/**
- * This method exists because java 1.5 no longer has
- * LinkedHashMap(LinkedHashMap), replacing it with LinkedHashMap(Map<? extends
- * K, ? extends V> m). Nevertheless, we want to use it in Production Mode to
- * test that Production Mode function.
+ * This method exists because java 1.5 no longer has LinkedHashMap(LinkedHashMap), replacing it
+ * with LinkedHashMap(Map<? extends K, ? extends V> m). Nevertheless, we want to use it in
+ * Production Mode to test that Production Mode function.
*
* @param hashMap the LinkedHashMap to be copied
* @return the copy
diff --git a/user/test/com/google/gwt/emultest/java/util/LinkedHashSetTest.java b/user/test/com/google/gwt/emultest/java/util/LinkedHashSetTest.java
index 5de7cd2..db6d148 100644
--- a/user/test/com/google/gwt/emultest/java/util/LinkedHashSetTest.java
+++ b/user/test/com/google/gwt/emultest/java/util/LinkedHashSetTest.java
@@ -1,12 +1,12 @@
/*
* Copyright 2013 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
@@ -15,14 +15,10 @@
*/
package com.google.gwt.emultest.java.util;
-import org.apache.commons.collections.TestSet;
-
import java.util.LinkedHashSet;
import java.util.Set;
-/**
- * Tests <code>LinkedHashSet</code>.
- */
+/** Tests <code>LinkedHashSet</code>. */
public class LinkedHashSetTest extends TestSet {
private static final String VALUE_1 = "val1";
@@ -32,7 +28,7 @@
/**
* Check the state of a newly constructed, empty LinkedHashSet.
- *
+ *
* @param hashSet
*/
private static void checkEmptyLinkedHashSetAssumptions(LinkedHashSet<?> hashSet) {
diff --git a/user/test/com/google/gwt/emultest/java/util/ListTestBase.java b/user/test/com/google/gwt/emultest/java/util/ListTestBase.java
index 94787d9..90ba0d3 100644
--- a/user/test/com/google/gwt/emultest/java/util/ListTestBase.java
+++ b/user/test/com/google/gwt/emultest/java/util/ListTestBase.java
@@ -1,12 +1,12 @@
/*
* 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
@@ -15,8 +15,6 @@
*/
package com.google.gwt.emultest.java.util;
-import org.apache.commons.collections.TestArrayList;
-
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
@@ -24,32 +22,32 @@
import java.util.ListIterator;
/**
- * Tests List, and, by extension AbstractList. Uses inheritance to inherit all
- * of Apache's TestList and TestCollection.
+ * Tests List, and, by extension AbstractList. Uses inheritance to inherit all of Apache's TestList
+ * and TestCollection.
*/
@SuppressWarnings("unchecked")
public abstract class ListTestBase extends TestArrayList {
- private static volatile boolean NO_OPTIMIZE_FALSE = false;
+ private static final boolean NO_OPTIMIZE_FALSE = false;
public void testAddAll() {
List<Integer> list = makeEmptyList();
list.addAll(Arrays.asList(1, 2, 3, 4));
list.addAll(2, Arrays.asList(21, 22));
- checkListSizeAndContent(list, 1, 2, 21, 22, 3 ,4);
+ checkListSizeAndContent(list, 1, 2, 21, 22, 3, 4);
list = makeEmptyList();
list.addAll(Arrays.asList(1, 2, 3, 4));
list.addAll(0, Arrays.asList(21, 22));
- checkListSizeAndContent(list, 21, 22, 1, 2, 3 ,4);
+ checkListSizeAndContent(list, 21, 22, 1, 2, 3, 4);
list = makeEmptyList();
list.addAll(Arrays.asList(1, 2, 3, 4));
list.addAll(4, Arrays.asList(21, 22));
- checkListSizeAndContent(list, 1, 2, 3 ,4, 21, 22);
+ checkListSizeAndContent(list, 1, 2, 3, 4, 21, 22);
}
public void testAddAllReturnValue() {
@@ -237,9 +235,7 @@
}
}
- /**
- * Test add() method for list returned by List<E>.subList() method.
- */
+ /** Test add() method for list returned by List<E>.subList() method. */
public void testSubListAdd() {
List<Integer> baseList = createListWithContent(new int[] {1, 2, 3, 4, 5});
List<Integer> sublist = baseList.subList(1, 3);
@@ -299,14 +295,14 @@
fail("Expected IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException expected) {
}
-
+
assertFalse(sublist.remove(Integer.valueOf(4)));
-
+
assertTrue(sublist.remove(Integer.valueOf(3)));
-
+
assertEquals(0, sublist.size());
assertEquals(3, baseList.size());
-
+
sublist.add(6);
checkListSizeAndContent(baseList, 1, 6, 4, 5);
}
diff --git a/user/test/com/google/gwt/emultest/java/util/PriorityQueueTest.java b/user/test/com/google/gwt/emultest/java/util/PriorityQueueTest.java
index abed20f..5a9051e 100644
--- a/user/test/com/google/gwt/emultest/java/util/PriorityQueueTest.java
+++ b/user/test/com/google/gwt/emultest/java/util/PriorityQueueTest.java
@@ -15,8 +15,6 @@
*/
package com.google.gwt.emultest.java.util;
-import org.apache.commons.collections.TestCollection;
-
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
@@ -25,9 +23,7 @@
import java.util.PriorityQueue;
import java.util.TreeSet;
-/**
- * Test PriorityQueue.
- */
+/** Test PriorityQueue. */
public class PriorityQueueTest extends TestCollection {
public void testAdd() {
@@ -35,6 +31,7 @@
try {
queue.add(null);
+ fail("Expected NullPointerException");
} catch (NullPointerException expected) {
}
@@ -140,12 +137,13 @@
pq = new PriorityQueue<Integer>(11);
assertNull(pq.comparator());
- Comparator<Integer> comparator = new Comparator<Integer>() {
- @Override
- public int compare(Integer o1, Integer o2) {
- return o1 - o2;
- }
- };
+ Comparator<Integer> comparator =
+ new Comparator<Integer>() {
+ @Override
+ public int compare(Integer o1, Integer o2) {
+ return o1 - o2;
+ }
+ };
pq = new PriorityQueue<Integer>(11, comparator);
assertEquals(comparator, pq.comparator());
@@ -243,9 +241,7 @@
return pq;
}
- /**
- * Null elements are prohibited in PriorityQueue.
- */
+ /** Null elements are prohibited in PriorityQueue. */
@Override
protected Object[] getFullElements() {
return new Integer[] {1, 2, 3, 4};
diff --git a/user/test/org/apache/commons/collections/TestArrayList.java b/user/test/com/google/gwt/emultest/java/util/TestArrayList.java
similarity index 63%
rename from user/test/org/apache/commons/collections/TestArrayList.java
rename to user/test/com/google/gwt/emultest/java/util/TestArrayList.java
index 32eb554..bfc919f 100644
--- a/user/test/org/apache/commons/collections/TestArrayList.java
+++ b/user/test/com/google/gwt/emultest/java/util/TestArrayList.java
@@ -1,3 +1,4 @@
+// CHECKSTYLE_OFF: Copyrighted to ASF
/*
* Copyright 1999-2004 The Apache Software Foundation
*
@@ -13,36 +14,27 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+// CHECKSTYLE_ON
// MODIFIED BY GOOGLE
-package org.apache.commons.collections;
+package com.google.gwt.emultest.java.util;
import java.util.List;
-/**
- * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
- * @version $Id: TestArrayList.java,v 1.5.2.1 2004/05/22 12:14:05 scolebourne Exp $
- */
@SuppressWarnings({"unchecked", "rawtypes"})
-public abstract class TestArrayList extends TestList
-{
-
-
- // GOOGLE
- protected List list = makeEmptyList();
+abstract class TestArrayList extends TestList {
+ // GOOGLE
+ protected List list = makeEmptyList();
- public void testNewArrayList()
- {
- assertTrue("New list is empty", list.isEmpty());
+ public void testNewArrayList() {
+ assertTrue("New list is empty", list.isEmpty());
assertEquals("New list has size zero", 0, list.size());
- }
+ }
- public void testSearch()
- {
- list.add("First Item");
- list.add("Last Item");
+ public void testSearch() {
+ list.add("First Item");
+ list.add("Last Item");
assertEquals("First item is 'First Item'", "First Item", list.get(0));
assertEquals("Last Item is 'Last Item'", "Last Item", list.get(1));
- }
-
+ }
}
diff --git a/user/test/com/google/gwt/emultest/java/util/TestCollection.java b/user/test/com/google/gwt/emultest/java/util/TestCollection.java
new file mode 100644
index 0000000..5fbf556
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/util/TestCollection.java
@@ -0,0 +1,961 @@
+// CHECKSTYLE_OFF: Copyrighted to ASF
+/*
+ * Copyright 1999-2004 The Apache Software Foundation
+ *
+ * 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.
+ */
+// CHECKSTYLE_ON
+package com.google.gwt.emultest.java.util;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Set;
+
+/**
+ * Tests base {@link java.util.Collection} methods and contracts.
+ *
+ * <p>You should create a concrete subclass of this class to test any custom {@link Collection}
+ * implementation. At minimum, you'll have to implement the {@link #makeCollection()} method. You
+ * might want to override some of the additional protected methods as well:
+ *
+ * <p><B>Element Population Methods</B>
+ *
+ * <p>Override these if your collection restricts what kind of elements are allowed (for instance,
+ * if <Code>null</Code> is not permitted):
+ *
+ * <UL>
+ * <Li>{@link #getFullElements()}
+ * <Li>{@link #getOtherElements()}
+ * </UL>
+ *
+ * <B>Supported Operation Methods</B>
+ *
+ * <p>Override these if your collection doesn't support certain operations:
+ *
+ * <UL>
+ * <LI>{@link #isAddSupported()}
+ * <LI>{@link #isRemoveSupported()}
+ * <li>{@link #areEqualElementsDistinguishable()}
+ * </UL>
+ *
+ * <B>Fixture Methods</B>
+ *
+ * <p>Fixtures are used to verify that the operation results in correct state for the collection.
+ * Basically, the operation is performed against your collection implementation, and an identical
+ * operation is performed against a <I>confirmed</I> collection implementation. A confirmed
+ * collection implementation is something like <Code>java.util.ArrayList</Code>, which is known to
+ * conform exactly to its collection interface's contract. After the operation takes place on both
+ * your collection implementation and the confirmed collection implementation, the two collections
+ * are compared to see if their state is identical. The comparison is usually much more involved
+ * than a simple <Code>equals</Code> test. This verification is used to ensure proper modifications
+ * are made along with ensuring that the collection does not change when read-only modifications are
+ * made.
+ *
+ * <p>The {@link #collection} field holds an instance of your collection implementation; the {@link
+ * #confirmed} field holds an instance of the confirmed collection implementation. The {@link
+ * #resetEmpty()} and {@link #resetFull()} methods set these fields to empty or full collections, so
+ * that tests can proceed from a known state.
+ *
+ * <p>After a modification operation to both {@link #collection} and {@link #confirmed}, the {@link
+ * #verify()} method is invoked to compare the results. You may want to override {@link #verify()}
+ * to perform additional verifications. For instance, when testing the collection views of a map,
+ * {@link TestMap} would override {@link #verify()} to make sure the map is changed after the
+ * collection view is changed.
+ *
+ * <p>If you're extending this class directly, you will have to provide implementations for the
+ * following:
+ *
+ * <UL>
+ * <LI>{@link #makeConfirmedCollection()}
+ * <LI>{@link #makeConfirmedFullCollection()}
+ * </UL>
+ *
+ * Those methods should provide a confirmed collection implementation that's compatible with your
+ * collection implementation.
+ *
+ * <p>If you're extending {@link TestList}, {@link TestSet}, or {@link TestBag}, you probably don't
+ * have to worry about the above methods, because those three classes already override the methods
+ * to provide standard JDK confirmed collections.
+ *
+ * <p><B>Other notes</B>
+ *
+ * <p>If your {@link Collection} fails one of these tests by design, you may still use this base set
+ * of cases. Simply override the test case (method) your {@link Collection} fails. For instance, the
+ * {@link #testIteratorFailFast()} method is provided since most collections have fail-fast
+ * iterators; however, that's not strictly required by the collection contract, so you may want to
+ * override that method to do nothing.
+ *
+ * <p>
+ */
+@SuppressWarnings({"unchecked", "rawtypes"})
+abstract class TestCollection extends TestObject {
+
+ //
+ // NOTE:
+ //
+ // Collection doesn't define any semantics for equals, and recommends you
+ // use reference-based default behavior of Object.equals. (And a test for
+ // that already exists in TestObject). Tests for equality of lists, sets
+ // and bags will have to be written in test subclasses. Thus, there is no
+ // tests on Collection.equals nor any for Collection.hashCode.
+ //
+
+ // These fields are used by reset() and verify(), and any test
+ // method that tests a modification.
+
+ /** A collection instance that will be used for testing. */
+ protected Collection collection;
+
+ /**
+ * Confirmed collection. This is an instance of a collection that is confirmed to conform exactly
+ * to the java.util.Collection contract. Modification operations are tested by performing a mod on
+ * your collection, performing the exact same mod on an equivalent confirmed collection, and then
+ * calling verify() to make sure your collection still matches the confirmed collection.
+ */
+ protected Collection confirmed;
+
+ /**
+ * Resets the {@link #collection} and {@link #confirmed} fields to empty collections. Invoke this
+ * method before performing a modification test.
+ */
+ protected void resetEmpty() {
+ this.collection = makeCollection();
+ this.confirmed = makeConfirmedCollection();
+ }
+
+ /**
+ * Resets the {@link #collection} and {@link #confirmed} fields to full collections. Invoke this
+ * method before performing a modification test.
+ */
+ protected void resetFull() {
+ this.collection = makeFullCollection();
+ this.confirmed = makeConfirmedFullCollection();
+ }
+
+ /**
+ * Specifies whether equal elements in the collection are, in fact, distinguishable with
+ * information not readily available. That is, if a particular value is to be removed from the
+ * collection, then there is one and only one value that can be removed, even if there are other
+ * elements which are equal to it.
+ *
+ * <p>In most collection cases, elements are not distinguishable (equal is equal), thus this
+ * method defaults to return false. In some cases, however, they are. For example, the collection
+ * returned from the map's values() collection view are backed by the map, so while there may be
+ * two values that are equal, their associated keys are not. Since the keys are distinguishable,
+ * the values are.
+ *
+ * <p>This flag is used to skip some verifications for iterator.remove() where it is impossible to
+ * perform an equivalent modification on the confirmed collection because it is not possible to
+ * determine which value in the confirmed collection to actually remove. Tests that override the
+ * default (i.e. where equal elements are distinguishable), should provide additional tests on
+ * iterator.remove() to make sure the proper elements are removed when remove() is called on the
+ * iterator.
+ */
+ protected boolean areEqualElementsDistinguishable() {
+ return false;
+ }
+
+ /** Verifies that {@link #collection} and {@link #confirmed} have identical state. */
+ protected void verify() {
+ int confirmedSize = confirmed.size();
+ assertEquals(
+ "Collection size should match confirmed collection's", confirmedSize, collection.size());
+ assertEquals(
+ "Collection isEmpty() result should match confirmed " + " collection's",
+ confirmed.isEmpty(),
+ collection.isEmpty());
+
+ // verify the collections are the same by attempting to match each
+ // object in the collection and confirmed collection. To account for
+ // duplicates and differing orders, each confirmed element is copied
+ // into an array and a flag is maintained for each element to determine
+ // whether it has been matched once and only once. If all elements in
+ // the confirmed collection are matched once and only once and there
+ // aren't any elements left to be matched in the collection,
+ // verification is a success.
+
+ // copy each collection value into an array
+ Object[] confirmedValues = new Object[confirmedSize];
+
+ Iterator iter;
+
+ iter = confirmed.iterator();
+ int pos = 0;
+ while (iter.hasNext()) {
+ confirmedValues[pos++] = iter.next();
+ }
+
+ // allocate an array of boolean flags for tracking values that have
+ // been matched once and only once.
+ boolean[] matched = new boolean[confirmedSize];
+
+ // now iterate through the values of the collection and try to match
+ // the value with one in the confirmed array.
+ iter = collection.iterator();
+ while (iter.hasNext()) {
+ Object o = iter.next();
+ boolean match = false;
+ for (int i = 0; i < confirmedSize; i++) {
+ if (matched[i]) {
+ // skip values already matched
+ continue;
+ }
+ if (o == confirmedValues[i] || (o != null && o.equals(confirmedValues[i]))) {
+ // values matched
+ matched[i] = true;
+ match = true;
+ break;
+ }
+ }
+ // no match found!
+ if (!match) {
+ fail(
+ "Collection should not contain a value that the "
+ + "confirmed collection does not have.");
+ }
+ }
+
+ // make sure there aren't any unmatched values
+ for (int i = 0; i < confirmedSize; i++) {
+ if (!matched[i]) {
+ // the collection didn't match all the confirmed values
+ fail("Collection should contain all values that are in the " + "confirmed collection");
+ }
+ }
+ }
+
+ /**
+ * Returns a confirmed empty collection. For instance, a {@link java.util.ArrayList} for lists or
+ * a {@link java.util.HashSet} for sets.
+ *
+ * @return a confirmed empty collection
+ */
+ protected abstract Collection makeConfirmedCollection();
+
+ /**
+ * Returns a confirmed full collection. For instance, a {@link java.util.ArrayList} for lists or a
+ * {@link java.util.HashSet} for sets. The returned collection should contain the elements
+ * returned by {@link #getFullElements()}.
+ *
+ * @return a confirmed full collection
+ */
+ protected abstract Collection makeConfirmedFullCollection();
+
+ /**
+ * Returns true if the collections produced by {@link #makeCollection()} and {@link
+ * #makeFullCollection()} support the <Code>add</Code> and <Code>addAll</Code> operations.
+ *
+ * <p>Default implementation returns true. Override if your collection class does not support add
+ * or addAll.
+ */
+ protected boolean isAddSupported() {
+ return true;
+ }
+
+ /**
+ * Returns true if the collections produced by {@link #makeCollection()} and {@link
+ * #makeFullCollection()} support the <Code>remove</Code>, <Code>removeAll</Code>, <Code>retainAll
+ * </Code>, <Code>clear</Code> and <Code>iterator().remove()</Code> methods. Default
+ * implementation returns true. Override if your collection class does not support removal
+ * operations.
+ */
+ protected boolean isRemoveSupported() {
+ return true;
+ }
+
+ /**
+ * Returns an array of objects that are contained in a collection produced by {@link
+ * #makeFullCollection()}. Every element in the returned array <I>must</I> be an element in a full
+ * collection.
+ *
+ * <p>The default implementation returns a heterogeneous array of objects with some duplicates and
+ * with the null element. Override if you require specific testing elements. Note that if you
+ * override {@link #makeFullCollection()}, you <I>must</I> override this method to reflect the
+ * contents of a full collection.
+ */
+ protected Object[] getFullElements() {
+ ArrayList list = new ArrayList();
+
+ list.addAll(Arrays.asList(getFullNonNullElements()));
+ list.add(4, null);
+ return list.toArray();
+ }
+
+ /**
+ * Returns an array of elements that are <I>not</I> contained in a full collection. Every element
+ * in the returned array must not exist in a collection returned by {@link #makeFullCollection()}.
+ * The default implementation returns a heterogeneous array of elements without null. Note that
+ * some of the tests add these elements to an empty or full collection, so if your collection
+ * restricts certain kinds of elements, you should override this method.
+ */
+ protected Object[] getOtherElements() {
+ return getOtherNonNullElements();
+ }
+
+ /** Returns a new, empty {@link Collection} to be used for testing. */
+ protected abstract Collection makeCollection();
+
+ /**
+ * Returns a full collection to be used for testing. The collection returned by this method should
+ * contain every element returned by {@link #getFullElements()}. The default implementation, in
+ * fact, simply invokes <Code>addAll</Code> on an empty collection with the results of {@link
+ * #getFullElements()}. Override this default if your collection doesn't support addAll.
+ */
+ protected Collection makeFullCollection() {
+ Collection c = makeCollection();
+ c.addAll(Arrays.asList(getFullElements()));
+ return c;
+ }
+
+ /** Returns an empty collection for Object tests. */
+ @Override
+ public Object makeObject() {
+ return makeCollection();
+ }
+
+ /** Tests {@link Collection#add(Object)}. */
+ public void testCollectionAdd() {
+ if (!isAddSupported()) {
+ return;
+ }
+
+ Object[] elements = getFullElements();
+ for (int i = 0; i < elements.length; i++) {
+ resetEmpty();
+ boolean r = collection.add(elements[i]);
+ confirmed.add(elements[i]);
+ verify();
+ assertTrue("Empty collection changed after add", r);
+ assertTrue("Collection size is 1 after first add", collection.size() == 1);
+ }
+
+ resetEmpty();
+ int size = 0;
+ for (int i = 0; i < elements.length; i++) {
+ boolean r = collection.add(elements[i]);
+ confirmed.add(elements[i]);
+ verify();
+ if (r) {
+ size++;
+ }
+ assertEquals("Collection size should grow after add", size, collection.size());
+ assertTrue("Collection should contain added element", collection.contains(elements[i]));
+ }
+ }
+
+ /** Tests {@link Collection#addAll(Collection)}. */
+ public void testCollectionAddAll() {
+ if (!isAddSupported()) {
+ return;
+ }
+
+ resetEmpty();
+ Object[] elements = getFullElements();
+ boolean r = collection.addAll(Arrays.asList(elements));
+ confirmed.addAll(Arrays.asList(elements));
+ verify();
+ assertTrue("Empty collection should change after addAll", r);
+ for (int i = 0; i < elements.length; i++) {
+ assertTrue("Collection should contain added element", collection.contains(elements[i]));
+ }
+
+ resetFull();
+ int size = collection.size();
+ elements = getOtherElements();
+ r = collection.addAll(Arrays.asList(elements));
+ confirmed.addAll(Arrays.asList(elements));
+ verify();
+ assertTrue("Full collection should change after addAll", r);
+ for (int i = 0; i < elements.length; i++) {
+ assertTrue("Full collection should contain added element", collection.contains(elements[i]));
+ }
+ assertEquals("Size should increase after addAll", size + elements.length, collection.size());
+
+ resetFull();
+ size = collection.size();
+ r = collection.addAll(Arrays.asList(getFullElements()));
+ confirmed.addAll(Arrays.asList(getFullElements()));
+ verify();
+ if (r) {
+ assertTrue("Size should increase if addAll returns true", size < collection.size());
+ } else {
+ assertEquals("Size should not change if addAll returns false", size, collection.size());
+ }
+ }
+
+ /**
+ * If {@link #isAddSupported()} returns false, tests that add operations
+ * raise <Code>UnsupportedOperationException.
+ */
+ public void testUnsupportedAdd() {
+ if (isAddSupported()) {
+ return;
+ }
+
+ resetEmpty();
+ try {
+ collection.add(new Object());
+ fail("Emtpy collection should not support add.");
+ } catch (UnsupportedOperationException e) {
+ // expected
+ }
+ // make sure things didn't change even if the expected exception was
+ // thrown.
+ verify();
+
+ try {
+ collection.addAll(Arrays.asList(getFullElements()));
+ fail("Emtpy collection should not support addAll.");
+ } catch (UnsupportedOperationException e) {
+ // expected
+ }
+ // make sure things didn't change even if the expected exception was
+ // thrown.
+ verify();
+
+ resetFull();
+ try {
+ collection.add(new Object());
+ fail("Full collection should not support add.");
+ } catch (UnsupportedOperationException e) {
+ // expected
+ }
+ // make sure things didn't change even if the expected exception was
+ // thrown.
+ verify();
+
+ try {
+ collection.addAll(Arrays.asList(getOtherElements()));
+ fail("Full collection should not support addAll.");
+ } catch (UnsupportedOperationException e) {
+ // expected
+ }
+ // make sure things didn't change even if the expected exception was
+ // thrown.
+ verify();
+ }
+
+ /** Test {@link Collection#clear()}. */
+ public void testCollectionClear() {
+ if (!isRemoveSupported()) {
+ return;
+ }
+
+ resetEmpty();
+ collection.clear(); // just to make sure it doesn't raise anything
+ verify();
+
+ resetFull();
+ collection.clear();
+ confirmed.clear();
+ verify();
+ }
+
+ /** Tests {@link Collection#contains(Object)}. */
+ public void testCollectionContains() {
+ Object[] elements;
+
+ resetEmpty();
+ elements = getFullElements();
+ for (int i = 0; i < elements.length; i++) {
+ assertFalse("Empty collection shouldn't contain element", collection.contains(elements[i]));
+ }
+ // make sure calls to "contains" don't change anything
+ verify();
+
+ elements = getOtherElements();
+ for (int i = 0; i < elements.length; i++) {
+ assertTrue("Empty collection shouldn't contain element", !collection.contains(elements[i]));
+ }
+ // make sure calls to "contains" don't change anything
+ verify();
+
+ resetFull();
+ elements = getFullElements();
+ for (int i = 0; i < elements.length; i++) {
+ assertTrue("Full collection should contain element.", collection.contains(elements[i]));
+ }
+ // make sure calls to "contains" don't change anything
+ verify();
+
+ resetFull();
+ elements = getOtherElements();
+ for (int i = 0; i < elements.length; i++) {
+ assertTrue("Full collection shouldn't contain element", !collection.contains(elements[i]));
+ }
+ }
+
+ /** Tests {@link Collection#containsAll(Collection)}. */
+ @SuppressWarnings("ModifyingCollectionWithItself")
+ public void testCollectionContainsAll() {
+ resetEmpty();
+ Collection col = new HashSet();
+ assertTrue(
+ "Every Collection should contain all elements of an " + "empty Collection.",
+ collection.containsAll(col));
+ col.addAll(Arrays.asList(getOtherElements()));
+ assertTrue(
+ "Empty Collection shouldn't contain all elements of " + "a non-empty Collection.",
+ !collection.containsAll(col));
+ // make sure calls to "containsAll" don't change anything
+ verify();
+
+ resetFull();
+ assertTrue("Full collection shouldn't contain other elements", !collection.containsAll(col));
+
+ col.clear();
+ col.addAll(Arrays.asList(getFullElements()));
+ assertTrue("Full collection should containAll full elements", collection.containsAll(col));
+ // make sure calls to "containsAll" don't change anything
+ verify();
+
+ assertTrue("Full collection should containAll itself", collection.containsAll(collection));
+
+ // make sure calls to "containsAll" don't change anything
+ verify();
+
+ col = new ArrayList();
+ col.addAll(Arrays.asList(getFullElements()));
+ col.addAll(Arrays.asList(getFullElements()));
+ assertTrue(
+ "Full collection should containAll duplicate full " + "elements",
+ collection.containsAll(col));
+
+ // make sure calls to "containsAll" don't change anything
+ verify();
+ }
+
+ /** Tests {@link Collection#isEmpty()}. */
+ public void testCollectionIsEmpty() {
+ resetEmpty();
+ assertEquals("New Collection should be empty.", true, collection.isEmpty());
+ // make sure calls to "isEmpty() don't change anything
+ verify();
+
+ resetFull();
+ assertEquals("Full collection shouldn't be empty", false, collection.isEmpty());
+ // make sure calls to "isEmpty() don't change anything
+ verify();
+ }
+
+ /** Tests the read-only functionality of {@link Collection#iterator()}. */
+ public void testCollectionIterator() {
+ resetEmpty();
+ Iterator it1 = collection.iterator();
+ assertEquals("Iterator for empty Collection shouldn't have next.", false, it1.hasNext());
+ try {
+ it1.next();
+ fail(
+ "Iterator at end of Collection should throw "
+ + "NoSuchElementException when next is called.");
+ } catch (NoSuchElementException e) {
+ // expected
+ }
+ // make sure nothing has changed after non-modification
+ verify();
+
+ resetFull();
+ it1 = collection.iterator();
+ for (int i = 0; i < collection.size(); i++) {
+ assertTrue("Iterator for full collection should haveNext", it1.hasNext());
+ it1.next();
+ }
+ assertTrue("Iterator should be finished", !it1.hasNext());
+
+ ArrayList list = new ArrayList();
+ it1 = collection.iterator();
+ for (int i = 0; i < collection.size(); i++) {
+ Object next = it1.next();
+ assertTrue(
+ "Collection should contain element returned by " + "its iterator",
+ collection.contains(next));
+ list.add(next);
+ }
+ try {
+ it1.next();
+ fail("iterator.next() should raise NoSuchElementException " + "after it finishes");
+ } catch (NoSuchElementException e) {
+ // expected
+ }
+ // make sure nothing has changed after non-modification
+ verify();
+ }
+
+ /** Tests removals from {@link Collection#iterator()}. */
+ public void testCollectionIteratorRemove() {
+ if (!isRemoveSupported()) {
+ return;
+ }
+
+ resetEmpty();
+ try {
+ collection.iterator().remove();
+ fail("New iterator.remove should raise IllegalState");
+ } catch (IllegalStateException e) {
+ // expected
+ }
+ verify();
+
+ try {
+ Iterator iter = collection.iterator();
+ iter.hasNext();
+ iter.remove();
+ fail("New iterator.remove should raise IllegalState " + "even after hasNext");
+ } catch (IllegalStateException e) {
+ // expected
+ }
+ verify();
+
+ resetFull();
+ int size = collection.size();
+ Iterator iter = collection.iterator();
+ while (iter.hasNext()) {
+ Object o = iter.next();
+ iter.remove();
+
+ // if the elements aren't distinguishable, we can just remove a
+ // matching element from the confirmed collection and verify
+ // contents are still the same. Otherwise, we don't have the
+ // ability to distinguish the elements and determine which to
+ // remove from the confirmed collection (in which case, we don't
+ // verify because we don't know how).
+ //
+ // see areEqualElementsDistinguishable()
+ if (!areEqualElementsDistinguishable()) {
+ confirmed.remove(o);
+ verify();
+ }
+
+ size--;
+ assertEquals(
+ "Collection should shrink by one after " + "iterator.remove", size, collection.size());
+ }
+ assertTrue("Collection should be empty after iterator purge", collection.isEmpty());
+
+ resetFull();
+ iter = collection.iterator();
+ iter.next();
+ iter.remove();
+ try {
+ iter.remove();
+ fail("Second iter.remove should raise IllegalState");
+ } catch (IllegalStateException e) {
+ // expected
+ }
+ }
+
+ /** Tests {@link Collection#remove(Object)}. */
+ public void testCollectionRemove() {
+ if (!isRemoveSupported()) {
+ return;
+ }
+
+ resetEmpty();
+ Object[] elements = getFullElements();
+ for (int i = 0; i < elements.length; i++) {
+ assertTrue("Shouldn't remove nonexistent element", !collection.remove(elements[i]));
+ verify();
+ }
+
+ Object[] other = getOtherElements();
+
+ resetFull();
+ for (int i = 0; i < other.length; i++) {
+ assertTrue("Shouldn't remove nonexistent other element", !collection.remove(other[i]));
+ verify();
+ }
+
+ int size = collection.size();
+ for (int i = 0; i < elements.length; i++) {
+ resetFull();
+ assertTrue("Collection should remove extant element", collection.remove(elements[i]));
+
+ // if the elements aren't distinguishable, we can just remove a
+ // matching element from the confirmed collection and verify
+ // contents are still the same. Otherwise, we don't have the
+ // ability to distinguish the elements and determine which to
+ // remove from the confirmed collection (in which case, we don't
+ // verify because we don't know how).
+ //
+ // see areEqualElementsDistinguishable()
+ if (!areEqualElementsDistinguishable()) {
+ confirmed.remove(elements[i]);
+ verify();
+ }
+
+ assertEquals("Collection should shrink after remove", size - 1, collection.size());
+ }
+ }
+
+ /** Tests {@link Collection#removeAll(Collection)}. */
+ public void testCollectionRemoveAll() {
+ if (!isRemoveSupported()) {
+ return;
+ }
+
+ resetEmpty();
+ assertTrue(
+ "Emtpy collection removeAll should return false for " + "empty input",
+ !collection.removeAll(Collections.EMPTY_SET));
+ verify();
+
+ assertTrue(
+ "Emtpy collection removeAll should return false for " + "nonempty input",
+ !collection.removeAll(new ArrayList(collection)));
+ verify();
+
+ resetFull();
+ assertTrue(
+ "Full collection removeAll should return false for " + "empty input",
+ !collection.removeAll(Collections.EMPTY_SET));
+ verify();
+
+ assertTrue(
+ "Full collection removeAll should return false for " + "other elements",
+ !collection.removeAll(Arrays.asList(getOtherElements())));
+ verify();
+
+ assertTrue(
+ "Full collection removeAll should return true for " + "full elements",
+ collection.removeAll(new HashSet(collection)));
+ confirmed.removeAll(new HashSet(confirmed));
+ verify();
+
+ resetFull();
+
+ int size = collection.size();
+ Object[] s = getFullElements();
+ List l = new ArrayList();
+ l.add(s[2]);
+ l.add(s[3]);
+ l.add(s[3]);
+
+ assertTrue("Full collection removeAll should work", collection.removeAll(l));
+ confirmed.removeAll(l);
+ verify();
+
+ assertTrue("Collection should shrink after removeAll", collection.size() < size);
+ Iterator iter = l.iterator();
+ while (iter.hasNext()) {
+ assertTrue("Collection shouldn't contain removed element", !collection.contains(iter.next()));
+ }
+ }
+
+ /** Tests {@link Collection#retainAll(Collection)}. */
+ public void testCollectionRetainAll() {
+ if (!isRemoveSupported()) {
+ return;
+ }
+
+ resetEmpty();
+ List elements = Arrays.asList(getFullElements());
+ List other = Arrays.asList(getOtherElements());
+ Set empty = new HashSet();
+
+ assertTrue("Empty retainAll() should return false", !collection.retainAll(empty));
+ verify();
+
+ assertTrue("Empty retainAll() should return false", !collection.retainAll(elements));
+ verify();
+
+ resetFull();
+ assertTrue("Collection should change from retainAll empty", collection.retainAll(empty));
+ confirmed.retainAll(empty);
+ verify();
+
+ resetFull();
+ assertTrue("Collection changed from retainAll other", collection.retainAll(other));
+ confirmed.retainAll(other);
+ verify();
+
+ resetFull();
+ int size = collection.size();
+ assertTrue(
+ "Collection shouldn't change from retainAll elements", !collection.retainAll(elements));
+ verify();
+ assertEquals("Collection size shouldn't change", size, collection.size());
+
+ resetFull();
+ HashSet set = new HashSet(elements);
+ size = collection.size();
+ assertTrue(
+ "Collection shouldn't change from retainAll without " + "duplicate elements",
+ !collection.retainAll(set));
+ verify();
+ assertEquals(
+ "Collection size didn't change from nonduplicate " + "retainAll", size, collection.size());
+ }
+
+ /** Tests {@link Collection#size()}. */
+ public void testCollectionSize() {
+ resetEmpty();
+ assertEquals("Size of new Collection is 0.", 0, collection.size());
+
+ resetFull();
+ assertTrue("Size of full collection should be greater than zero", collection.size() > 0);
+ }
+
+ /** Tests <Code>toString</Code> on a collection. */
+ public void testCollectionToString() {
+ resetEmpty();
+ assertTrue("toString shouldn't return null", collection.toString() != null);
+
+ resetFull();
+ assertTrue("toString shouldn't return null", collection.toString() != null);
+ }
+
+ /**
+ * If isRemoveSupported() returns false, tests to see that remove operations raise an
+ * UnsupportedOperationException.
+ */
+ public void testUnsupportedRemove() {
+ if (isRemoveSupported()) {
+ return;
+ }
+
+ resetEmpty();
+ try {
+ collection.clear();
+ fail("clear should raise UnsupportedOperationException");
+ } catch (UnsupportedOperationException e) {
+ // expected
+ }
+ verify();
+
+ try {
+ collection.remove(null);
+ fail("remove should raise UnsupportedOperationException");
+ } catch (UnsupportedOperationException e) {
+ // expected
+ }
+ verify();
+
+ try {
+ collection.removeAll(null);
+ fail("removeAll should raise UnsupportedOperationException");
+ } catch (UnsupportedOperationException e) {
+ // expected
+ }
+ verify();
+
+ try {
+ collection.retainAll(null);
+ fail("removeAll should raise UnsupportedOperationException");
+ } catch (UnsupportedOperationException e) {
+ // expected
+ }
+ verify();
+
+ resetFull();
+ try {
+ Iterator iterator = collection.iterator();
+ iterator.next();
+ iterator.remove();
+ fail("iterator.remove should raise UnsupportedOperationException");
+ } catch (UnsupportedOperationException e) {
+ // expected
+ }
+ verify();
+ }
+
+ /**
+ * Returns a list of elements suitable for return by {@link #getFullElements()}. The array
+ * returned by this method does not include null, but does include a variety of objects of
+ * different types. Override getFullElements to return the results of this method if your
+ * collection does not support the null element.
+ */
+ public static Object[] getFullNonNullElements() {
+ return new Object[] {
+ "",
+ "One",
+ new Integer(2),
+ "Three",
+ new Integer(4),
+ "One",
+ new Double(5),
+ new Float(6),
+ "Seven",
+ "Eight",
+ "Nine",
+ new Integer(10),
+ new Short((short) 11),
+ new Long(12),
+ "Thirteen",
+ "14",
+ "15",
+ new Byte((byte) 16)
+ };
+ }
+
+ /**
+ * Returns the default list of objects returned by {@link #getOtherElements()}. Includes many
+ * objects of different types.
+ */
+ public static Object[] getOtherNonNullElements() {
+ return new Object[] {
+ new Integer(0),
+ new Float(0),
+ new Double(0),
+ "Zero",
+ new Short((short) 0),
+ new Byte((byte) 0),
+ new Long(0),
+ new Character('\u0000'),
+ "0"
+ };
+ }
+
+ /**
+ * Returns a list of string elements suitable for return by {@link #getFullElements()}. Override
+ * getFullElements to return the results of this method if your collection does not support
+ * heterogeneous elements or the null element.
+ */
+ public static Object[] getFullNonNullStringElements() {
+ return new Object[] {
+ "If",
+ "the",
+ "dull",
+ "substance",
+ "of",
+ "my",
+ "flesh",
+ "were",
+ "thought",
+ "Injurious",
+ "distance",
+ "could",
+ "not",
+ "stop",
+ "my",
+ "way",
+ };
+ }
+
+ /**
+ * Returns a list of string elements suitable for return by {@link #getOtherElements()}. Override
+ * getOtherElements to return the results of this method if your collection does not support
+ * heterogeneous elements or the null element.
+ */
+ public static Object[] getOtherNonNullStringElements() {
+ return new Object[] {
+ "For", "then", "despite", /* of */ "space", "I", "would", "be", "brought",
+ "From", "limits", "far", "remote", "where", "thou", "dost", "stay"
+ };
+ }
+}
diff --git a/user/test/com/google/gwt/emultest/java/util/TestComparator.java b/user/test/com/google/gwt/emultest/java/util/TestComparator.java
new file mode 100644
index 0000000..8c04bb8
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/util/TestComparator.java
@@ -0,0 +1,121 @@
+// CHECKSTYLE_OFF: Copyrighted to ASF
+/*
+ * Copyright 1999-2004 The Apache Software Foundation
+ *
+ * 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.
+ */
+// CHECKSTYLE_ON
+package com.google.gwt.emultest.java.util;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+@SuppressWarnings({"unchecked", "rawtypes"})
+abstract class TestComparator extends TestObject {
+
+ public abstract Comparator makeComparator();
+
+ public abstract List getComparableObjectsOrdered();
+
+ @Override
+ public Object makeObject() {
+ return makeComparator();
+ }
+
+ /**
+ * There were no Comparators in version 1.x.
+ *
+ * @return 2
+ */
+ @Override
+ public int getCompatibilityVersion() {
+ return 2;
+ }
+
+ public void reverseObjects(List list) {
+ Collections.reverse(list);
+ }
+
+ /**
+ * Sort object according to the given Comparator.
+ *
+ * @param list List to sort
+ * @param comparator sorting comparator
+ */
+ public void sortObjects(List list, Comparator comparator) {
+
+ Collections.sort(list, comparator);
+ }
+
+ @Override
+ public boolean supportsEmptyCollections() {
+ return false;
+ }
+
+ @Override
+ public boolean supportsFullCollections() {
+ return false;
+ }
+
+ public void testEmptyListSort() {
+ List list = new ArrayList();
+ sortObjects(list, makeComparator());
+
+ List list2 = new ArrayList();
+
+ assertTrue("Comparator cannot sort empty lists", list2.equals(list));
+ }
+
+ public void testReverseListSort() {
+ Comparator comparator = makeComparator();
+
+ List randomList = getComparableObjectsOrdered();
+ reverseObjects(randomList);
+ sortObjects(randomList, comparator);
+
+ List orderedList = getComparableObjectsOrdered();
+
+ assertTrue("Comparator did not reorder the List correctly", orderedList.equals(randomList));
+ }
+
+ public String getCanonicalComparatorName(Object object) {
+ StringBuilder retval = new StringBuilder();
+ retval.append("data/test/");
+ String colName = object.getClass().getName();
+ colName = colName.substring(colName.lastIndexOf(".") + 1);
+ retval.append(colName);
+ retval.append(".version");
+ retval.append(getCompatibilityVersion());
+ retval.append(".obj");
+ return retval.toString();
+ }
+
+ /** Compare the current serialized form of the Comparator against the canonical version in CVS. */
+ public void testComparatorCompatibility() {
+ Comparator comparator = null;
+
+ // make sure the canonical form produces the ordering we currently
+ // expect
+ List randomList = getComparableObjectsOrdered();
+ reverseObjects(randomList);
+ sortObjects(randomList, comparator);
+
+ List orderedList = getComparableObjectsOrdered();
+
+ assertTrue(
+ "Comparator did not reorder the List correctly:" + randomList,
+ orderedList.equals(randomList));
+ }
+}
diff --git a/user/test/com/google/gwt/emultest/java/util/TestIterator.java b/user/test/com/google/gwt/emultest/java/util/TestIterator.java
new file mode 100644
index 0000000..49df5ea
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/util/TestIterator.java
@@ -0,0 +1,102 @@
+// CHECKSTYLE_OFF: Copyrighted to ASF
+/*
+ * Copyright 1999-2004 The Apache Software Foundation
+ *
+ * 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.
+ */
+// CHECKSTYLE_ON
+package com.google.gwt.emultest.java.util;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/** Base class for testing Iterator interface */
+@SuppressWarnings("rawtypes")
+abstract class TestIterator extends TestObject {
+
+ public abstract Iterator makeEmptyIterator();
+
+ public abstract Iterator makeFullIterator();
+
+ /**
+ * Whether or not we are testing an iterator that can be empty. Default is true.
+ *
+ * @return true if Iterators can be empty
+ */
+ public boolean supportsEmptyIterator() {
+ return true;
+ }
+
+ /**
+ * Whether or not we are testing an iterator that can contain elements. Default is true.
+ *
+ * @return true if Iterators can be empty
+ */
+ public boolean supportsFullIterator() {
+ return true;
+ }
+
+ /**
+ * Whether or not we are testing an iterator that supports remove. Default is true.
+ *
+ * @return true if Iterators can remove elements
+ */
+ public boolean supportsRemove() {
+ return true;
+ }
+
+ /** Should throw a NoSuchElementException. */
+ public void testEmptyIterator() {
+ if (!supportsEmptyIterator()) {
+ return;
+ }
+
+ Iterator iter = makeEmptyIterator();
+ assertTrue("hasNext() should return false for empty iterators", !iter.hasNext());
+ try {
+ iter.next();
+ fail("NoSuchElementException must be thrown when Iterator is exhausted");
+ } catch (NoSuchElementException e) {
+ }
+ }
+
+ /**
+ * NoSuchElementException (or any other exception) should not be thrown for the first element.
+ * NoSuchElementException must be thrown when hasNext() returns false
+ */
+ public void testFullIterator() {
+ if (!supportsFullIterator()) {
+ return;
+ }
+
+ Iterator iter = makeFullIterator();
+
+ assertTrue("hasNext() should return true for at least one element", iter.hasNext());
+
+ try {
+ iter.next();
+ } catch (NoSuchElementException e) {
+ fail("Full iterators must have at least one element");
+ }
+
+ while (iter.hasNext()) {
+ iter.next();
+ }
+
+ try {
+ iter.next();
+ fail("NoSuchElementException must be thrown when Iterator is exhausted");
+ } catch (NoSuchElementException e) {
+ }
+ }
+}
diff --git a/user/test/com/google/gwt/emultest/java/util/TestList.java b/user/test/com/google/gwt/emultest/java/util/TestList.java
new file mode 100644
index 0000000..9613a8f
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/util/TestList.java
@@ -0,0 +1,627 @@
+// CHECKSTYLE_OFF: Copyrighted to ASF
+/*
+ * Copyright 1999-2004 The Apache Software Foundation
+ *
+ * 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.
+ */
+// CHECKSTYLE_ON
+package com.google.gwt.emultest.java.util;
+
+import java.util.AbstractCollection;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+
+/**
+ * Tests base {@link java.util.List} methods and contracts.
+ *
+ * <p>To use, simply extend this class, and implement the {@link #makeList} method.
+ *
+ * <p>If your {@link List} fails one of these tests by design, you may still use this base set of
+ * cases. Simply override the test case (method) your {@link List} fails.
+ */
+@SuppressWarnings({"unchecked", "rawtypes"})
+abstract class TestList extends TestCollection {
+
+ /**
+ * Return a new, empty {@link List} to be used for testing.
+ *
+ * @return an empty list for testing.
+ */
+ protected abstract List makeEmptyList();
+
+ /**
+ * Return a new, full {@link List} to be used for testing.
+ *
+ * @return a full list for testing
+ */
+ protected List makeFullList() {
+ // only works if list supports optional "addAll(Collection)"
+ List list = makeEmptyList();
+ list.addAll(Arrays.asList(getFullElements()));
+ return list;
+ }
+
+ /**
+ * Returns {@link makeEmptyList()}.
+ *
+ * @return an empty list to be used for testing
+ */
+ @Override
+ protected final Collection makeCollection() {
+ return makeEmptyList();
+ }
+
+ /**
+ * Returns {@link makeFullList()}.
+ *
+ * @return a full list to be used for testing
+ */
+ @Override
+ protected final Collection makeFullCollection() {
+ return makeFullList();
+ }
+
+ /**
+ * Whether or not we are testing an iterator that can be empty. Default is true.
+ *
+ * @return true if Iterators can be empty
+ */
+ public boolean supportsEmptyIterator() {
+ return true;
+ }
+
+ /**
+ * Whether or not we are testing an list that allows element set. Default is true.
+ *
+ * @return true if Lists support element set
+ */
+ public boolean isSetSupported() {
+ return true;
+ }
+
+ /**
+ * Returns the {@link collection} field cast to a {@link List}.
+ *
+ * @return the collection field as a List
+ */
+ protected List getList() {
+ return (List) collection;
+ }
+
+ /**
+ * Returns the {@link confirmed} field cast to a {@link List}.
+ *
+ * @return the confirmed field as a List
+ */
+ protected List getConfirmedList() {
+ return (List) confirmed;
+ }
+
+ public class TestListIterator extends AbstractTestListIterator {
+
+ @Override
+ public Object addSetValue() {
+ return TestList.this.getOtherElements()[0];
+ }
+
+ @Override
+ public boolean supportsRemove() {
+ return TestList.this.isRemoveSupported();
+ }
+
+ @Override
+ public boolean supportsAdd() {
+ return TestList.this.isAddSupported();
+ }
+
+ @Override
+ public boolean supportsSet() {
+ return TestList.this.isSetSupported();
+ }
+
+ @Override
+ public ListIterator makeEmptyListIterator() {
+ resetEmpty();
+ return ((List) TestList.this.collection).listIterator();
+ }
+
+ @Override
+ public ListIterator makeFullListIterator() {
+ resetFull();
+ return ((List) TestList.this.collection).listIterator();
+ }
+
+ @Override
+ public Object makeObject() {
+ return ((List) TestList.this.collection).listIterator();
+ }
+ }
+
+ /** Tests the read-only bits of {@link List#listIterator()}. */
+ public void testListListIterator() {
+ resetFull();
+ forwardTest(getList().listIterator(), 0);
+ backwardTest(getList().listIterator(), 0);
+ }
+
+ /** Tests the read-only bits of {@link List#listIterator(int)}. */
+ public void testListListIteratorByIndex() {
+ resetFull();
+ try {
+ getList().listIterator(-1);
+ } catch (IndexOutOfBoundsException ex) {
+ }
+ resetFull();
+ try {
+ getList().listIterator(getList().size() + 1);
+ } catch (IndexOutOfBoundsException ex) {
+ }
+ resetFull();
+ for (int i = 0; i <= confirmed.size(); i++) {
+ forwardTest(getList().listIterator(i), i);
+ backwardTest(getList().listIterator(i), i);
+ }
+ resetFull();
+ for (int i = 0; i <= confirmed.size(); i++) {
+ backwardTest(getList().listIterator(i), i);
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ /** Tests remove on list iterator is correct. */
+ public void testListListIteratorPreviousRemoveNext() {
+ if (!isRemoveSupported()) {
+ return;
+ }
+ resetFull();
+ if (collection.size() < 4) {
+ return;
+ }
+ ListIterator it = getList().listIterator();
+ Object zero = it.next();
+ Object one = it.next();
+ Object two = it.next();
+ Object two2 = it.previous();
+ Object one2 = it.previous();
+ assertEquals(one, one2);
+ assertEquals(two, two2);
+ assertEquals(zero, getList().get(0));
+ assertEquals(one, getList().get(1));
+ assertEquals(two, getList().get(2));
+
+ it.remove(); // removed element at index 1 (one)
+ assertEquals(zero, getList().get(0));
+ assertEquals(two, getList().get(1));
+ Object two3 = it.next(); // do next after remove
+ assertEquals(two, two3);
+ assertEquals(collection.size() > 2, it.hasNext());
+ assertTrue(it.hasPrevious());
+ }
+
+ /** Tests remove on list iterator is correct. */
+ public void testListListIteratorPreviousRemovePrevious() {
+ if (!isRemoveSupported()) {
+ return;
+ }
+ resetFull();
+ if (collection.size() < 4) {
+ return;
+ }
+ ListIterator it = getList().listIterator();
+ Object zero = it.next();
+ Object one = it.next();
+ Object two = it.next();
+ Object two2 = it.previous();
+ Object one2 = it.previous();
+ assertEquals(one, one2);
+ assertEquals(two, two2);
+ assertEquals(zero, getList().get(0));
+ assertEquals(one, getList().get(1));
+ assertEquals(two, getList().get(2));
+
+ it.remove(); // removed element at index 1 (one)
+ assertEquals(zero, getList().get(0));
+ assertEquals(two, getList().get(1));
+ Object zero3 = it.previous(); // do previous after remove
+ assertEquals(zero, zero3);
+ assertEquals(false, it.hasPrevious());
+ assertEquals(collection.size() > 2, it.hasNext());
+ }
+
+ /** Tests remove on list iterator is correct. */
+ public void testListListIteratorNextRemoveNext() {
+ if (!isRemoveSupported()) {
+ return;
+ }
+ resetFull();
+ if (collection.size() < 4) {
+ return;
+ }
+ ListIterator it = getList().listIterator();
+ Object zero = it.next();
+ Object one = it.next();
+ Object two = it.next();
+ assertEquals(zero, getList().get(0));
+ assertEquals(one, getList().get(1));
+ assertEquals(two, getList().get(2));
+ Object three = getList().get(3);
+
+ it.remove(); // removed element at index 2 (two)
+ assertEquals(zero, getList().get(0));
+ assertEquals(one, getList().get(1));
+ Object three2 = it.next(); // do next after remove
+ assertEquals(three, three2);
+ assertEquals(collection.size() > 3, it.hasNext());
+ assertEquals(true, it.hasPrevious());
+ }
+
+ /** Tests remove on list iterator is correct. */
+ public void testListListIteratorNextRemovePrevious() {
+ if (!isRemoveSupported()) {
+ return;
+ }
+ resetFull();
+ if (collection.size() < 4) {
+ return;
+ }
+ ListIterator it = getList().listIterator();
+ Object zero = it.next();
+ Object one = it.next();
+ Object two = it.next();
+ assertEquals(zero, getList().get(0));
+ assertEquals(one, getList().get(1));
+ assertEquals(two, getList().get(2));
+
+ it.remove(); // removed element at index 2 (two)
+ assertEquals(zero, getList().get(0));
+ assertEquals(one, getList().get(1));
+ Object one2 = it.previous(); // do previous after remove
+ assertEquals(one, one2);
+ assertEquals(true, it.hasNext());
+ assertEquals(true, it.hasPrevious());
+ }
+
+ // -----------------------------------------------------------------------
+ /**
+ * Traverses to the end of the given iterator.
+ *
+ * @param iter the iterator to traverse
+ * @param i the starting index
+ */
+ private void forwardTest(ListIterator iter, int i) {
+ List list = getList();
+ int max = getFullElements().length;
+
+ while (i < max) {
+ assertTrue("Iterator should have next", iter.hasNext());
+ assertEquals("Iterator.nextIndex should work", iter.nextIndex(), i);
+ assertEquals("Iterator.previousIndex should work", iter.previousIndex(), i - 1);
+ Object o = iter.next();
+ assertEquals("Iterator returned correct element f", list.get(i), o);
+ i++;
+ }
+
+ assertTrue("Iterator shouldn't have next", !iter.hasNext());
+ assertEquals("nextIndex should be size", iter.nextIndex(), max);
+ assertEquals("previousIndex should be size - 1", iter.previousIndex(), max - 1);
+
+ try {
+ iter.next();
+ fail("Exhausted iterator should raise NoSuchElement");
+ } catch (NoSuchElementException e) {
+ // expected
+ }
+ }
+
+ /**
+ * Traverses to the beginning of the given iterator.
+ *
+ * @param iter the iterator to traverse
+ * @param i the starting index
+ */
+ private void backwardTest(ListIterator iter, int i) {
+ List list = getList();
+
+ while (i > 0) {
+ assertTrue("Iterator should have previous, i:" + i, iter.hasPrevious());
+ assertEquals("Iterator.nextIndex should work, i:" + i, iter.nextIndex(), i);
+ assertEquals("Iterator.previousIndex should work, i:" + i, iter.previousIndex(), i - 1);
+ Object o = iter.previous();
+ assertEquals("Iterator returned correct element b", list.get(i - 1), o);
+ i--;
+ }
+
+ assertTrue("Iterator shouldn't have previous", !iter.hasPrevious());
+ int nextIndex = iter.nextIndex();
+ assertEquals("nextIndex should be 0, actual value: " + nextIndex, 0, nextIndex);
+ int prevIndex = iter.previousIndex();
+ assertEquals("previousIndex should be -1, actual value: " + prevIndex, -1, prevIndex);
+
+ try {
+ iter.previous();
+ fail("Exhausted iterator should raise NoSuchElement");
+ } catch (NoSuchElementException e) {
+ // expected
+ }
+ }
+
+ /** Tests the {@link ListIterator#add(Object)} method of the list iterator. */
+ public void testListIteratorAdd() {
+ if (!isAddSupported()) {
+ return;
+ }
+
+ resetEmpty();
+ List list1 = getList();
+ List list2 = getConfirmedList();
+
+ Object[] elements = getFullElements();
+ ListIterator iter1 = list1.listIterator();
+ ListIterator iter2 = list2.listIterator();
+
+ for (int i = 0; i < elements.length; i++) {
+ iter1.add(elements[i]);
+ iter2.add(elements[i]);
+ verify();
+ }
+
+ resetFull();
+ iter1 = getList().listIterator();
+ iter2 = getConfirmedList().listIterator();
+ for (int i = 0; i < elements.length; i++) {
+ iter1.next();
+ iter2.next();
+ iter1.add(elements[i]);
+ iter2.add(elements[i]);
+ verify();
+ }
+ }
+
+ /** Tests the {@link ListIterator#set(Object)} method of the list iterator. */
+ public void testListIteratorSet() {
+ if (!isSetSupported()) {
+ return;
+ }
+
+ Object[] elements = getFullElements();
+
+ resetFull();
+ ListIterator iter1 = getList().listIterator();
+ ListIterator iter2 = getConfirmedList().listIterator();
+ for (int i = 0; i < elements.length; i++) {
+ iter1.next();
+ iter2.next();
+ iter1.set(elements[i]);
+ iter2.set(elements[i]);
+ verify();
+ }
+ }
+
+ /** Tests {@link List#add(int,Object)}. */
+ public void testListAddByIndex() {
+ if (!isAddSupported()) {
+ return;
+ }
+
+ Object element = getOtherElements()[0];
+ int max = getFullElements().length;
+
+ for (int i = 0; i <= max; i++) {
+ resetFull();
+ ((List) collection).add(i, element);
+ ((List) confirmed).add(i, element);
+ verify();
+ }
+ }
+
+ /** Tests {@link List#equals(Object)}. */
+ public void testListEquals() {
+ resetEmpty();
+ List list = getList();
+ assertTrue("Empty lists should be equal", list.equals(confirmed));
+ verify();
+ assertTrue("Empty list should equal self", list.equals(list));
+ verify();
+
+ List list2 = Arrays.asList(getFullElements());
+ assertTrue("Empty list shouldn't equal full", !list.equals(list2));
+ verify();
+
+ list2 = Arrays.asList(getOtherElements());
+ assertTrue("Empty list shouldn't equal other", !list.equals(list2));
+ verify();
+
+ resetFull();
+ list = getList();
+ assertTrue("Full lists should be equal", list.equals(confirmed));
+ verify();
+ assertTrue("Full list should equal self", list.equals(list));
+ verify();
+
+ list2 = makeEmptyList();
+ assertTrue("Full list shouldn't equal empty", !list.equals(list2));
+ verify();
+
+ list2 = Arrays.asList(getOtherElements());
+ assertTrue("Full list shouldn't equal other", !list.equals(list2));
+ verify();
+
+ list2 = Arrays.asList(getFullElements());
+ Collections.reverse(list2);
+ assertTrue(
+ "Full list shouldn't equal full list with same elements" + " but different order",
+ !list.equals(list2));
+ verify();
+
+ assertTrue("List shouldn't equal String", !list.equals(""));
+ verify();
+
+ final List listForC = Arrays.asList(getFullElements());
+ Collection c =
+ new AbstractCollection() {
+ @Override
+ public int size() {
+ return listForC.size();
+ }
+
+ @Override
+ public Iterator iterator() {
+ return listForC.iterator();
+ }
+ };
+
+ assertTrue(
+ "List shouldn't equal nonlist with same elements " + " in same order", !list.equals(c));
+ verify();
+ }
+
+ /** Tests {@link List#hashCode()}. */
+ public void testListHashCode() {
+ resetEmpty();
+ int hash1 = collection.hashCode();
+ int hash2 = confirmed.hashCode();
+ assertEquals("Empty lists should have equal hashCodes", hash1, hash2);
+ verify();
+
+ resetFull();
+ hash1 = collection.hashCode();
+ hash2 = confirmed.hashCode();
+ assertEquals("Full lists should have equal hashCodes", hash1, hash2);
+ verify();
+ }
+
+ /** Tests {@link List#get(int)}. */
+ public void testListGetByIndex() {
+ resetFull();
+ List list = getList();
+ Object[] elements = getFullElements();
+ for (int i = 0; i < elements.length; i++) {
+ assertEquals("List should contain correct elements", elements[i], list.get(i));
+ verify();
+ }
+ }
+
+ /** Tests {@link List#indexOf()}. */
+ public void testListIndexOf() {
+ resetFull();
+ List list1 = getList();
+ List list2 = getConfirmedList();
+
+ Iterator iterator = list2.iterator();
+ while (iterator.hasNext()) {
+ Object element = iterator.next();
+ assertEquals(
+ "indexOf should return correct result", list1.indexOf(element), list2.indexOf(element));
+ verify();
+ }
+
+ Object[] other = getOtherElements();
+ for (int i = 0; i < other.length; i++) {
+ assertEquals("indexOf should return -1 for nonexistent element", -1, list1.indexOf(other[i]));
+ verify();
+ }
+ }
+
+ /** Tests {@link List#lastIndexOf()}. */
+ public void testListLastIndexOf() {
+ resetFull();
+ List list1 = getList();
+ List list2 = getConfirmedList();
+
+ Iterator iterator = list2.iterator();
+ while (iterator.hasNext()) {
+ Object element = iterator.next();
+ assertEquals(
+ "lastIndexOf should return correct result",
+ list1.lastIndexOf(element),
+ list2.lastIndexOf(element));
+ verify();
+ }
+
+ Object[] other = getOtherElements();
+ for (int i = 0; i < other.length; i++) {
+ assertEquals(
+ "lastIndexOf should return -1 for nonexistent " + "element",
+ -1,
+ list1.lastIndexOf(other[i]));
+ verify();
+ }
+ }
+
+ /** Tests {@link List#remove(int)}. */
+ public void testListRemoveByIndex() {
+ if (!isRemoveSupported()) {
+ return;
+ }
+
+ int max = getFullElements().length;
+ for (int i = 0; i < max; i++) {
+ resetFull();
+ Object o1 = ((List) collection).remove(i);
+ Object o2 = ((List) confirmed).remove(i);
+ assertEquals("remove should return correct element", o1, o2);
+ verify();
+ }
+ }
+
+ /** Returns an empty {@link ArrayList}. */
+ @Override
+ protected Collection makeConfirmedCollection() {
+ ArrayList list = new ArrayList();
+ return list;
+ }
+
+ /** Returns a full {@link ArrayList}. */
+ @Override
+ protected Collection makeConfirmedFullCollection() {
+ ArrayList list = new ArrayList();
+ list.addAll(Arrays.asList(getFullElements()));
+ return list;
+ }
+
+ /** Verifies that the test list implementation matches the confirmed list implementation. */
+ @Override
+ protected void verify() {
+ super.verify();
+
+ List list1 = getList();
+ List list2 = getConfirmedList();
+
+ assertEquals("List should equal confirmed", list1, list2);
+ assertEquals("Confirmed should equal list", list2, list1);
+
+ assertEquals("Hash codes should be equal", list1.hashCode(), list2.hashCode());
+
+ int i = 0;
+ Iterator iterator1 = list1.iterator();
+ Iterator iterator2 = list2.iterator();
+ Object[] array = list1.toArray();
+ while (iterator2.hasNext()) {
+ assertTrue("List iterator should have next", iterator1.hasNext());
+ Object o1 = iterator1.next();
+ Object o2 = iterator2.next();
+ assertEquals("Iterator elements should be equal", o1, o2);
+ o2 = list1.get(i);
+ assertEquals("get should return correct element", o1, o2);
+ o2 = array[i];
+ assertEquals("toArray should have correct element", o1, o2);
+ i++;
+ }
+ }
+}
diff --git a/user/test/com/google/gwt/emultest/java/util/TestMap.java b/user/test/com/google/gwt/emultest/java/util/TestMap.java
new file mode 100644
index 0000000..bded458
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/util/TestMap.java
@@ -0,0 +1,1137 @@
+// CHECKSTYLE_OFF: Copyrighted to ASF
+/*
+ * Copyright 1999-2004 The Apache Software Foundation
+ *
+ * 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.
+ */
+// CHECKSTYLE_ON
+package com.google.gwt.emultest.java.util;
+
+import com.google.gwt.testing.TestUtils;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.ConcurrentModificationException;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import jsinterop.annotations.JsPackage;
+import jsinterop.annotations.JsProperty;
+
+/**
+ * Tests base {@link java.util.Map} methods and contracts.
+ * <p>
+ * The forces at work here are similar to those in {@link TestCollection}.
+ * If your class implements the full Map interface, including optional
+ * operations, simply extend this class, and implement the {@link
+ * #makeEmptyMap()} method.
+ * <p>
+ * On the other hand, if your map implemenation is weird, you may have to
+ * override one or more of the other protected methods. They're described
+ * below.<P>
+ *
+ * <B>Entry Population Methods</B><P>
+ *
+ * Override these methods if your map requires special entries:
+ *
+ * <UL>
+ * <LI>{@link #getSampleKeys()}
+ * <LI>{@link #getSampleValues()}
+ * <LI>{@link #getNewSampleValues()}
+ * <LI>{@link #getOtherKeys()}
+ * <LI>{@link #getOtherValues()}
+ * </UL>
+ *
+ * <B>Supported Operation Methods</B><P>
+ *
+ * Override these methods if your map doesn't support certain operations:
+ *
+ * <UL>
+ * <LI> {@link #useDuplicateValues()}
+ * <LI> {@link #useNullKey()}
+ * <LI> {@link #useNullValue()}
+ * <LI> {@link #isAddRemoveModifiable()}
+ * <LI> {@link #isChangeable()}
+ * </UL>
+ *
+ * <B>Fixture Methods</B><P>
+ *
+ * For tests on modification operations (puts and removes), fixtures are used
+ * to verify that that operation results in correct state for the map and its
+ * collection views. Basically, the modification is performed against your
+ * map implementation, and an identical modification is performed against
+ * a <I>confirmed</I> map implementation. A confirmed map implementation is
+ * something like <Code>java.util.HashMap</Code>, which is known to conform
+ * exactly to the {@link Map} contract. After the modification takes place
+ * on both your map implementation and the confirmed map implementation, the
+ * two maps are compared to see if their state is identical. The comparison
+ * also compares the collection views to make sure they're still the same.<P>
+ *
+ * The upshot of all that is that <I>any</I> test that modifies the map in
+ * <I>any</I> way will verify that <I>all</I> of the map's state is still
+ * correct, including the state of its collection views. So for instance
+ * if a key is removed by the map's key set's iterator, then the entry set
+ * is checked to make sure the key/value pair no longer appears.<P>
+ *
+ * The {@link #map} field holds an instance of your collection implementation.
+ * The {@link #entrySet}, {@link #keySet} and {@link #collectionValues} fields hold
+ * that map's collection views. And the {@link #confirmed} field holds
+ * an instance of the confirmed collection implementation. The
+ * {@link #resetEmpty()} and {@link #resetFull()} methods set these fields to
+ * empty or full maps, so that tests can proceed from a known state.<P>
+ *
+ * After a modification operation to both {@link #map} and {@link #confirmed},
+ * the {@link #verify()} method is invoked to compare the results. The {@link
+ * verify()} method calls separate methods to verify the map and its three
+ * collection views ({@link verifyMap(), {@link verifyEntrySet()}, {@link
+ * verifyKeySet()}, and {@link verifyValues()}). You may want to override one
+ * of the verification methodsto perform additional verifications. For
+ * instance, {@link TestDoubleOrderedMap} would want override its {@link
+ * #verifyValues()} method to verify that the values are unique and in
+ * ascending order.<P>
+ *
+ * <B>Other Notes</B><P>
+ *
+ * If your {@link Map} fails one of these tests by design, you may still use
+ * this base set of cases. Simply override the test case (method) your {@link
+ * Map} fails and/or the methods that define the assumptions used by the test
+ * cases. For example, if your map does not allow duplicate values, override
+ * {@link #useDuplicateValues()} and have it return <code>false</code>
+ */
+@SuppressWarnings({"unchecked", "rawtypes"})
+abstract class TestMap extends TestObject {
+
+ // These instance variables are initialized with the reset method.
+ // Tests for map methods that alter the map (put, putAll, remove)
+ // first call reset() to create the map and its views; then perform
+ // the modification on the map; perform the same modification on the
+ // confirmed; and then call verify() to ensure that the map is equal
+ // to the confirmed, that the already-constructed collection views
+ // are still equal to the confirmed's collection views.
+
+ /** Map created by reset(). */
+ protected Map map;
+
+ /** Entry set of map created by reset(). */
+ protected Set entrySet;
+
+ /** Key set of map created by reset(). */
+ protected Set keySet;
+
+ /** Values collection of map created by reset(). */
+ protected Collection collectionValues;
+
+ /** HashMap created by reset(). */
+ protected Map confirmed;
+
+ /**
+ * Override if your map does not allow a <code>null</code> key. The default implementation returns
+ * <code>true</code>
+ */
+ protected boolean useNullKey() {
+ return true;
+ }
+
+ /**
+ * Override if your map does not allow <code>null</code> values. The default implementation
+ * returns <code>true</code>.
+ */
+ protected boolean useNullValue() {
+ return true;
+ }
+
+ /**
+ * Override if your map does not allow duplicate values. The default implementation returns <code>
+ * true</code>.
+ */
+ protected boolean useDuplicateValues() {
+ return true;
+ }
+
+ /**
+ * Override if your map allows its mappings to be changed to new values. The default
+ * implementation returns <code>true</code>.
+ */
+ protected boolean isChangeable() {
+ return true;
+ }
+
+ /**
+ * Override if your map does not allow add/remove modifications. The default implementation
+ * returns <code>true</code>.
+ */
+ protected boolean isAddRemoveModifiable() {
+ return true;
+ }
+
+ /**
+ * Override if your map allows concurrent modifications. The default implementation returns <code>
+ * true</code>.
+ */
+ protected boolean isFailFastExpected() {
+ return true;
+ }
+
+ /**
+ * Returns the set of keys in the mappings used to test the map. This method must return an array
+ * with the same length as {@link #getSampleValues()} and all array elements must be different.
+ * The default implementation constructs a set of String keys, and includes a single null key if
+ * {@link #useNullKey()} returns <code>true</code>.
+ */
+ protected Object[] getSampleKeys() {
+ Object[] result = {
+ "blah",
+ "foo",
+ "bar",
+ "baz",
+ "tmp",
+ "gosh",
+ "golly",
+ "gee",
+ "hello",
+ "goodbye",
+ "we'll",
+ "see",
+ "you",
+ "all",
+ "again",
+ "key",
+ "key2",
+ useNullKey() ? null : "nonnullkey"
+ };
+ return result;
+ }
+
+ protected Object[] getOtherKeys() {
+ return TestCollection.getOtherNonNullStringElements();
+ }
+
+ protected Object[] getOtherValues() {
+ return TestCollection.getOtherNonNullStringElements();
+ }
+
+ /**
+ * Returns the set of values in the mappings used to test the map. This method must return an
+ * array with the same length as {@link #getSampleKeys()}. The default implementation contructs a
+ * set of String values and includes a single null value if {@link #useNullValue()} returns <code>
+ * true</code>, and includes two values that are the same if {@link #useDuplicateValues()} returns
+ * <code>true</code>.
+ */
+ protected Object[] getSampleValues() {
+ Object[] result = {
+ "blahv",
+ "foov",
+ "barv",
+ "bazv",
+ "tmpv",
+ "goshv",
+ "gollyv",
+ "geev",
+ "hellov",
+ "goodbyev",
+ "we'llv",
+ "seev",
+ "youv",
+ "allv",
+ "againv",
+ useNullValue() ? null : "nonnullvalue",
+ "value",
+ useDuplicateValues() ? "value" : "value2",
+ };
+ return result;
+ }
+
+ /**
+ * Returns a the set of values that can be used to replace the values returned from {@link
+ * #getSampleValues()}. This method must return an array with the same length as {@link
+ * #getSampleValues()}. The values returned from this method should not be the same as those
+ * returned from {@link #getSampleValues()}. The default implementation constructs a set of String
+ * values and includes a single null value if {@link #useNullValue()} returns <code>true</code>,
+ * and includes two values that are the same if {@link #useDuplicateValues()} returns <code>true
+ * </code>.
+ */
+ protected Object[] getNewSampleValues() {
+ Object[] result = {
+ useNullValue() ? null : "newnonnullvalue",
+ "newvalue",
+ useDuplicateValues() ? "newvalue" : "newvalue2",
+ "newblahv",
+ "newfoov",
+ "newbarv",
+ "newbazv",
+ "newtmpv",
+ "newgoshv",
+ "newgollyv",
+ "newgeev",
+ "newhellov",
+ "newgoodbyev",
+ "newwe'llv",
+ "newseev",
+ "newyouv",
+ "newallv",
+ "newagainv",
+ };
+ return result;
+ }
+
+ /**
+ * Helper method to add all the mappings described by {@link #getSampleKeys()} and {@link
+ * #getSampleValues()}.
+ */
+ protected void addSampleMappings(Map m) {
+
+ Object[] keys = getSampleKeys();
+ Object[] values = getSampleValues();
+
+ for (int i = 0; i < keys.length; i++) {
+ try {
+ m.put(keys[i], values[i]);
+ } catch (NullPointerException exception) {
+ assertTrue(
+ "NullPointerException only allowed to be thrown "
+ + "if either the key or value is null.",
+ keys[i] == null || values[i] == null);
+
+ if (keys[i] == null) {
+ if (useNullKey()) {
+ throw new Error(
+ "NullPointerException on null key, but "
+ + "useNullKey is not overridden to return false.",
+ exception);
+ }
+ } else if (values[i] == null) {
+ if (useNullValue()) {
+ throw new Error(
+ "NullPointerException on null value, but "
+ + "useNullValue is not overridden to return false.",
+ exception);
+ }
+ } else {
+ // Unknown reason for NullPointer.
+ throw exception;
+ }
+ }
+ }
+ assertEquals("size must reflect number of mappings added.", keys.length, m.size());
+ }
+
+ /** Return a new, empty {@link Map} to be used for testing. */
+ protected abstract Map makeEmptyMap();
+
+ protected Map makeConfirmedMap() {
+ return new HashMap();
+ }
+
+ /**
+ * Return a new, populated map. The mappings in the map should match the keys and values returned
+ * from {@link #getSampleKeys()} and {@link #getSampleValues()}. The default implementation uses
+ * makeEmptyMap() and calls {@link #addSampleMappings()} to add all the mappings to the map.
+ */
+ protected Map makeFullMap() {
+ Map m = makeEmptyMap();
+ addSampleMappings(m);
+ return m;
+ }
+
+ @Override
+ public Object makeObject() {
+ return makeEmptyMap();
+ }
+
+ public void testSpecialKeysValues() {
+ String[] keys = {"toString", "constructor", "__proto__", "", "null"};
+ Object[] values = {new Object(), new Object(), new Object(), new Object(), null};
+
+ Map map = makeEmptyMap();
+
+ assertMap(map, keys, values);
+
+ Object[] undefineds = new Object[values.length];
+ Arrays.fill(undefineds, getUndefined());
+ assertMap(map, keys, undefineds);
+ }
+
+ private void assertMap(Map map, String[] keys, Object[] values) {
+ assertEmptyMap(map, keys, values);
+
+ // Fill the map with special keys/values.
+ for (int i = 0; i < keys.length; i++) {
+ map.put(keys[i], values[i]);
+ }
+
+ // Assert the map with filled in keys/values
+ for (int i = 0; i < keys.length; i++) {
+ assertTrue(keys[i], map.containsKey(keys[i]));
+ assertTrue(keys[i], map.containsValue(values[i]));
+ assertSame(keys[i], values[i], map.get(keys[i]));
+ }
+ assertEquals(map.toString(), keys.length, map.size());
+
+ // Remove the keys and assert the results
+ for (int i = 0; i < keys.length; i++) {
+ assertSame(keys[i], values[i], map.remove(keys[i]));
+ }
+ assertEmptyMap(map, keys, values);
+ }
+
+ private static void assertEmptyMap(Map map, final String[] keys, final Object[] values) {
+ for (int i = 0; i < keys.length; i++) {
+ assertFalse(keys[i], map.containsKey(keys[i]));
+ assertFalse(keys[i], map.containsValue(values[i]));
+ assertNull(keys[i], map.get(keys[i]));
+ }
+ }
+
+ private static Object getUndefined() {
+ if (TestUtils.isJvm()) {
+ return null;
+ }
+ return getUndefinedImpl();
+ }
+
+ @JsProperty(name = "undefined", namespace = JsPackage.GLOBAL)
+ private static native Object getUndefinedImpl();
+
+ /**
+ * Test to ensure the test setup is working properly. This method checks to ensure that the
+ * getSampleKeys and getSampleValues methods are returning results that look appropriate. That is,
+ * they both return a non-null array of equal length. The keys array must not have any duplicate
+ * values, and may only contain a (single) null key if useNullKey() returns true. The values array
+ * must only have a null value if useNullValue() is true and may only have duplicate values if
+ * useDuplicateValues() returns true.
+ */
+ public void testSampleMappings() {
+ Object[] keys = getSampleKeys();
+ Object[] values = getSampleValues();
+ Object[] newValues = getNewSampleValues();
+
+ assertNotNull("failure in test: Must have keys returned from " + "getSampleKeys.", keys);
+
+ assertTrue(
+ "failure in test: Must have values returned from " + "getSampleValues.", values != null);
+
+ // verify keys and values have equivalent lengths (in case getSampleX are
+ // overridden)
+ assertEquals(
+ "failure in test: not the same number of sample " + "keys and values.",
+ keys.length,
+ values.length);
+
+ assertEquals(
+ "failure in test: not the same number of values and new values.",
+ values.length,
+ newValues.length);
+
+ // verify there aren't duplicate keys, and check values
+ for (int i = 0; i < keys.length - 1; i++) {
+ for (int j = i + 1; j < keys.length; j++) {
+ assertTrue("failure in test: duplicate null keys.", (keys[i] != null || keys[j] != null));
+ assertTrue(
+ "failure in test: duplicate non-null key.",
+ (keys[i] == null
+ || keys[j] == null
+ || (!keys[i].equals(keys[j]) && !keys[j].equals(keys[i]))));
+ }
+ assertTrue(
+ "failure in test: found null key, but useNullKey " + "is false.",
+ keys[i] != null || useNullKey());
+ assertTrue(
+ "failure in test: found null value, but useNullValue " + "is false.",
+ values[i] != null || useNullValue());
+ assertTrue(
+ "failure in test: found null new value, but useNullValue " + "is false.",
+ newValues[i] != null || useNullValue());
+ assertTrue(
+ "failure in test: values should not be the same as new value",
+ values[i] != newValues[i] && (values[i] == null || !values[i].equals(newValues[i])));
+ }
+ }
+
+ // tests begin here. Each test adds a little bit of tested functionality.
+ // Many methods assume previous methods passed. That is, they do not
+ // exhaustively recheck things that have already been checked in a previous
+ // test methods.
+
+ /**
+ * Test to ensure that makeEmptyMap and makeFull returns a new non-null map with each invocation.
+ */
+ public void testMakeMap() {
+ Map em = makeEmptyMap();
+ assertTrue("failure in test: makeEmptyMap must return a non-null map.", em != null);
+
+ Map em2 = makeEmptyMap();
+ assertTrue("failure in test: makeEmptyMap must return a non-null map.", em != null);
+
+ assertTrue(
+ "failure in test: makeEmptyMap must return a new map " + "with each invocation.",
+ em != em2);
+
+ Map fm = makeFullMap();
+ assertTrue("failure in test: makeFullMap must return a non-null map.", fm != null);
+
+ Map fm2 = makeFullMap();
+ assertTrue("failure in test: makeFullMap must return a non-null map.", fm != null);
+
+ assertTrue(
+ "failure in test: makeFullMap must return a new map " + "with each invocation.", fm != fm2);
+ }
+
+ /** Tests Map.isEmpty() */
+ public void testMapIsEmpty() {
+
+ resetEmpty();
+ assertEquals("Map.isEmpty() should return true with an empty map", true, map.isEmpty());
+ verify();
+
+ resetFull();
+ assertEquals("Map.isEmpty() should return false with a non-empty map", false, map.isEmpty());
+ verify();
+ }
+
+ /** Tests Map.size() */
+ public void testMapSize() {
+ resetEmpty();
+ assertEquals("Map.size() should be 0 with an empty map", 0, map.size());
+ verify();
+
+ resetFull();
+ assertEquals(
+ "Map.size() should equal the number of entries " + "in the map",
+ getSampleKeys().length,
+ map.size());
+ verify();
+ }
+
+ /**
+ * Tests {@link Map#clear()}. If the map {@link #isAddRemoveModifiable() can add and remove
+ * elements}, then {@link Map#size()} and {@link Map#isEmpty()} are used to ensure that map has no
+ * elements after a call to clear. If the map does not support adding and removing elements, this
+ * method checks to ensure clear throws an UnsupportedOperationException.
+ */
+ public void testMapClear() {
+ if (!isAddRemoveModifiable()) {
+ return;
+ }
+
+ resetEmpty();
+ map.clear();
+ confirmed.clear();
+ verify();
+
+ resetFull();
+ map.clear();
+ confirmed.clear();
+ verify();
+ }
+
+ /**
+ * Tests Map.containsKey(Object) by verifying it returns false for all sample keys on a map
+ * created using an empty map and returns true for all sample keys returned on a full map.
+ */
+ public void testMapContainsKey() {
+ Object[] keys = getSampleKeys();
+
+ resetEmpty();
+ for (int i = 0; i < keys.length; i++) {
+ assertTrue("Map must not contain key when map is empty", !map.containsKey(keys[i]));
+ }
+ verify();
+
+ resetFull();
+ for (int i = 0; i < keys.length; i++) {
+ assertTrue(
+ "Map must contain key for a mapping in the map. " + "Missing: " + keys[i],
+ map.containsKey(keys[i]));
+ }
+ verify();
+ }
+
+ /**
+ * Tests Map.containsValue(Object) by verifying it returns false for all sample values on an empty
+ * map and returns true for all sample values on a full map.
+ */
+ public void testMapContainsValue() {
+ Object[] values = getSampleValues();
+
+ resetEmpty();
+ for (int i = 0; i < values.length; i++) {
+ assertTrue("Empty map must not contain value", !map.containsValue(values[i]));
+ }
+ verify();
+
+ resetFull();
+ for (int i = 0; i < values.length; i++) {
+ assertTrue("Map must contain value for a mapping in the map.", map.containsValue(values[i]));
+ }
+ verify();
+ }
+
+ /** Tests Map.equals(Object) */
+ public void testMapEquals() {
+ resetEmpty();
+ assertTrue("Empty maps unequal.", map.equals(confirmed));
+ verify();
+
+ resetFull();
+ assertTrue("Full maps unequal.", map.equals(confirmed));
+ verify();
+
+ resetFull();
+ // modify the HashMap created from the full map and make sure this
+ // change results in map.equals() to return false.
+ Iterator iter = confirmed.keySet().iterator();
+ iter.next();
+ iter.remove();
+ assertTrue("Different maps equal.", !map.equals(confirmed));
+
+ resetFull();
+ assertTrue("equals(null) returned true.", !map.equals(null));
+ assertTrue("equals(new Object()) returned true.", !map.equals(new Object()));
+ verify();
+ }
+
+ /** Tests Map.get(Object) */
+ public void testMapGet() {
+ resetEmpty();
+
+ Object[] keys = getSampleKeys();
+ Object[] values = getSampleValues();
+
+ for (int i = 0; i < keys.length; i++) {
+ assertTrue("Empty map.get() should return null.", map.get(keys[i]) == null);
+ }
+ verify();
+
+ resetFull();
+ for (int i = 0; i < keys.length; i++) {
+ assertEquals("Full map.get() should return value from mapping.", values[i], map.get(keys[i]));
+ }
+ }
+
+ /** Tests Map.hashCode() */
+ public void testMapHashCode() {
+ resetEmpty();
+ assertTrue("Empty maps have different hashCodes.", map.hashCode() == confirmed.hashCode());
+
+ resetFull();
+ assertTrue("Equal maps have different hashCodes.", map.hashCode() == confirmed.hashCode());
+ }
+
+ /**
+ * Tests Map.toString(). Since the format of the string returned by the toString() method is not
+ * defined in the Map interface, there is no common way to test the results of the toString()
+ * method. Thereforce, it is encouraged that Map implementations override this test with one that
+ * checks the format matches any format defined in its API. This default implementation just
+ * verifies that the toString() method does not return null.
+ */
+ public void testMapToString() {
+ resetEmpty();
+ assertTrue("Empty map toString() should not return null", map.toString() != null);
+ verify();
+
+ resetFull();
+ assertTrue("Empty map toString() should not return null", map.toString() != null);
+ verify();
+ }
+
+ /** Tests Map.put(Object, Object) */
+ public void testMapPut() {
+ if (!isAddRemoveModifiable()) {
+ return;
+ }
+
+ resetEmpty();
+
+ Object[] keys = getSampleKeys();
+ Object[] values = getSampleValues();
+ Object[] newValues = getNewSampleValues();
+
+ for (int i = 0; i < keys.length; i++) {
+ Object o = map.put(keys[i], values[i]);
+ confirmed.put(keys[i], values[i]);
+ verify();
+ assertTrue("First map.put should return null", o == null);
+ assertTrue("Map should contain key after put", map.containsKey(keys[i]));
+ assertTrue("Map should contain value after put", map.containsValue(values[i]));
+ }
+
+ for (int i = 0; i < keys.length; i++) {
+ Object o = map.put(keys[i], newValues[i]);
+ confirmed.put(keys[i], newValues[i]);
+ verify();
+ assertEquals("Second map.put should return previous value", values[i], o);
+ assertTrue("Map should still contain key after put", map.containsKey(keys[i]));
+ assertTrue("Map should contain new value after put", map.containsValue(newValues[i]));
+
+ // if duplicates are allowed, we're not guarunteed that the value
+ // no longer exists, so don't try checking that.
+ if (!useDuplicateValues()) {
+ assertTrue(
+ "Map should not contain old value after second put", !map.containsValue(values[i]));
+ }
+ }
+ }
+
+ /** Tests Map.putAll(Collection) */
+ public void testMapPutAll() {
+ if (!isAddRemoveModifiable()) {
+ return;
+ }
+
+ resetEmpty();
+
+ Map m2 = makeFullMap();
+
+ map.putAll(m2);
+ confirmed.putAll(m2);
+ verify();
+
+ resetEmpty();
+
+ m2 = new HashMap();
+ Object[] keys = getSampleKeys();
+ Object[] values = getSampleValues();
+ for (int i = 0; i < keys.length; i++) {
+ m2.put(keys[i], values[i]);
+ }
+
+ map.putAll(m2);
+ confirmed.putAll(m2);
+ verify();
+ }
+
+ /** Tests Map.remove(Object) */
+ public void testMapRemove() {
+ if (!isAddRemoveModifiable()) {
+ return;
+ }
+
+ resetEmpty();
+
+ Object[] keys = getSampleKeys();
+ Object[] values = getSampleValues();
+ for (int i = 0; i < keys.length; i++) {
+ Object o = map.remove(keys[i]);
+ assertTrue("First map.remove should return null", o == null);
+ }
+ verify();
+
+ resetFull();
+
+ for (int i = 0; i < keys.length; i++) {
+ Object o = map.remove(keys[i]);
+ confirmed.remove(keys[i]);
+ verify();
+
+ assertEquals("map.remove with valid key should return value", values[i], o);
+ }
+
+ Object[] other = getOtherKeys();
+
+ resetFull();
+ int size = map.size();
+ for (int i = 0; i < other.length; i++) {
+ Object o = map.remove(other[i]);
+ assertEquals("map.remove for nonexistent key should return null", o, null);
+ assertEquals("map.remove for nonexistent key should not " + "shrink map", size, map.size());
+ }
+ verify();
+ }
+
+ public void testFailFastEntrySet() {
+ if (!isAddRemoveModifiable()) {
+ return;
+ }
+ if (!isFailFastExpected()) {
+ return;
+ }
+ resetFull();
+ Iterator<Map.Entry> it = map.entrySet().iterator();
+ final Map.Entry val = it.next();
+ map.remove(val.getKey());
+ try {
+ it.next();
+ fail();
+ } catch (ConcurrentModificationException expected) {
+ }
+
+ resetFull();
+ it = map.entrySet().iterator();
+ it.next();
+ map.clear();
+ try {
+ it.next();
+ fail();
+ } catch (ConcurrentModificationException expected) {
+ }
+ }
+
+ public void testFailFastKeySet() {
+ if (!isAddRemoveModifiable()) {
+ return;
+ }
+ if (!isFailFastExpected()) {
+ return;
+ }
+ resetFull();
+ Iterator it = map.keySet().iterator();
+ final Object val = it.next();
+ map.remove(val);
+ try {
+ it.next();
+ fail();
+ } catch (ConcurrentModificationException expected) {
+ }
+
+ resetFull();
+ it = map.keySet().iterator();
+ it.next();
+ map.clear();
+ try {
+ it.next();
+ fail();
+ } catch (ConcurrentModificationException expected) {
+ }
+ }
+
+ public void testFailFastValues() {
+ if (!isAddRemoveModifiable()) {
+ return;
+ }
+ if (!isFailFastExpected()) {
+ return;
+ }
+ resetFull();
+ Iterator it = map.values().iterator();
+ it.next();
+ map.remove(map.keySet().iterator().next());
+ try {
+ it.next();
+ fail();
+ } catch (ConcurrentModificationException expected) {
+ }
+
+ resetFull();
+ it = map.values().iterator();
+ it.next();
+ map.clear();
+ try {
+ it.next();
+ fail();
+ } catch (ConcurrentModificationException expected) {
+ }
+ }
+
+ /**
+ * Utility methods to create an array of Map.Entry objects out of the given key and value arrays.
+ *
+ * <p>
+ *
+ * @param keys the array of keys
+ * @param values the array of values
+ * @return an array of Map.Entry of those keys to those values
+ */
+ private Map.Entry[] makeEntryArray(Object[] keys, Object[] values) {
+ Map.Entry[] result = new Map.Entry[keys.length];
+ for (int i = 0; i < keys.length; i++) {
+ result[i] = new DefaultMapEntry(keys[i], values[i]);
+ }
+ return result;
+ }
+
+ class TestMapEntrySet extends TestSet {
+ public TestMapEntrySet() {
+ super("");
+ }
+
+ // Have to implement manually; entrySet doesn't support addAll
+ @Override
+ protected Object[] getFullElements() {
+ Object[] k = getSampleKeys();
+ Object[] v = getSampleValues();
+ return makeEntryArray(k, v);
+ }
+
+ // Have to implement manually; entrySet doesn't support addAll
+ @Override
+ protected Object[] getOtherElements() {
+ Object[] k = getOtherKeys();
+ Object[] v = getOtherValues();
+ return makeEntryArray(k, v);
+ }
+
+ @Override
+ protected Set makeEmptySet() {
+ return makeEmptyMap().entrySet();
+ }
+
+ @Override
+ protected Set makeFullSet() {
+ return makeFullMap().entrySet();
+ }
+
+ @Override
+ protected boolean isAddSupported() {
+ // Collection views don't support add operations.
+ return false;
+ }
+
+ @Override
+ protected boolean isRemoveSupported() {
+ // Entry set should only support remove if map does
+ return isAddRemoveModifiable();
+ }
+
+ @Override
+ protected void resetFull() {
+ TestMap.this.resetFull();
+ collection = map.entrySet();
+ TestMapEntrySet.this.confirmed = TestMap.this.confirmed.entrySet();
+ }
+
+ @Override
+ protected void resetEmpty() {
+ TestMap.this.resetEmpty();
+ collection = map.entrySet();
+ TestMapEntrySet.this.confirmed = TestMap.this.confirmed.entrySet();
+ }
+
+ @Override
+ protected void verify() {
+ super.verify();
+ TestMap.this.verify();
+ }
+ }
+
+ class TestMapKeySet extends TestSet {
+ public TestMapKeySet() {
+ super("");
+ }
+
+ @Override
+ protected Object[] getFullElements() {
+ return getSampleKeys();
+ }
+
+ @Override
+ protected Object[] getOtherElements() {
+ return getOtherKeys();
+ }
+
+ @Override
+ protected Set makeEmptySet() {
+ return makeEmptyMap().keySet();
+ }
+
+ @Override
+ protected Set makeFullSet() {
+ return makeFullMap().keySet();
+ }
+
+ @Override
+ protected boolean isAddSupported() {
+ return false;
+ }
+
+ @Override
+ protected boolean isRemoveSupported() {
+ return isAddRemoveModifiable();
+ }
+
+ @Override
+ protected void resetEmpty() {
+ TestMap.this.resetEmpty();
+ collection = map.keySet();
+ TestMapKeySet.this.confirmed = TestMap.this.confirmed.keySet();
+ }
+
+ @Override
+ protected void resetFull() {
+ TestMap.this.resetFull();
+ collection = map.keySet();
+ TestMapKeySet.this.confirmed = TestMap.this.confirmed.keySet();
+ }
+
+ @Override
+ protected void verify() {
+ super.verify();
+ TestMap.this.verify();
+ }
+ }
+
+ class TestMapValues extends TestCollection {
+ public TestMapValues() {}
+
+ @Override
+ protected Object[] getFullElements() {
+ return getSampleValues();
+ }
+
+ @Override
+ protected Object[] getOtherElements() {
+ return getOtherValues();
+ }
+
+ @Override
+ protected Collection makeCollection() {
+ return makeEmptyMap().values();
+ }
+
+ @Override
+ protected Collection makeFullCollection() {
+ return makeFullMap().values();
+ }
+
+ @Override
+ protected boolean isAddSupported() {
+ return false;
+ }
+
+ @Override
+ protected boolean isRemoveSupported() {
+ return isAddRemoveModifiable();
+ }
+
+ @Override
+ protected boolean areEqualElementsDistinguishable() {
+ // equal values are associated with different keys, so they are
+ // distinguishable.
+ return true;
+ }
+
+ @Override
+ protected Collection makeConfirmedCollection() {
+ // never gets called, reset methods are overridden
+ return null;
+ }
+
+ @Override
+ protected Collection makeConfirmedFullCollection() {
+ // never gets called, reset methods are overridden
+ return null;
+ }
+
+ @Override
+ protected void resetFull() {
+ TestMap.this.resetFull();
+ collection = map.values();
+ TestMapValues.this.confirmed = TestMap.this.confirmed.values();
+ }
+
+ @Override
+ protected void resetEmpty() {
+ TestMap.this.resetEmpty();
+ collection = map.values();
+ TestMapValues.this.confirmed = TestMap.this.confirmed.values();
+ }
+
+ @Override
+ protected void verify() {
+ super.verify();
+ TestMap.this.verify();
+ }
+
+ // TODO: should test that a remove on the values collection view
+ // removes the proper mapping and not just any mapping that may have
+ // the value equal to the value returned from the values iterator.
+ }
+
+ /**
+ * Resets the {@link #map}, {@link #entrySet}, {@link #keySet}, {@link #collectionValues} and
+ * {@link #confirmed} fields to empty.
+ */
+ protected void resetEmpty() {
+ this.map = makeEmptyMap();
+ views();
+ this.confirmed = makeConfirmedMap();
+ }
+
+ /**
+ * Resets the {@link #map}, {@link #entrySet}, {@link #keySet}, {@link #collectionValues} and
+ * {@link #confirmed} fields to full.
+ */
+ protected void resetFull() {
+ this.map = makeFullMap();
+ views();
+ this.confirmed = makeConfirmedMap();
+ Object[] k = getSampleKeys();
+ Object[] v = getSampleValues();
+ for (int i = 0; i < k.length; i++) {
+ confirmed.put(k[i], v[i]);
+ }
+ }
+
+ /** Resets the collection view fields. */
+ private void views() {
+ this.keySet = map.keySet();
+ this.collectionValues = map.values();
+ this.entrySet = map.entrySet();
+ }
+
+ /**
+ * Verifies that {@link #map} is still equal to {@link #confirmed}. This method checks that the
+ * map is equal to the HashMap, <I>and</I> that the map's collection views are still equal to the
+ * HashMap's collection views. An <Code>equals</Code> test is done on the maps and their
+ * collection views; their size and <Code>isEmpty</Code> results are compared; their hashCodes are
+ * compared; and <Code>containsAll</Code> tests are run on the collection views.
+ */
+ protected void verify() {
+ verifyMap();
+ verifyEntrySet();
+ verifyKeySet();
+ }
+
+ protected void verifyMap() {
+ int size = confirmed.size();
+ boolean empty = confirmed.isEmpty();
+ assertEquals("Map should be same size as HashMap", size, map.size());
+ assertEquals("Map should be empty if HashMap is", empty, map.isEmpty());
+ assertEquals("hashCodes should be the same", confirmed.hashCode(), map.hashCode());
+ // this fails for LRUMap because confirmed.equals() somehow modifies
+ // map, causing concurrent modification exceptions.
+ // assertEquals("Map should still equal HashMap", confirmed, map);
+ // this works though and performs the same verification:
+ assertTrue("Map should still equal HashMap", map.equals(confirmed));
+ // TODO: this should really be rexamined to figure out why LRU map
+ // behaves like it does (the equals shouldn't modify since all accesses
+ // by the confirmed collection should be through an iterator, thus not
+ // causing LRUMap to change).
+ }
+
+ protected void verifyEntrySet() {
+ int size = confirmed.size();
+ boolean empty = confirmed.isEmpty();
+ assertEquals("entrySet should be same size as HashMap's", size, entrySet.size());
+ assertEquals("entrySet should be empty if HashMap is", empty, entrySet.isEmpty());
+ assertTrue(
+ "entrySet should contain all HashMap's elements",
+ entrySet.containsAll(confirmed.entrySet()));
+ assertEquals(
+ "entrySet hashCodes should be the same",
+ confirmed.entrySet().hashCode(),
+ entrySet.hashCode());
+ assertEquals("Map's entry set should still equal HashMap's", confirmed.entrySet(), entrySet);
+ }
+
+ protected void verifyKeySet() {
+ int size = confirmed.size();
+ boolean empty = confirmed.isEmpty();
+ assertEquals("keySet should be same size as HashMap's", size, keySet.size());
+ assertEquals("keySet should be empty if HashMap is", empty, keySet.isEmpty());
+ assertTrue(
+ "keySet should contain all HashMap's elements", keySet.containsAll(confirmed.keySet()));
+ assertEquals(
+ "keySet hashCodes should be the same", confirmed.keySet().hashCode(), keySet.hashCode());
+ assertEquals("Map's key set should still equal HashMap's", confirmed.keySet(), keySet);
+ }
+}
diff --git a/user/test/com/google/gwt/emultest/java/util/TestObject.java b/user/test/com/google/gwt/emultest/java/util/TestObject.java
new file mode 100644
index 0000000..20d9c42
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/util/TestObject.java
@@ -0,0 +1,124 @@
+// CHECKSTYLE_OFF: Copyrighted to ASF
+/*
+ * Copyright 1999-2004 The Apache Software Foundation
+ *
+ * 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.
+ */
+// CHECKSTYLE_ON
+package com.google.gwt.emultest.java.util;
+
+/**
+ * Tests base {@link java.lang.Object} methods and contracts.
+ *
+ * <p>To use, simply extend this class, and implement the {@link #makeObject()} method.
+ *
+ * <p>If your {@link Object} fails one of these tests by design, you may still use this base set of
+ * cases. Simply override the test case (method) your {@link Object} fails.
+ */
+abstract class TestObject extends EmulTestBase {
+
+ // current major release for Collections
+ public static final int COLLECTIONS_MAJOR_VERSION = 2;
+
+ /**
+ * This constant makes it possible for TestMap (and other subclasses, if necessary) to
+ * automatically check CVS for a versionX copy of a Serialized object, so we can make sure that
+ * compatibility is maintained. See, for example, TestMap.getCanonicalFullMapName(Map map).
+ * Subclasses can override this variable, indicating compatibility with earlier Collections
+ * versions. Defaults to 1, the earliest Collections version. (Note: some collections did not even
+ * exist in this version).
+ *
+ * @return 1
+ */
+ public int getCompatibilityVersion() {
+ return 1;
+ }
+
+ /** Return a new, empty {@link Object} to used for testing. */
+ public abstract Object makeObject();
+
+ public void testObjectEqualsSelf() {
+ Object obj = makeObject();
+ assertEquals("A Object should equal itself", obj, obj);
+ }
+
+ public void testObjectHashCodeEqualsSelfHashCode() {
+ Object obj = makeObject();
+ assertEquals("hashCode should be repeatable", obj.hashCode(), obj.hashCode());
+ }
+
+ public void testObjectHashCodeEqualsContract() {
+ Object obj1 = makeObject();
+ if (obj1.equals(obj1)) {
+ assertEquals(
+ "[1] When two objects are equal, their hashCodes should be also.",
+ obj1.hashCode(),
+ obj1.hashCode());
+ }
+ Object obj2 = makeObject();
+ if (obj1.equals(obj2)) {
+ assertEquals(
+ "[2] When two objects are equal, their hashCodes should be also.",
+ obj1.hashCode(),
+ obj2.hashCode());
+ assertTrue(
+ "When obj1.equals(obj2) is true, then obj2.equals(obj1) should also be true",
+ obj2.equals(obj1));
+ }
+ }
+
+ public String getCanonicalEmptyCollectionName(Object object) {
+ StringBuilder retval = new StringBuilder();
+ retval.append("data/test/");
+ String colName = object.getClass().getName();
+
+ colName = colName.substring(colName.lastIndexOf(".") + 1);
+ retval.append(colName);
+ retval.append(".emptyCollection.version");
+ retval.append(getCompatibilityVersion());
+ retval.append(".obj");
+ return retval.toString();
+ }
+
+ public String getCanonicalFullCollectionName(Object object) {
+ StringBuilder retval = new StringBuilder();
+ retval.append("data/test/");
+ String colName = object.getClass().getName();
+ colName = colName.substring(colName.lastIndexOf(".") + 1);
+ retval.append(colName);
+ retval.append(".fullCollection.version");
+ retval.append(getCompatibilityVersion());
+ retval.append(".obj");
+ return retval.toString();
+ }
+
+ /**
+ * Override this method if a subclass is testing a Collections that cannot serialize an "empty"
+ * Collection (e.g. Comparators have no contents)
+ *
+ * @return true
+ */
+ public boolean supportsEmptyCollections() {
+ return true;
+ }
+
+ /**
+ * Override this method if a subclass is testing a Collections that cannot serialize a "full"
+ * Collection (e.g. Comparators have no contents)
+ *
+ * @return true
+ */
+ public boolean supportsFullCollections() {
+ return true;
+ }
+}
diff --git a/user/test/com/google/gwt/emultest/java/util/TestSet.java b/user/test/com/google/gwt/emultest/java/util/TestSet.java
new file mode 100644
index 0000000..aafb85e
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/util/TestSet.java
@@ -0,0 +1,163 @@
+// CHECKSTYLE_OFF: Copyrighted to ASF
+/*
+ * Copyright 1999-2004 The Apache Software Foundation
+ *
+ * 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.
+ */
+// CHECKSTYLE_ON
+package com.google.gwt.emultest.java.util;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+/**
+ * Tests base {@link Set} methods and contracts.
+ *
+ * <p>Since {@link Set} doesn't stipulate much new behavior that isn't already found in {@link
+ * Collection}, this class basically just adds tests for {@link Set#equals()} and {@link
+ * Set#hashCode()} along with an updated {@link #verify()} that ensures elements do not appear more
+ * than once in the set.
+ *
+ * <p>To use, subclass and override the {@link #makeEmptySet()} method. You may have to override
+ * other protected methods if your set is not modifiable, or if your set restricts what kinds of
+ * elements may be added; see {@link TestCollection} for more details.
+ */
+@SuppressWarnings({"unchecked", "rawtypes"})
+abstract class TestSet extends TestCollection {
+
+ /**
+ * Constructor.
+ *
+ * @param name name for test
+ */
+ public TestSet(String name) {}
+
+ /**
+ * Makes an empty collection by invoking {@link #makeEmptySet()}.
+ *
+ * @return an empty collection
+ */
+ @Override
+ protected final Collection makeCollection() {
+ return makeEmptySet();
+ }
+
+ /**
+ * Makes a full collection by invoking {@link #makeFullSet()}.
+ *
+ * @return a full collection
+ */
+ @Override
+ protected final Collection makeFullCollection() {
+ return makeFullSet();
+ }
+
+ /** Return the {@link TestCollection#collection} fixture, but cast as a Set. */
+ protected Set getSet() {
+ return (Set) collection;
+ }
+
+ /**
+ * Returns an empty {@link HashSet} for use in modification testing.
+ *
+ * @return a confirmed empty collection
+ */
+ @Override
+ protected Collection makeConfirmedCollection() {
+ return new HashSet();
+ }
+
+ /**
+ * Returns a full {@link HashSet} for use in modification testing.
+ *
+ * @return a confirmed full collection
+ */
+ @Override
+ protected Collection makeConfirmedFullCollection() {
+ HashSet set = new HashSet();
+ set.addAll(Arrays.asList(getFullElements()));
+ return set;
+ }
+
+ /** Return the {@link TestCollection#confirmed} fixture, but cast as a Set. */
+ protected Set getConfirmedSet() {
+ return (Set) confirmed;
+ }
+
+ /**
+ * Makes an empty set. The returned set should have no elements.
+ *
+ * @return an empty set
+ */
+ protected abstract Set makeEmptySet();
+
+ /**
+ * Makes a full set by first creating an empty set and then adding all the elements returned by
+ * {@link #getFullElements()}.
+ *
+ * <p>Override if your set does not support the add operation.
+ *
+ * @return a full set
+ */
+ protected Set makeFullSet() {
+ Set set = makeEmptySet();
+ set.addAll(Arrays.asList(getFullElements()));
+ return set;
+ }
+
+ /** Tests {@link Set#equals(Object)}. */
+ public void testSetEquals() {
+ resetEmpty();
+ assertEquals("Empty sets should be equal", getSet(), getConfirmedSet());
+ verify();
+
+ HashSet set2 = new HashSet();
+ set2.add("foo");
+ assertFalse("Empty set shouldn't equal nonempty set", getSet().equals(set2));
+
+ resetFull();
+ assertEquals("Full sets should be equal", getSet(), getConfirmedSet());
+ verify();
+
+ set2.clear();
+ set2.addAll(Arrays.asList(getOtherElements()));
+ assertTrue("Sets with different contents shouldn't be equal", !getSet().equals(set2));
+ }
+
+ /** Tests {@link Set#hashCode()}. */
+ public void testSetHashCode() {
+ resetEmpty();
+ assertEquals(
+ "Empty sets have equal hashCodes", getSet().hashCode(), getConfirmedSet().hashCode());
+
+ resetFull();
+ assertEquals(
+ "Equal sets have equal hashCodes", getSet().hashCode(), getConfirmedSet().hashCode());
+ }
+
+ /** Provides additional verifications for sets. */
+ @Override
+ protected void verify() {
+ super.verify();
+ assertEquals("Sets should be equal", confirmed, collection);
+ assertEquals("Sets should have equal hashCodes", confirmed.hashCode(), collection.hashCode());
+ HashSet set = new HashSet();
+ Iterator iterator = collection.iterator();
+ while (iterator.hasNext()) {
+ assertTrue("Set.iterator should only return unique elements", set.add(iterator.next()));
+ }
+ }
+}
diff --git a/user/test/com/google/gwt/emultest/java/util/TreeMapTest.java b/user/test/com/google/gwt/emultest/java/util/TreeMapTest.java
index 84b2d24..df8b397 100644
--- a/user/test/com/google/gwt/emultest/java/util/TreeMapTest.java
+++ b/user/test/com/google/gwt/emultest/java/util/TreeMapTest.java
@@ -16,9 +16,6 @@
package com.google.gwt.emultest.java.util;
import com.google.gwt.testing.TestUtils;
-
-import org.apache.commons.collections.TestMap;
-
import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
import java.util.Collection;
@@ -41,12 +38,8 @@
*
* @param <K> The key type for the underlying TreeMap
* @param <V> The value type for the underlying TreeMap
- *
- * 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 TreeMapTest<K extends Comparable<K>, V> extends TestMap {
+abstract class TreeMapTest<K extends Comparable<K>, V> extends TestMap {
private static class ConflictingKey implements Comparable<CharSequence> {
private final String value;
@@ -91,15 +84,13 @@
}
/**
- * Verify that two Collections are deeply equivalent. Some of the Sets that
- * need to be verified do not implement a sensible equals method
- * (TreeMap.values for example).
+ * Verify that two Collections are deeply equivalent. Some of the Sets that need to be verified do
+ * not implement a sensible equals method (TreeMap.values for example).
*
* @param expected
* @param actual
*/
- private static <T> void _assertEquals(Collection<T> expected,
- Collection<T> 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());
@@ -137,9 +128,8 @@
* @param expected
* @param actual
*/
- private static <K, V> void _assertEquals(SortedMap<K, V> expected,
- SortedMap<K, V> actual) {
- _assertEquals((Map<K, V>) expected, (Map<K, V>) actual);
+ private static <K, V> void _assertEquals(SortedMap<K, V> expected, SortedMap<K, V> actual) {
+ _assertEquals(expected, (Map<K, V>) actual);
// verify the order of the associated collections
assertEquals(expected.keySet().toArray(), actual.keySet().toArray());
@@ -148,8 +138,7 @@
}
/**
- * Create the expected return of toString for a Map containing only the passed
- * key and value.
+ * Create the expected return of toString for a Map containing only the passed key and value.
*
* @param key
* @param value
@@ -166,8 +155,8 @@
}
/**
- * Verify entry to be immutable and to have correct values of {@code Map.Entry#toString()}
- * and {@code Map.Entry#hashCode()}.
+ * Verify entry to be immutable and to have correct values of {@code Map.Entry#toString()} and
+ * {@code Map.Entry#hashCode()}.
*/
@SuppressWarnings("unchecked")
private static void verifyEntry(Entry entry) {
@@ -178,22 +167,21 @@
}
Object key = entry.getKey();
Object value = entry.getValue();
- int expectedHashCode = (key == null ? 0 : key.hashCode())
- ^ (value == null ? 0 : value.hashCode());
+ int expectedHashCode =
+ (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode());
assertEquals(expectedHashCode, entry.hashCode());
assertEquals(key + "=" + value, entry.toString());
}
- /**
- * comparator used when creating the SortedMap.
- */
+ /** comparator used when creating the SortedMap. */
private Comparator<K> comparator = null;
- private boolean isClearSupported = true;
- private boolean isNullKeySupported = true;
- private boolean isNullValueSupported = true;
- private boolean isPutAllSupported = true;
- private boolean isPutSupported = true;
- private boolean isRemoveSupported = true;
+
+ private final boolean isClearSupported = true;
+ private final boolean isNullKeySupported = true;
+ private final boolean isNullValueSupported = true;
+ private final boolean isPutAllSupported = true;
+ private final boolean isPutSupported = true;
+ private final boolean isRemoveSupported = true;
@Override
public String getModuleName() {
@@ -289,9 +277,7 @@
}
}
- /**
- * Test method for 'java.lang.Object.clone()'.
- */
+ /** Test method for 'java.lang.Object.clone()'. */
public void testClone() {
// Map<K, V> map = createMap();
// Check empty clone behavior
@@ -333,12 +319,13 @@
assertNull(treeMap.comparator());
assertNull(secondTreeMap.comparator());
- final Comparator<? super K> customComparator = new Comparator<K>() {
- @Override
- public int compare(K o1, K o2) {
- return o1.compareTo(o2);
- }
- };
+ final Comparator<? super K> customComparator =
+ new Comparator<K>() {
+ @Override
+ public int compare(K o1, K o2) {
+ return o1.compareTo(o2);
+ }
+ };
treeMap = new TreeMap<>(customComparator);
secondTreeMap = new TreeMap<>(treeMap);
assertSame(customComparator, treeMap.comparator());
@@ -680,7 +667,7 @@
keys.remove(null);
}
- Comparator<? super K> cmp = ((TreeMap<K, V>) map).comparator();
+ Comparator<? super K> cmp = map.comparator();
Collections.sort(keys, Collections.reverseOrder(cmp));
Iterator<K> it = map.descendingKeySet().iterator();
for (K key : keys) {
@@ -748,22 +735,24 @@
public void testEntrySet_add_throwsUnsupportedOperationException() {
Map<K, V> map = createMap();
try {
- map.entrySet().add(new Entry<K, V>() {
- @Override
- public K getKey() {
- return null;
- }
+ map.entrySet()
+ .add(
+ new Entry<K, V>() {
+ @Override
+ public K getKey() {
+ return null;
+ }
- @Override
- public V getValue() {
- return null;
- }
+ @Override
+ public V getValue() {
+ return null;
+ }
- @Override
- public V setValue(V value) {
- return null;
- }
- });
+ @Override
+ public V setValue(V value) {
+ return null;
+ }
+ });
fail("expected exception");
} catch (UnsupportedOperationException e) {
// expected outcome
@@ -1652,7 +1641,6 @@
* Test method for 'java.util.Map.isEmpty()'.
*
* @see java.util.Map#isEmpty()
- *
*/
public void testIsEmpty() {
K[] keys = getKeys();
@@ -2034,7 +2022,7 @@
for (Object key : getSampleKeys()) {
keys.add((K) key);
}
- Comparator<? super K> cmp = ((TreeMap<K, V>) map).comparator();
+ Comparator<? super K> cmp = map.comparator();
Collections.sort(keys, cmp);
Iterator<K> it = map.navigableKeySet().iterator();
for (K key : keys) {
@@ -2156,15 +2144,14 @@
}
/**
- * Test method for 'java.util.Map.put(Object, Object)'. This test shows some
- * bad behavior of the TreeMap class before JDK 7. A mapping with null key can
- * be put in but several methods are are unusable afterward.
+ * Test method for 'java.util.Map.put(Object, Object)'. This test shows some bad behavior of the
+ * TreeMap class before JDK 7. A mapping with null key can be put in but several methods are are
+ * unusable afterward.
*
- * A SortedMap with natural ordering (no comparator) is supposed to throw a
- * null pointer exception if a null keys are "not supported". For a natural
- * ordered TreeMap before JDK 7, a null pointer exception is not thrown. But,
- * the map is left in a state where any other key based methods result in a
- * null pointer exception.
+ * <p>A SortedMap with natural ordering (no comparator) is supposed to throw a null pointer
+ * exception if a null keys are "not supported". For a natural ordered TreeMap before JDK 7, a
+ * null pointer exception is not thrown. But, the map is left in a state where any other key based
+ * methods result in a null pointer exception.
*
* @see java.util.Map#put(Object, Object)
*/
@@ -2306,8 +2293,7 @@
}
public void testPut_ComparableKey() {
- final boolean java6CompatibleSources =
- !TestUtils.isJvm() || TestUtils.getJdkVersion() < 7;
+ final boolean java6CompatibleSources = !TestUtils.isJvm() || TestUtils.getJdkVersion() < 7;
TreeMap map = new TreeMap();
ConflictingKey conflictingKey = new ConflictingKey("conflictingKey");
try {
@@ -2814,8 +2800,8 @@
fail("Should throw an IllegalArgumentException");
} catch (IllegalArgumentException expected) {
}
- assertEquals(keys.length,
- map.subMap(getLessThanMinimumKey(), getGreaterThanMaximumKey()).size());
+ assertEquals(
+ keys.length, map.subMap(getLessThanMinimumKey(), getGreaterThanMaximumKey()).size());
}
/**
@@ -2842,14 +2828,14 @@
assertEquals(0, map.subMap(keys[0], keys[0]).size());
// bounded by a "wide" range
assertEquals(1, map.subMap(getLessThanMinimumKey(), getGreaterThanMaximumKey()).size());
- assertEquals(1, map.subMap(getLessThanMinimumKey(), false,
- getGreaterThanMaximumKey(), false).size());
- assertEquals(1, map.subMap(getLessThanMinimumKey(), true,
- getGreaterThanMaximumKey(), false).size());
- assertEquals(1, map.subMap(getLessThanMinimumKey(), false,
- getGreaterThanMaximumKey(), true).size());
- assertEquals(1, map.subMap(getLessThanMinimumKey(), true,
- getGreaterThanMaximumKey(), true).size());
+ assertEquals(
+ 1, map.subMap(getLessThanMinimumKey(), false, getGreaterThanMaximumKey(), false).size());
+ assertEquals(
+ 1, map.subMap(getLessThanMinimumKey(), true, getGreaterThanMaximumKey(), false).size());
+ assertEquals(
+ 1, map.subMap(getLessThanMinimumKey(), false, getGreaterThanMaximumKey(), true).size());
+ assertEquals(
+ 1, map.subMap(getLessThanMinimumKey(), true, getGreaterThanMaximumKey(), true).size());
// test with two entry map
map.put(keys[1], values[1]);
@@ -2860,36 +2846,26 @@
assertEquals(0, map.subMap(keys[0], false, keys[1], false).size());
assertEquals(1, map.subMap(keys[0], false, keys[1], true).size());
- assertEquals(keys[1], map.subMap(keys[0], false,
- keys[1], true).keySet().toArray()[0]);
+ assertEquals(keys[1], map.subMap(keys[0], false, keys[1], true).keySet().toArray()[0]);
assertEquals(1, map.subMap(keys[0], true, keys[1], false).size());
- assertEquals(keys[0], map.subMap(keys[0], true,
- keys[1], false).keySet().toArray()[0]);
+ assertEquals(keys[0], map.subMap(keys[0], true, keys[1], false).keySet().toArray()[0]);
assertEquals(2, map.subMap(keys[0], true, keys[1], true).size());
- assertEquals(keys[0], map.subMap(keys[0], true,
- keys[1], true).keySet().toArray()[0]);
- assertEquals(keys[1], map.subMap(keys[0], true,
- keys[1], true).keySet().toArray()[1]);
+ assertEquals(keys[0], map.subMap(keys[0], true, keys[1], true).keySet().toArray()[0]);
+ assertEquals(keys[1], map.subMap(keys[0], true, keys[1], true).keySet().toArray()[1]);
// bounded by a "wide" range
assertEquals(2, map.subMap(getLessThanMinimumKey(), getGreaterThanMaximumKey()).size());
- assertEquals(2, map.subMap(getLessThanMinimumKey(), false,
- getGreaterThanMaximumKey(), false).size());
- assertEquals(1, map.subMap(keys[0], false,
- getGreaterThanMaximumKey(), false).size());
- assertEquals(0, map.subMap(keys[0], false,
- keys[1], false).size());
- assertEquals(2, map.subMap(keys[0], true,
- getGreaterThanMaximumKey(), false).size());
- assertEquals(1, map.subMap(keys[0], true,
- keys[1], false).size());
- assertEquals(2, map.subMap(keys[0], true,
- getGreaterThanMaximumKey(), true).size());
- assertEquals(2, map.subMap(keys[0], true,
- keys[1], true).size());
+ assertEquals(
+ 2, map.subMap(getLessThanMinimumKey(), false, getGreaterThanMaximumKey(), false).size());
+ assertEquals(1, map.subMap(keys[0], false, getGreaterThanMaximumKey(), false).size());
+ assertEquals(0, map.subMap(keys[0], false, keys[1], false).size());
+ assertEquals(2, map.subMap(keys[0], true, getGreaterThanMaximumKey(), false).size());
+ assertEquals(1, map.subMap(keys[0], true, keys[1], false).size());
+ assertEquals(2, map.subMap(keys[0], true, getGreaterThanMaximumKey(), true).size());
+ assertEquals(2, map.subMap(keys[0], true, keys[1], true).size());
}
public void testSubMap_empty() {
@@ -3320,9 +3296,7 @@
assertTrue(map.containsKey(keys[0]));
}
- /**
- * Test method for 'java.lang.Object.toString()'.
- */
+ /** Test method for 'java.lang.Object.toString()'. */
public void testToString() {
K[] keys = getKeys();
V[] values = getValues();
diff --git a/user/test/com/google/gwt/emultest/java/util/TreeSetTest.java b/user/test/com/google/gwt/emultest/java/util/TreeSetTest.java
index 87a76d5..4b5ab8c 100644
--- a/user/test/com/google/gwt/emultest/java/util/TreeSetTest.java
+++ b/user/test/com/google/gwt/emultest/java/util/TreeSetTest.java
@@ -16,9 +16,6 @@
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;
@@ -35,13 +32,12 @@
/**
* Tests <code>TreeSet</code>.
*
- * @param <E> The key type for the underlying TreeSet
+ * <p>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.
*
- * 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.
+ * @param <E> The key type for the underlying TreeSet
*/
-public abstract class TreeSetTest<E extends Comparable<E>> extends TestSet {
+abstract class TreeSetTest<E extends Comparable<E>> extends TestSet {
/**
* Verify a Set is explicitly and implicitly empty.
@@ -55,15 +51,13 @@
}
/**
- * 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).
+ * 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) {
+ 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());
@@ -83,9 +77,8 @@
* @param expected
* @param actual
*/
- private static <E> void _assertEquals(SortedSet<E> expected,
- SortedSet<E> actual) {
- _assertEquals((Set<E>) expected, (Set<E>) actual);
+ private static <E> void _assertEquals(SortedSet<E> expected, SortedSet<E> actual) {
+ _assertEquals(expected, (Set<E>) actual);
// verify the order of the associated collections
assertEquals(expected.toArray(), actual.toArray());
@@ -105,16 +98,14 @@
return reversedCollection;
}
- /**
- * comparator used when creating the SortedSet.
- */
+ /** 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;
+ private final boolean isAddSupported = true;
+ private final boolean isClearSupported = true;
+ private final boolean isNullKeySupported = true;
+ private final boolean isPutAllSupported = true;
+ private final boolean isRemoveSupported = true;
public TreeSetTest() {
super("TreeSetTest");
@@ -490,12 +481,12 @@
* @see java.util.TreeSet#TreeSet(Comparator)
*/
public void testConstructor_comparator() {
- TreeSet<E> TreeSet = new TreeSet<E>(getComparator());
- _assertEmpty(TreeSet);
+ TreeSet<E> treeSet = new TreeSet<E>(getComparator());
+ _assertEmpty(treeSet);
if (isNaturalOrder()) {
- assertNull(TreeSet.comparator());
+ assertNull(treeSet.comparator());
} else {
- assertSame(getComparator(), TreeSet.comparator());
+ assertSame(getComparator(), treeSet.comparator());
}
}
@@ -720,10 +711,10 @@
* @see java.util.SortedSet#first()
*/
public void testFirstKey_throwsNoSuchElementException() {
- SortedSet<E> SortedSet = createNavigableSet();
+ SortedSet<E> sortedSet = createNavigableSet();
// test with no entries
try {
- SortedSet.first();
+ sortedSet.first();
fail("expected exception");
} catch (NoSuchElementException e) {
// expected outcome
@@ -781,14 +772,14 @@
*/
@SuppressWarnings("unchecked")
public void testHeadMap_throwsClassCastException() {
- SortedSet SortedSet = createNavigableSet();
- SortedSet.add(getKeys()[0]);
+ SortedSet sortedSet = createNavigableSet();
+ sortedSet.add(getKeys()[0]);
if (isNaturalOrder()) {
// TODO Why does this succeed with natural ordering when subSet doesn't?
- SortedSet.headSet(getConflictingKey());
+ sortedSet.headSet(getConflictingKey());
} else {
try {
- SortedSet.headSet(getConflictingKey());
+ sortedSet.headSet(getConflictingKey());
assertTrue("CCE expected in Development Mode", !TestUtils.isJvm());
} catch (ClassCastException e) {
// expected outcome
@@ -891,7 +882,6 @@
* Test method for 'java.util.Set.isEmpty()'. *
*
* @see java.util.Set#isEmpty()
- *
*/
public void testIsEmpty() {
Set<E> sourceSet = createSet();
@@ -940,10 +930,10 @@
* @see java.util.SortedSet#last()
*/
public void testLastKey_throwsNoSuchElementException() {
- SortedSet<E> SortedSet = createNavigableSet();
+ SortedSet<E> sortedSet = createNavigableSet();
// test with no entries
try {
- SortedSet.last();
+ sortedSet.last();
fail("expected exception");
} catch (NoSuchElementException e) {
// expected outcome
@@ -1102,10 +1092,10 @@
*/
@SuppressWarnings("unchecked")
public void testSubMap_throwsClassCastException() {
- SortedSet SortedSet = createNavigableSet();
- SortedSet.add(getKeys()[0]);
+ SortedSet sortedSet = createNavigableSet();
+ sortedSet.add(getKeys()[0]);
try {
- SortedSet.subSet(getConflictingKey(), getKeys()[0]);
+ 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
@@ -1114,7 +1104,7 @@
// expected outcome
}
try {
- SortedSet.subSet(getKeys()[0], getConflictingKey());
+ 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
@@ -1130,9 +1120,9 @@
* @see java.util.SortedSet#subSet(Object, Object)
*/
public void testSubMap_throwsIllegalArgumentException() {
- SortedSet<E> SortedSet = createNavigableSet();
+ SortedSet<E> sortedSet = createNavigableSet();
try {
- SortedSet.subSet(getGreaterThanMaximumKey(), getLessThanMinimumKey());
+ sortedSet.subSet(getGreaterThanMaximumKey(), getLessThanMinimumKey());
fail("expected exception");
} catch (IllegalArgumentException e) {
// from key is greater than the to key
@@ -1160,65 +1150,62 @@
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());
+ 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(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(
+ 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(
+ 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]);
+ 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());
+ 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());
+ 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)'.
+ * 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)
@@ -1233,8 +1220,8 @@
}
/**
- * Test method for 'java.util.SortedSet.tailSet(Object)' and
- * '@see java.util.NavigableSet.tailSet(Object, boolean)'.
+ * 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)
@@ -1257,8 +1244,8 @@
}
/**
- * Test method for 'java.util.SortedSet.tailSet(Object)' and
- * '@see java.util.NavigableSet.tailSet(Object, boolean)'.
+ * 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)
@@ -1282,8 +1269,8 @@
}
/**
- * Test method for 'java.util.SortedSet.tailSet(Object)' and
- * '@see java.util.NavigableSet.tailSet(Object, boolean)'.
+ * 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)
@@ -1333,14 +1320,14 @@
*/
@SuppressWarnings("unchecked")
public void testTailSet_throwsClassCastException() {
- SortedSet SortedSet = createNavigableSet();
- SortedSet.add(getKeys()[0]);
+ SortedSet sortedSet = createNavigableSet();
+ sortedSet.add(getKeys()[0]);
if (isNaturalOrder()) {
// TODO Why does this succeed with natural ordering when subSet doesn't?
- SortedSet.tailSet(getConflictingKey());
+ sortedSet.tailSet(getConflictingKey());
} else {
try {
- SortedSet.tailSet(getConflictingKey());
+ sortedSet.tailSet(getConflictingKey());
assertTrue("CCE expected in Development Mode", !TestUtils.isJvm());
} catch (ClassCastException e) {
// expected outcome
@@ -1384,7 +1371,6 @@
return comparator == null;
}
- @SuppressWarnings("unchecked")
@Override
protected Set makeEmptySet() {
return createTreeSet();
diff --git a/user/test/org/apache/commons/Collections.gwt.xml b/user/test/org/apache/commons/Collections.gwt.xml
deleted file mode 100644
index 0c36542..0000000
--- a/user/test/org/apache/commons/Collections.gwt.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<!-- -->
-<!-- Copyright 2007 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 -->
-<!-- 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. License for the specific language governing permissions and -->
-<!-- limitations under the License. -->
-
-<module>
- <inherits name='com.google.gwt.junit.JUnit'/>
- <source path='collections'/>
-</module>
diff --git a/user/test/org/apache/commons/collections/DefaultMapEntry.java b/user/test/org/apache/commons/collections/DefaultMapEntry.java
deleted file mode 100644
index f6daecc..0000000
--- a/user/test/org/apache/commons/collections/DefaultMapEntry.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright 1999-2004 The Apache Software Foundation
- *
- * 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 org.apache.commons.collections;
-
-import java.util.Map;
-
-/** A default implementation of {@link java.util.Map.Entry}
- *
- * @since 1.0
- * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
- * @author <a href="mailto:mas@apache.org">Michael A. Smith</a>
- */
-@SuppressWarnings({"unchecked", "rawtypes"})
-public class DefaultMapEntry implements Map.Entry {
-
- private Object key;
- private Object value;
-
- /**
- * Constructs a new <Code>DefaultMapEntry</Code> with a null key
- * and null value.
- */
- public DefaultMapEntry() {
- }
-
- /**
- * Constructs a new <Code>DefaultMapEntry</Code> with the given
- * key and given value.
- *
- * @param key the key for the entry, may be null
- * @param value the value for the entyr, may be null
- */
- public DefaultMapEntry(Object key, Object value) {
- this.key = key;
- this.value = value;
- }
-
- /**
- * Implemented per API documentation of
- * {@link java.util.Map.Entry#equals(Object)}
- **/
- @Override
- public boolean equals(Object o) {
- if( o == null ) return false;
- if( o == this ) return true;
-
- if ( ! (o instanceof Map.Entry ) )
- return false;
- Map.Entry e2 = (Map.Entry)o;
- return ((getKey() == null ?
- e2.getKey() == null : getKey().equals(e2.getKey())) &&
- (getValue() == null ?
- e2.getValue() == null : getValue().equals(e2.getValue())));
- }
-
-
- /**
- * Implemented per API documentation of
- * {@link java.util.Map.Entry#hashCode()}
- **/
- @Override
- public int hashCode() {
- return ( ( getKey() == null ? 0 : getKey().hashCode() ) ^
- ( getValue() == null ? 0 : getValue().hashCode() ) );
- }
-
-
-
- // Map.Entry interface
- //-------------------------------------------------------------------------
-
- /**
- * Returns the key.
- *
- * @return the key
- */
- @Override
- public Object getKey() {
- return key;
- }
-
-
- /**
- * Returns the value.
- *
- * @return the value
- */
- @Override
- public Object getValue() {
- return value;
- }
-
- // Properties
- //-------------------------------------------------------------------------
-
- /**
- * Sets the key. This method does not modify any map.
- *
- * @param key the new key
- */
- public void setKey(Object key) {
- this.key = key;
- }
-
- /** Note that this method only sets the local reference inside this object and
- * does not modify the original Map.
- *
- * @return the old value of the value
- * @param value the new value
- */
- @Override
- public Object setValue(Object value) {
- Object answer = this.value;
- this.value = value;
- return answer;
- }
-
-}
diff --git a/user/test/org/apache/commons/collections/LocalTestNode.java b/user/test/org/apache/commons/collections/LocalTestNode.java
deleted file mode 100644
index e141975..0000000
--- a/user/test/org/apache/commons/collections/LocalTestNode.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * Copyright 1999-2004 The Apache Software Foundation
- *
- * 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 org.apache.commons.collections;
-
-/**
-* Class LocalTestNode
-*
-* a helper class for TestDoubleOrderedMap
-*
-* @author Marc Johnson (marcj at users dot sourceforge dot net)
-*/
-@SuppressWarnings({"unchecked", "rawtypes"})
-class LocalTestNode implements Comparable {
-
- private Comparable key;
- private Comparable value;
-
- /**
- * construct a LocalTestNode
- *
- * @param key value used to create the key and value
- */
- LocalTestNode(final int key) {
- this.key = new Integer(key);
- this.value = String.valueOf(key);
- }
-
- /**
- * @param key the unique key associated with the current node.
- */
- void setKey(Comparable key) {
- this.key = key;
- }
-
- /**
- * Returns the unique key associated with the current node.
- */
- Comparable getKey() {
- return key;
- }
-
- /**
- * @param value the unique value associated with the current node.
- */
- void setValue(Comparable value) {
- this.value = value;
- }
-
- /**
- * Returns the unique value associated with the current node.
- */
- Comparable getValue() {
- return value;
- }
-
- /**
- * Method compareTo
- *
- * @param o
- *
- * @return int
- */
- @Override
- public int compareTo(Object o) {
-
- LocalTestNode other = (LocalTestNode) o;
- int rval = getKey().compareTo(other.getKey());
-
- if (rval == 0) {
- rval = getValue().compareTo(other.getValue());
- }
-
- return rval;
- }
-
- /**
- * Method equals
- *
- * @param o
- *
- * @return true if equal
- */
- @Override
- public boolean equals(Object o) {
-
- if (o == null) {
- return false;
- }
-
-
- if(!(getClass().getName().equals(o.getClass().getName()))){
- return false;
- }
- LocalTestNode node = (LocalTestNode) o;
-
- return (getKey().equals(node.getKey())
- && getValue().equals(node.getValue()));
- }
-
- /**
- * @return hash code
- */
- @Override
- public int hashCode() {
- return getKey().hashCode() ^ getValue().hashCode();
- }
-}
diff --git a/user/test/org/apache/commons/collections/TestCollection.java b/user/test/org/apache/commons/collections/TestCollection.java
deleted file mode 100644
index f1333f0..0000000
--- a/user/test/org/apache/commons/collections/TestCollection.java
+++ /dev/null
@@ -1,1058 +0,0 @@
-/*
- * Copyright 1999-2004 The Apache Software Foundation
- *
- * 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 org.apache.commons.collections;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.NoSuchElementException;
-import java.util.Set;
-
-
-/**
- * Tests base {@link java.util.Collection} methods and contracts.
- * <p>
- * You should create a concrete subclass of this class to test any custom
- * {@link Collection} implementation. At minimum, you'll have to
- * implement the {@link #makeCollection()} method. You might want to
- * override some of the additional protected methods as well:<P>
- *
- * <B>Element Population Methods</B><P>
- *
- * Override these if your collection restricts what kind of elements are
- * allowed (for instance, if <Code>null</Code> is not permitted):
- * <UL>
- * <Li>{@link #getFullElements()}
- * <Li>{@link #getOtherElements()}
- * </UL>
- *
- * <B>Supported Operation Methods</B><P>
- *
- * Override these if your collection doesn't support certain operations:
- * <UL>
- * <LI>{@link #isAddSuppoted()}
- * <LI>{@link #isRemoveSupported()}
- * <li>{@link #areEqualElementsDistinguishable()}
- * </UL>
- *
- * <B>Fixture Methods</B><P>
- *
- * Fixtures are used to verify that the operation results in correct state
- * for the collection. Basically, the operation is performed against your
- * collection implementation, and an identical operation is performed against a
- * <I>confirmed</I> collection implementation. A confirmed collection
- * implementation is something like <Code>java.util.ArrayList</Code>, which is
- * known to conform exactly to its collection interface's contract. After the
- * operation takes place on both your collection implementation and the
- * confirmed collection implementation, the two collections are compared to see
- * if their state is identical. The comparison is usually much more involved
- * than a simple <Code>equals</Code> test. This verification is used to ensure
- * proper modifications are made along with ensuring that the collection does
- * not change when read-only modifications are made.<P>
- *
- * The {@link #collection} field holds an instance of your collection
- * implementation; the {@link #confirmed} field holds an instance of the
- * confirmed collection implementation. The {@link #resetEmpty()} and
- * {@link #resetFull()} methods set these fields to empty or full collections,
- * so that tests can proceed from a known state.<P>
- *
- * After a modification operation to both {@link #collection} and
- * {@link #confirmed}, the {@link #verify()} method is invoked to compare
- * the results. You may want to override {@link #verify()} to perform
- * additional verifications. For instance, when testing the collection
- * views of a map, {@link TestMap} would override {@link #verify()} to make
- * sure the map is changed after the collection view is changed.
- *
- * If you're extending this class directly, you will have to provide
- * implementations for the following:
- * <UL>
- * <LI>{@link #makeConfirmedCollection()}
- * <LI>{@link #makeConfirmedFullCollection()}
- * </UL>
- *
- * Those methods should provide a confirmed collection implementation
- * that's compatible with your collection implementation.<P>
- *
- * If you're extending {@link TestList}, {@link TestSet},
- * or {@link TestBag}, you probably don't have to worry about the
- * above methods, because those three classes already override the methods
- * to provide standard JDK confirmed collections.<P>
- *
- * <B>Other notes</B><P>
- *
- * If your {@link Collection} fails one of these tests by design,
- * you may still use this base set of cases. Simply override the
- * test case (method) your {@link Collection} fails. For instance, the
- * {@link #testIteratorFailFast()} method is provided since most collections
- * have fail-fast iterators; however, that's not strictly required by the
- * collection contract, so you may want to override that method to do
- * nothing.<P>
- *
- * @author Rodney Waldhoff
- * @author Paul Jack
- * @author <a href="mailto:mas@apache.org">Michael A. Smith</a>
- * @version $Id: TestCollection.java,v 1.9.2.1 2004/05/22 12:14:05 scolebourne Exp $
- */
-@SuppressWarnings({"unchecked", "rawtypes"})
-public abstract class TestCollection extends TestObject {
-
- //
- // NOTE:
- //
- // Collection doesn't define any semantics for equals, and recommends you
- // use reference-based default behavior of Object.equals. (And a test for
- // that already exists in TestObject). Tests for equality of lists, sets
- // and bags will have to be written in test subclasses. Thus, there is no
- // tests on Collection.equals nor any for Collection.hashCode.
- //
-
-
- // These fields are used by reset() and verify(), and any test
- // method that tests a modification.
-
- /**
- * A collection instance that will be used for testing.
- */
- protected Collection collection;
-
- /**
- * Confirmed collection. This is an instance of a collection that is
- * confirmed to conform exactly to the java.util.Collection contract.
- * Modification operations are tested by performing a mod on your
- * collection, performing the exact same mod on an equivalent confirmed
- * collection, and then calling verify() to make sure your collection
- * still matches the confirmed collection.
- */
- protected Collection confirmed;
-
-
-
- /**
- * Resets the {@link #collection} and {@link #confirmed} fields to empty
- * collections. Invoke this method before performing a modification
- * test.
- */
- protected void resetEmpty() {
- this.collection = makeCollection();
- this.confirmed = makeConfirmedCollection();
- }
-
-
- /**
- * Resets the {@link #collection} and {@link #confirmed} fields to full
- * collections. Invoke this method before performing a modification
- * test.
- */
- protected void resetFull() {
- this.collection = makeFullCollection();
- this.confirmed = makeConfirmedFullCollection();
- }
-
- /**
- * Specifies whether equal elements in the collection are, in fact,
- * distinguishable with information not readily available. That is, if a
- * particular value is to be removed from the collection, then there is
- * one and only one value that can be removed, even if there are other
- * elements which are equal to it.
- *
- * <P>In most collection cases, elements are not distinguishable (equal is
- * equal), thus this method defaults to return false. In some cases,
- * however, they are. For example, the collection returned from the map's
- * values() collection view are backed by the map, so while there may be
- * two values that are equal, their associated keys are not. Since the
- * keys are distinguishable, the values are.
- *
- * <P>This flag is used to skip some verifications for iterator.remove()
- * where it is impossible to perform an equivalent modification on the
- * confirmed collection because it is not possible to determine which
- * value in the confirmed collection to actually remove. Tests that
- * override the default (i.e. where equal elements are distinguishable),
- * should provide additional tests on iterator.remove() to make sure the
- * proper elements are removed when remove() is called on the iterator.
- **/
- protected boolean areEqualElementsDistinguishable() {
- return false;
- }
-
- /**
- * Verifies that {@link #collection} and {@link #confirmed} have
- * identical state.
- */
- protected void verify() {
- int confirmedSize = confirmed.size();
- assertEquals("Collection size should match confirmed collection's",
- confirmedSize, collection.size());
- assertEquals("Collection isEmpty() result should match confirmed " +
- " collection's",
- confirmed.isEmpty(), collection.isEmpty());
-
- // verify the collections are the same by attempting to match each
- // object in the collection and confirmed collection. To account for
- // duplicates and differing orders, each confirmed element is copied
- // into an array and a flag is maintained for each element to determine
- // whether it has been matched once and only once. If all elements in
- // the confirmed collection are matched once and only once and there
- // aren't any elements left to be matched in the collection,
- // verification is a success.
-
- // copy each collection value into an array
- Object[] confirmedValues = new Object[confirmedSize];
-
- Iterator iter;
-
- iter = confirmed.iterator();
- int pos = 0;
- while(iter.hasNext()) {
- confirmedValues[pos++] = iter.next();
- }
-
- // allocate an array of boolean flags for tracking values that have
- // been matched once and only once.
- boolean[] matched = new boolean[confirmedSize];
-
- // now iterate through the values of the collection and try to match
- // the value with one in the confirmed array.
- iter = collection.iterator();
- while(iter.hasNext()) {
- Object o = iter.next();
- boolean match = false;
- for(int i = 0; i < confirmedSize; i++) {
- if(matched[i]) {
- // skip values already matched
- continue;
- }
- if(o == confirmedValues[i] ||
- (o != null && o.equals(confirmedValues[i]))) {
- // values matched
- matched[i] = true;
- match = true;
- break;
- }
- }
- // no match found!
- if(!match) {
- fail("Collection should not contain a value that the " +
- "confirmed collection does not have.");
- }
- }
-
- // make sure there aren't any unmatched values
- for(int i = 0; i < confirmedSize; i++) {
- if(!matched[i]) {
- // the collection didn't match all the confirmed values
- fail("Collection should contain all values that are in the " +
- "confirmed collection");
- }
- }
- }
-
-
- /**
- * Returns a confirmed empty collection.
- * For instance, a {@link java.util.ArrayList} for lists or a
- * {@link java.util.HashSet} for sets.
- *
- * @return a confirmed empty collection
- */
- protected abstract Collection makeConfirmedCollection();
-
-
-
- /**
- * Returns a confirmed full collection.
- * For instance, a {@link java.util.ArrayList} for lists or a
- * {@link java.util.HashSet} for sets. The returned collection
- * should contain the elements returned by {@link #getFullElements()}.
- *
- * @return a confirmed full collection
- */
- protected abstract Collection makeConfirmedFullCollection();
-
-
- /**
- * Returns true if the collections produced by
- * {@link #makeCollection()} and {@link #makeFullCollection()}
- * support the <Code>add</Code> and <Code>addAll</Code>
- * operations.<P>
- * Default implementation returns true. Override if your collection
- * class does not support add or addAll.
- */
- protected boolean isAddSupported() {
- return true;
- }
-
-
- /**
- * Returns true if the collections produced by
- * {@link #makeCollection()} and {@link #makeFullCollection()}
- * support the <Code>remove</Code>, <Code>removeAll</Code>,
- * <Code>retainAll</Code>, <Code>clear</Code> and
- * <Code>iterator().remove()</Code> methods.
- * Default implementation returns true. Override if your collection
- * class does not support removal operations.
- */
- protected boolean isRemoveSupported() {
- return true;
- }
-
-
- /**
- * Returns an array of objects that are contained in a collection
- * produced by {@link #makeFullCollection()}. Every element in the
- * returned array <I>must</I> be an element in a full collection.<P>
- * The default implementation returns a heterogenous array of
- * objects with some duplicates and with the null element.
- * Override if you require specific testing elements. Note that if you
- * override {@link #makeFullCollection()}, you <I>must</I> override
- * this method to reflect the contents of a full collection.
- */
- protected Object[] getFullElements() {
- ArrayList list = new ArrayList();
-
- list.addAll(Arrays.asList(getFullNonNullElements()));
- list.add(4, null);
- return list.toArray();
- }
-
-
- /**
- * Returns an array of elements that are <I>not</I> contained in a
- * full collection. Every element in the returned array must
- * not exist in a collection returned by {@link #makeFullCollection()}.
- * The default implementation returns a heterogenous array of elements
- * without null. Note that some of the tests add these elements
- * to an empty or full collection, so if your collection restricts
- * certain kinds of elements, you should override this method.
- */
- protected Object[] getOtherElements() {
- return getOtherNonNullElements();
- }
-
-
- /**
- * Returns a new, empty {@link Collection} to be used for testing.
- */
- protected abstract Collection makeCollection();
-
-
- /**
- * Returns a full collection to be used for testing. The collection
- * returned by this method should contain every element returned by
- * {@link #getFullElements()}. The default implementation, in fact,
- * simply invokes <Code>addAll</Code> on an empty collection with
- * the results of {@link #getFullElements()}. Override this default
- * if your collection doesn't support addAll.
- */
- protected Collection makeFullCollection() {
- Collection c = makeCollection();
- c.addAll(Arrays.asList(getFullElements()));
- return c;
- }
-
-
- /**
- * Returns an empty collection for Object tests.
- */
- @Override
- public Object makeObject() {
- return makeCollection();
- }
-
-
- /**
- * Tests {@link Collection#add(Object)}.
- */
- public void testCollectionAdd() {
- if (!isAddSupported()) return;
-
- Object[] elements = getFullElements();
- for (int i = 0; i < elements.length; i++) {
- resetEmpty();
- boolean r = collection.add(elements[i]);
- confirmed.add(elements[i]);
- verify();
- assertTrue("Empty collection changed after add", r);
- assertTrue("Collection size is 1 after first add",
- collection.size() == 1);
- }
-
- resetEmpty();
- int size = 0;
- for (int i = 0; i < elements.length; i++) {
- boolean r = collection.add(elements[i]);
- confirmed.add(elements[i]);
- verify();
- if (r) size++;
- assertEquals("Collection size should grow after add",
- size, collection.size());
- assertTrue("Collection should contain added element",
- collection.contains(elements[i]));
- }
- }
-
-
- /**
- * Tests {@link Collection#addAll(Collection)}.
- */
- public void testCollectionAddAll() {
- if (!isAddSupported()) return;
-
- resetEmpty();
- Object[] elements = getFullElements();
- boolean r = collection.addAll(Arrays.asList(elements));
- confirmed.addAll(Arrays.asList(elements));
- verify();
- assertTrue("Empty collection should change after addAll", r);
- for (int i = 0; i < elements.length; i++) {
- assertTrue("Collection should contain added element",
- collection.contains(elements[i]));
- }
-
- resetFull();
- int size = collection.size();
- elements = getOtherElements();
- r = collection.addAll(Arrays.asList(elements));
- confirmed.addAll(Arrays.asList(elements));
- verify();
- assertTrue("Full collection should change after addAll", r);
- for (int i = 0; i < elements.length; i++) {
- assertTrue("Full collection should contain added element",
- collection.contains(elements[i]));
- }
- assertEquals("Size should increase after addAll",
- size + elements.length, collection.size());
-
- resetFull();
- size = collection.size();
- r = collection.addAll(Arrays.asList(getFullElements()));
- confirmed.addAll(Arrays.asList(getFullElements()));
- verify();
- if (r) {
- assertTrue("Size should increase if addAll returns true",
- size < collection.size());
- } else {
- assertEquals("Size should not change if addAll returns false",
- size, collection.size());
- }
- }
-
-
- /**
- * If {@link #isAddSupported()} returns false, tests that add operations
- * raise <Code>UnsupportedOperationException.
- */
- public void testUnsupportedAdd() {
- if (isAddSupported()) return;
-
- resetEmpty();
- try {
- collection.add(new Object());
- fail("Emtpy collection should not support add.");
- } catch (UnsupportedOperationException e) {
- // expected
- }
- // make sure things didn't change even if the expected exception was
- // thrown.
- verify();
-
- try {
- collection.addAll(Arrays.asList(getFullElements()));
- fail("Emtpy collection should not support addAll.");
- } catch (UnsupportedOperationException e) {
- // expected
- }
- // make sure things didn't change even if the expected exception was
- // thrown.
- verify();
-
- resetFull();
- try {
- collection.add(new Object());
- fail("Full collection should not support add.");
- } catch (UnsupportedOperationException e) {
- // expected
- }
- // make sure things didn't change even if the expected exception was
- // thrown.
- verify();
-
- try {
- collection.addAll(Arrays.asList(getOtherElements()));
- fail("Full collection should not support addAll.");
- } catch (UnsupportedOperationException e) {
- // expected
- }
- // make sure things didn't change even if the expected exception was
- // thrown.
- verify();
- }
-
-
- /**
- * Test {@link Collection#clear()}.
- */
- public void testCollectionClear() {
- if (!isRemoveSupported()) return;
-
- resetEmpty();
- collection.clear(); // just to make sure it doesn't raise anything
- verify();
-
- resetFull();
- collection.clear();
- confirmed.clear();
- verify();
- }
-
-
- /**
- * Tests {@link Collection#contains(Object)}.
- */
- public void testCollectionContains() {
- Object[] elements;
-
- resetEmpty();
- elements = getFullElements();
- for(int i = 0; i < elements.length; i++) {
- assertTrue("Empty collection shouldn'y contain element",
- !collection.contains(elements[i]));
- }
- // make sure calls to "contains" don't change anything
- verify();
-
- elements = getOtherElements();
- for(int i = 0; i < elements.length; i++) {
- assertTrue("Empty collection shouldn'y contain element",
- !collection.contains(elements[i]));
- }
- // make sure calls to "contains" don't change anything
- verify();
-
- resetFull();
- elements = getFullElements();
- for(int i = 0; i < elements.length; i++) {
- assertTrue("Full collection should contain element.",
- collection.contains(elements[i]));
- }
- // make sure calls to "contains" don't change anything
- verify();
-
- resetFull();
- elements = getOtherElements();
- for(int i = 0; i < elements.length; i++) {
- assertTrue("Full collection shouldn't contain element",
- !collection.contains(elements[i]));
- }
- }
-
-
- /**
- * Tests {@link Collection#containsAll(Collection)}.
- */
- @SuppressWarnings("ModifyingCollectionWithItself")
- public void testCollectionContainsAll() {
- resetEmpty();
- Collection col = new HashSet();
- assertTrue("Every Collection should contain all elements of an " +
- "empty Collection.", collection.containsAll(col));
- col.addAll(Arrays.asList(getOtherElements()));
- assertTrue("Empty Collection shouldn't contain all elements of " +
- "a non-empty Collection.", !collection.containsAll(col));
- // make sure calls to "containsAll" don't change anything
- verify();
-
- resetFull();
- assertTrue("Full collection shouldn't contain other elements",
- !collection.containsAll(col));
-
- col.clear();
- col.addAll(Arrays.asList(getFullElements()));
- assertTrue("Full collection should containAll full elements",
- collection.containsAll(col));
- // make sure calls to "containsAll" don't change anything
- verify();
-
-
- assertTrue("Full collection should containAll itself",
- collection.containsAll(collection));
-
- // make sure calls to "containsAll" don't change anything
- verify();
-
- col = new ArrayList();
- col.addAll(Arrays.asList(getFullElements()));
- col.addAll(Arrays.asList(getFullElements()));
- assertTrue("Full collection should containAll duplicate full " +
- "elements", collection.containsAll(col));
-
- // make sure calls to "containsAll" don't change anything
- verify();
- }
-
- /**
- * Tests {@link Collection#isEmpty()}.
- */
- public void testCollectionIsEmpty() {
- resetEmpty();
- assertEquals("New Collection should be empty.",
- true, collection.isEmpty());
- // make sure calls to "isEmpty() don't change anything
- verify();
-
- resetFull();
- assertEquals("Full collection shouldn't be empty",
- false, collection.isEmpty());
- // make sure calls to "isEmpty() don't change anything
- verify();
- }
-
-
- /**
- * Tests the read-only functionality of {@link Collection#iterator()}.
- */
- public void testCollectionIterator() {
- resetEmpty();
- Iterator it1 = collection.iterator();
- assertEquals("Iterator for empty Collection shouldn't have next.",
- false, it1.hasNext());
- try {
- it1.next();
- fail("Iterator at end of Collection should throw " +
- "NoSuchElementException when next is called.");
- } catch(NoSuchElementException e) {
- // expected
- }
- // make sure nothing has changed after non-modification
- verify();
-
- resetFull();
- it1 = collection.iterator();
- for (int i = 0; i < collection.size(); i++) {
- assertTrue("Iterator for full collection should haveNext",
- it1.hasNext());
- it1.next();
- }
- assertTrue("Iterator should be finished", !it1.hasNext());
-
- ArrayList list = new ArrayList();
- it1 = collection.iterator();
- for (int i = 0; i < collection.size(); i++) {
- Object next = it1.next();
- assertTrue("Collection should contain element returned by " +
- "its iterator", collection.contains(next));
- list.add(next);
- }
- try {
- it1.next();
- fail("iterator.next() should raise NoSuchElementException " +
- "after it finishes");
- } catch (NoSuchElementException e) {
- // expected
- }
- // make sure nothing has changed after non-modification
- verify();
- }
-
-
- /**
- * Tests removals from {@link Collection#iterator()}.
- */
- public void testCollectionIteratorRemove() {
- if (!isRemoveSupported()) return;
-
- resetEmpty();
- try {
- collection.iterator().remove();
- fail("New iterator.remove should raise IllegalState");
- } catch (IllegalStateException e) {
- // expected
- }
- verify();
-
- try {
- Iterator iter = collection.iterator();
- iter.hasNext();
- iter.remove();
- fail("New iterator.remove should raise IllegalState " +
- "even after hasNext");
- } catch (IllegalStateException e) {
- // expected
- }
- verify();
-
- resetFull();
- int size = collection.size();
- Iterator iter = collection.iterator();
- while (iter.hasNext()) {
- Object o = iter.next();
- iter.remove();
-
- // if the elements aren't distinguishable, we can just remove a
- // matching element from the confirmed collection and verify
- // contents are still the same. Otherwise, we don't have the
- // ability to distinguish the elements and determine which to
- // remove from the confirmed collection (in which case, we don't
- // verify because we don't know how).
- //
- // see areEqualElementsDistinguishable()
- if(!areEqualElementsDistinguishable()) {
- confirmed.remove(o);
- verify();
- }
-
- size--;
- assertEquals("Collection should shrink by one after " +
- "iterator.remove", size, collection.size());
- }
- assertTrue("Collection should be empty after iterator purge",
- collection.isEmpty());
-
- resetFull();
- iter = collection.iterator();
- iter.next();
- iter.remove();
- try {
- iter.remove();
- fail("Second iter.remove should raise IllegalState");
- } catch (IllegalStateException e) {
- // expected
- }
- }
-
-
- /**
- * Tests {@link Collection#remove(Object)}.
- */
- public void testCollectionRemove() {
- if (!isRemoveSupported()) return;
-
- resetEmpty();
- Object[] elements = getFullElements();
- for (int i = 0; i < elements.length; i++) {
- assertTrue("Shouldn't remove nonexistent element",
- !collection.remove(elements[i]));
- verify();
- }
-
- Object[] other = getOtherElements();
-
- resetFull();
- for (int i = 0; i < other.length; i++) {
- assertTrue("Shouldn't remove nonexistent other element",
- !collection.remove(other[i]));
- verify();
- }
-
- int size = collection.size();
- for (int i = 0; i < elements.length; i++) {
- resetFull();
- assertTrue("Collection should remove extant element",
- collection.remove(elements[i]));
-
- // if the elements aren't distinguishable, we can just remove a
- // matching element from the confirmed collection and verify
- // contents are still the same. Otherwise, we don't have the
- // ability to distinguish the elements and determine which to
- // remove from the confirmed collection (in which case, we don't
- // verify because we don't know how).
- //
- // see areEqualElementsDistinguishable()
- if(!areEqualElementsDistinguishable()) {
- confirmed.remove(elements[i]);
- verify();
- }
-
- assertEquals("Collection should shrink after remove",
- size - 1, collection.size());
- }
- }
-
-
- /**
- * Tests {@link Collection#removeAll(Collection)}.
- */
- public void testCollectionRemoveAll() {
- if (!isRemoveSupported()) return;
-
- resetEmpty();
- assertTrue("Emtpy collection removeAll should return false for " +
- "empty input",
- !collection.removeAll(Collections.EMPTY_SET));
- verify();
-
- assertTrue("Emtpy collection removeAll should return false for " +
- "nonempty input",
- !collection.removeAll(new ArrayList(collection)));
- verify();
-
- resetFull();
- assertTrue("Full collection removeAll should return false for " +
- "empty input",
- !collection.removeAll(Collections.EMPTY_SET));
- verify();
-
- assertTrue("Full collection removeAll should return false for " +
- "other elements",
- !collection.removeAll(Arrays.asList(getOtherElements())));
- verify();
-
- assertTrue("Full collection removeAll should return true for " +
- "full elements",
- collection.removeAll(new HashSet(collection)));
- confirmed.removeAll(new HashSet(confirmed));
- verify();
-
- resetFull();
-
- int size = collection.size();
- Object[] s = getFullElements();
- List l = new ArrayList();
- l.add(s[2]); l.add(s[3]); l.add(s[3]);
-
- assertTrue("Full collection removeAll should work",
- collection.removeAll(l));
- confirmed.removeAll(l);
- verify();
-
- assertTrue("Collection should shrink after removeAll",
- collection.size() < size);
- Iterator iter = l.iterator();
- while (iter.hasNext()) {
- assertTrue("Collection shouldn't contain removed element",
- !collection.contains(iter.next()));
- }
- }
-
-
- /**
- * Tests {@link Collection#retainAll(Collection)}.
- */
- public void testCollectionRetainAll() {
- if (!isRemoveSupported()) return;
-
- resetEmpty();
- List elements = Arrays.asList(getFullElements());
- List other = Arrays.asList(getOtherElements());
- Set empty = new HashSet();
-
- assertTrue("Empty retainAll() should return false",
- !collection.retainAll(empty));
- verify();
-
- assertTrue("Empty retainAll() should return false",
- !collection.retainAll(elements));
- verify();
-
- resetFull();
- assertTrue("Collection should change from retainAll empty",
- collection.retainAll(empty));
- confirmed.retainAll(empty);
- verify();
-
- resetFull();
- assertTrue("Collection changed from retainAll other",
- collection.retainAll(other));
- confirmed.retainAll(other);
- verify();
-
- resetFull();
- int size = collection.size();
- assertTrue("Collection shouldn't change from retainAll elements",
- !collection.retainAll(elements));
- verify();
- assertEquals("Collection size shouldn't change", size,
- collection.size());
-
-
- resetFull();
- HashSet set = new HashSet(elements);
- size = collection.size();
- assertTrue("Collection shouldn't change from retainAll without " +
- "duplicate elements", !collection.retainAll(set));
- verify();
- assertEquals("Collection size didn't change from nonduplicate " +
- "retainAll", size, collection.size());
- }
-
-
- /**
- * Tests {@link Collection#size()}.
- */
- public void testCollectionSize() {
- resetEmpty();
- assertEquals("Size of new Collection is 0.", 0, collection.size());
-
- resetFull();
- assertTrue("Size of full collection should be greater than zero",
- collection.size() > 0);
- }
-
-
-
-
- /**
- * Tests <Code>toString</Code> on a collection.
- */
- public void testCollectionToString() {
- resetEmpty();
- assertTrue("toString shouldn't return null",
- collection.toString() != null);
-
- resetFull();
- assertTrue("toString shouldn't return null",
- collection.toString() != null);
- }
-
-
- /**
- * If isRemoveSupported() returns false, tests to see that remove
- * operations raise an UnsupportedOperationException.
- */
- public void testUnsupportedRemove() {
- if (isRemoveSupported()) return;
-
- resetEmpty();
- try {
- collection.clear();
- fail("clear should raise UnsupportedOperationException");
- } catch (UnsupportedOperationException e) {
- // expected
- }
- verify();
-
- try {
- collection.remove(null);
- fail("remove should raise UnsupportedOperationException");
- } catch (UnsupportedOperationException e) {
- // expected
- }
- verify();
-
- try {
- collection.removeAll(null);
- fail("removeAll should raise UnsupportedOperationException");
- } catch (UnsupportedOperationException e) {
- // expected
- }
- verify();
-
- try {
- collection.retainAll(null);
- fail("removeAll should raise UnsupportedOperationException");
- } catch (UnsupportedOperationException e) {
- // expected
- }
- verify();
-
- resetFull();
- try {
- Iterator iterator = collection.iterator();
- iterator.next();
- iterator.remove();
- fail("iterator.remove should raise UnsupportedOperationException");
- } catch (UnsupportedOperationException e) {
- // expected
- }
- verify();
-
- }
-
-
-
- /**
- * Returns a list of elements suitable for return by
- * {@link #getFullElements()}. The array returned by this method
- * does not include null, but does include a variety of objects
- * of different types. Override getFullElements to return
- * the results of this method if your collection does not support
- * the null element.
- */
- public static Object[] getFullNonNullElements() {
- return new Object[] {
- new String(""),
- new String("One"),
- new Integer(2),
- "Three",
- new Integer(4),
- "One",
- new Double(5),
- new Float(6),
- "Seven",
- "Eight",
- new String("Nine"),
- new Integer(10),
- new Short((short)11),
- new Long(12),
- "Thirteen",
- "14",
- "15",
- new Byte((byte)16)
- };
- }
-
-
- /**
- * Returns the default list of objects returned by
- * {@link #getOtherElements()}. Includes many objects
- * of different types.
- */
- public static Object[] getOtherNonNullElements() {
- return new Object[] {
- new Integer(0),
- new Float(0),
- new Double(0),
- "Zero",
- new Short((short)0),
- new Byte((byte)0),
- new Long(0),
- new Character('\u0000'),
- "0"
- };
- }
-
-
-
- /**
- * Returns a list of string elements suitable for return by
- * {@link #getFullElements()}. Override getFullElements to return
- * the results of this method if your collection does not support
- * heterogenous elements or the null element.
- */
- public static Object[] getFullNonNullStringElements() {
- return new Object[] {
- "If","the","dull","substance","of","my","flesh","were","thought",
- "Injurious","distance","could","not","stop","my","way",
- };
- }
-
-
- /**
- * Returns a list of string elements suitable for return by
- * {@link #getOtherElements()}. Override getOtherElements to return
- * the results of this method if your collection does not support
- * heterogenous elements or the null element.
- */
- public static Object[] getOtherNonNullStringElements() {
- return new Object[] {
- "For","then","despite",/* of */"space","I","would","be","brought",
- "From","limits","far","remote","where","thou","dost","stay"
- };
- }
-}
diff --git a/user/test/org/apache/commons/collections/TestComparator.java b/user/test/org/apache/commons/collections/TestComparator.java
deleted file mode 100644
index 8e3025e..0000000
--- a/user/test/org/apache/commons/collections/TestComparator.java
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * Copyright 1999-2004 The Apache Software Foundation
- *
- * 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 org.apache.commons.collections;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-
-@SuppressWarnings({"unchecked", "rawtypes"})
-public abstract class TestComparator extends TestObject {
-
-
- public abstract Comparator makeComparator();
- public abstract List getComparableObjectsOrdered();
-
- @Override
- public Object makeObject() {
- return makeComparator();
- }
-
- /**
- * There were no Comparators in version 1.x.
- *
- * @return 2
- */
- @Override
- public int getCompatibilityVersion() {
- return 2;
- }
-
- public void reverseObjects(List list) {
- Collections.reverse(list);
- }
-
-
-
- /**
- * Sort object according to the given Comparator.
- *
- * @param list List to sort
- * @param comparator sorting comparator
- */
- public void sortObjects(List list, Comparator comparator) {
-
- Collections.sort(list,comparator);
-
- }
-
- @Override
- public boolean supportsEmptyCollections() {
- return false;
- }
-
- @Override
- public boolean supportsFullCollections() {
- return false;
- }
-
- public void testEmptyListSort() {
- List list = new ArrayList();
- sortObjects(list,makeComparator());
-
- List list2 = new ArrayList();
-
- assertTrue("Comparator cannot sort empty lists",
- list2.equals(list));
- }
-
- public void testReverseListSort() {
- Comparator comparator = makeComparator();
-
- List randomList = getComparableObjectsOrdered();
- reverseObjects(randomList);
- sortObjects(randomList,comparator);
-
- List orderedList = getComparableObjectsOrdered();
-
- assertTrue("Comparator did not reorder the List correctly",
- orderedList.equals(randomList));
-
- }
-
-
-
-
- public String getCanonicalComparatorName(Object object) {
- StringBuffer retval = new StringBuffer();
- retval.append("data/test/");
- String colName = object.getClass().getName();
- colName = colName.substring(colName.lastIndexOf(".")+1,colName.length());
- retval.append(colName);
- retval.append(".version");
- retval.append(getCompatibilityVersion());
- retval.append(".obj");
- return retval.toString();
- }
-
- /**
- * Compare the current serialized form of the Comparator
- * against the canonical version in CVS.
- */
- public void testComparatorCompatibility() {
- Comparator comparator = null;
-
-
- // make sure the canonical form produces the ordering we currently
- // expect
- List randomList = getComparableObjectsOrdered();
- reverseObjects(randomList);
- sortObjects(randomList,comparator);
-
- List orderedList = getComparableObjectsOrdered();
-
- assertTrue("Comparator did not reorder the List correctly:" + randomList,
- orderedList.equals(randomList));
- }
-
-}
diff --git a/user/test/org/apache/commons/collections/TestIterator.java b/user/test/org/apache/commons/collections/TestIterator.java
deleted file mode 100644
index 4714bc1..0000000
--- a/user/test/org/apache/commons/collections/TestIterator.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright 1999-2004 The Apache Software Foundation
- *
- * 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 org.apache.commons.collections;
-
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-
-/**
- * Base class for tetsing Iterator interface
- *
- * @author Morgan Delagrange
- */
-@SuppressWarnings({"unchecked", "rawtypes"})
-public abstract class TestIterator extends TestObject {
-
-
-
- public abstract Iterator makeEmptyIterator();
-
- public abstract Iterator makeFullIterator();
-
- /**
- * Whether or not we are testing an iterator that can be
- * empty. Default is true.
- *
- * @return true if Iterators can be empty
- */
- public boolean supportsEmptyIterator() {
- return true;
- }
-
- /**
- * Whether or not we are testing an iterator that can contain
- * elements. Default is true.
- *
- * @return true if Iterators can be empty
- */
- public boolean supportsFullIterator() {
- return true;
- }
-
- /**
- * Whether or not we are testing an iterator that supports remove.
- * Default is true.
- *
- * @return true if Iterators can remove elements
- */
- public boolean supportsRemove() {
- return true;
- }
-
- /**
- * Should throw a NoSuchElementException.
- */
- public void testEmptyIterator() {
- if (supportsEmptyIterator() == false) {
- return;
- }
-
- Iterator iter = makeEmptyIterator();
- assertTrue("hasNext() should return false for empty iterators",iter.hasNext() == false);
- try {
- iter.next();
- fail("NoSuchElementException must be thrown when Iterator is exhausted");
- } catch (NoSuchElementException e) {
- }
- }
-
- /**
- * NoSuchElementException (or any other exception)
- * should not be thrown for the first element.
- * NoSuchElementException must be thrown when
- * hasNext() returns false
- */
- public void testFullIterator() {
- if (supportsFullIterator() == false) {
- return;
- }
-
- Iterator iter = makeFullIterator();
-
- assertTrue("hasNext() should return true for at least one element",iter.hasNext());
-
- try {
- iter.next();
- } catch (NoSuchElementException e) {
- fail("Full iterators must have at least one element");
- }
-
- while (iter.hasNext()) {
- iter.next();
- }
-
- try {
- iter.next();
- fail("NoSuchElementException must be thrown when Iterator is exhausted");
- } catch (NoSuchElementException e) {
- }
- }
-
-}
diff --git a/user/test/org/apache/commons/collections/TestList.java b/user/test/org/apache/commons/collections/TestList.java
deleted file mode 100644
index e951855..0000000
--- a/user/test/org/apache/commons/collections/TestList.java
+++ /dev/null
@@ -1,698 +0,0 @@
-/*
- * Copyright 1999-2004 The Apache Software Foundation
- *
- * 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 org.apache.commons.collections;
-
-import java.util.AbstractCollection;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import java.util.ListIterator;
-import java.util.NoSuchElementException;
-
-/**
- * Tests base {@link java.util.List} methods and contracts.
- * <p>
- * To use, simply extend this class, and implement
- * the {@link #makeList} method.
- * <p>
- * If your {@link List} fails one of these tests by design,
- * you may still use this base set of cases. Simply override the
- * test case (method) your {@link List} fails.
- *
- * @author Rodney Waldhoff
- * @author Paul Jack
- * @version $Id: TestList.java,v 1.13.2.1 2004/05/22 12:14:05 scolebourne Exp $
- */
-@SuppressWarnings({"unchecked", "rawtypes"})
-public abstract class TestList extends TestCollection {
-
-
-
-
- /**
- * Return a new, empty {@link List} to be used for testing.
- *
- * @return an empty list for testing.
- */
- protected abstract List makeEmptyList();
-
-
- /**
- * Return a new, full {@link List} to be used for testing.
- *
- * @return a full list for testing
- */
- protected List makeFullList() {
- // only works if list supports optional "addAll(Collection)"
- List list = makeEmptyList();
- list.addAll(Arrays.asList(getFullElements()));
- return list;
- }
-
-
- /**
- * Returns {@link makeEmptyList()}.
- *
- * @return an empty list to be used for testing
- */
- @Override
- final protected Collection makeCollection() {
- return makeEmptyList();
- }
-
-
- /**
- * Returns {@link makeFullList()}.
- *
- * @return a full list to be used for testing
- */
- @Override
- final protected Collection makeFullCollection() {
- return makeFullList();
- }
-
-
-
- /**
- * Whether or not we are testing an iterator that can be
- * empty. Default is true.
- *
- * @return true if Iterators can be empty
- */
- public boolean supportsEmptyIterator() {
- return true;
- }
-
- /**
- * Whether or not we are testing an list that allows
- * element set. Default is true.
- *
- * @return true if Lists support element set
- */
- public boolean isSetSupported() {
- return true;
- }
-
-
- /**
- * Returns the {@link collection} field cast to a {@link List}.
- *
- * @return the collection field as a List
- */
- protected List getList() {
- return (List)collection;
- }
-
-
- /**
- * Returns the {@link confirmed} field cast to a {@link List}.
- *
- * @return the confirmed field as a List
- */
- protected List getConfirmedList() {
- return (List)confirmed;
- }
-
-
-
-
- public class TestListIterator extends AbstractTestListIterator {
-
- @Override
- public Object addSetValue() {
- return TestList.this.getOtherElements()[0];
- }
-
- @Override
- public boolean supportsRemove() {
- return TestList.this.isRemoveSupported();
- }
-
- @Override
- public boolean supportsAdd() {
- return TestList.this.isAddSupported();
- }
-
- @Override
- public boolean supportsSet() {
- return TestList.this.isSetSupported();
- }
-
- @Override
- public ListIterator makeEmptyListIterator() {
- resetEmpty();
- return ((List) TestList.this.collection).listIterator();
- }
-
- @Override
- public ListIterator makeFullListIterator() {
- resetFull();
- return ((List) TestList.this.collection).listIterator();
- }
-
- @Override
- public Object makeObject() {
- return ((List) TestList.this.collection).listIterator();
- }
- }
-
- /**
- * Tests the read-only bits of {@link List#listIterator()}.
- */
- public void testListListIterator() {
- resetFull();
- forwardTest(getList().listIterator(), 0);
- backwardTest(getList().listIterator(), 0);
- }
-
- /**
- * Tests the read-only bits of {@link List#listIterator(int)}.
- */
- public void testListListIteratorByIndex() {
- resetFull();
- try {
- getList().listIterator(-1);
- } catch (IndexOutOfBoundsException ex) {
- }
- resetFull();
- try {
- getList().listIterator(getList().size() + 1);
- } catch (IndexOutOfBoundsException ex) {
- }
- resetFull();
- for (int i = 0; i <= confirmed.size(); i++) {
- forwardTest(getList().listIterator(i), i);
- backwardTest(getList().listIterator(i), i);
- }
- resetFull();
- for (int i = 0; i <= confirmed.size(); i++) {
- backwardTest(getList().listIterator(i), i);
- }
- }
-
- // -----------------------------------------------------------------------
- /**
- * Tests remove on list iterator is correct.
- */
- public void testListListIteratorPreviousRemoveNext() {
- if (isRemoveSupported() == false)
- return;
- resetFull();
- if (collection.size() < 4)
- return;
- ListIterator it = getList().listIterator();
- Object zero = it.next();
- Object one = it.next();
- Object two = it.next();
- Object two2 = it.previous();
- Object one2 = it.previous();
- assertEquals(one, one2);
- assertEquals(two, two2);
- assertEquals(zero, getList().get(0));
- assertEquals(one, getList().get(1));
- assertEquals(two, getList().get(2));
-
- it.remove(); // removed element at index 1 (one)
- assertEquals(zero, getList().get(0));
- assertEquals(two, getList().get(1));
- Object two3 = it.next(); // do next after remove
- assertEquals(two, two3);
- assertEquals(collection.size() > 2, it.hasNext());
- assertEquals(true, it.hasPrevious());
- }
-
- /**
- * Tests remove on list iterator is correct.
- */
- public void testListListIteratorPreviousRemovePrevious() {
- if (isRemoveSupported() == false)
- return;
- resetFull();
- if (collection.size() < 4)
- return;
- ListIterator it = getList().listIterator();
- Object zero = it.next();
- Object one = it.next();
- Object two = it.next();
- Object two2 = it.previous();
- Object one2 = it.previous();
- assertEquals(one, one2);
- assertEquals(two, two2);
- assertEquals(zero, getList().get(0));
- assertEquals(one, getList().get(1));
- assertEquals(two, getList().get(2));
-
- it.remove(); // removed element at index 1 (one)
- assertEquals(zero, getList().get(0));
- assertEquals(two, getList().get(1));
- Object zero3 = it.previous(); // do previous after remove
- assertEquals(zero, zero3);
- assertEquals(false, it.hasPrevious());
- assertEquals(collection.size() > 2, it.hasNext());
- }
-
- /**
- * Tests remove on list iterator is correct.
- */
- public void testListListIteratorNextRemoveNext() {
- if (isRemoveSupported() == false)
- return;
- resetFull();
- if (collection.size() < 4)
- return;
- ListIterator it = getList().listIterator();
- Object zero = it.next();
- Object one = it.next();
- Object two = it.next();
- assertEquals(zero, getList().get(0));
- assertEquals(one, getList().get(1));
- assertEquals(two, getList().get(2));
- Object three = getList().get(3);
-
- it.remove(); // removed element at index 2 (two)
- assertEquals(zero, getList().get(0));
- assertEquals(one, getList().get(1));
- Object three2 = it.next(); // do next after remove
- assertEquals(three, three2);
- assertEquals(collection.size() > 3, it.hasNext());
- assertEquals(true, it.hasPrevious());
- }
-
- /**
- * Tests remove on list iterator is correct.
- */
- public void testListListIteratorNextRemovePrevious() {
- if (isRemoveSupported() == false)
- return;
- resetFull();
- if (collection.size() < 4)
- return;
- ListIterator it = getList().listIterator();
- Object zero = it.next();
- Object one = it.next();
- Object two = it.next();
- assertEquals(zero, getList().get(0));
- assertEquals(one, getList().get(1));
- assertEquals(two, getList().get(2));
-
- it.remove(); // removed element at index 2 (two)
- assertEquals(zero, getList().get(0));
- assertEquals(one, getList().get(1));
- Object one2 = it.previous(); // do previous after remove
- assertEquals(one, one2);
- assertEquals(true, it.hasNext());
- assertEquals(true, it.hasPrevious());
- }
-
- // -----------------------------------------------------------------------
- /**
- * Traverses to the end of the given iterator.
- *
- * @param iter the iterator to traverse
- * @param i the starting index
- */
- private void forwardTest(ListIterator iter, int i) {
- List list = getList();
- int max = getFullElements().length;
-
- while (i < max) {
- assertTrue("Iterator should have next", iter.hasNext());
- assertEquals("Iterator.nextIndex should work", iter.nextIndex(), i);
- assertEquals("Iterator.previousIndex should work", iter.previousIndex(),
- i - 1);
- Object o = iter.next();
- assertEquals("Iterator returned correct element f", list.get(i), o);
- i++;
- }
-
- assertTrue("Iterator shouldn't have next", !iter.hasNext());
- assertEquals("nextIndex should be size", iter.nextIndex(), max);
- assertEquals("previousIndex should be size - 1", iter.previousIndex(),
- max - 1);
-
- try {
- iter.next();
- fail("Exhausted iterator should raise NoSuchElement");
- } catch (NoSuchElementException e) {
- // expected
- }
- }
-
- /**
- * Traverses to the beginning of the given iterator.
- *
- * @param iter the iterator to traverse
- * @param i the starting index
- */
- private void backwardTest(ListIterator iter, int i) {
- List list = getList();
-
- while (i > 0) {
- assertTrue("Iterator should have previous, i:" + i, iter.hasPrevious());
- assertEquals("Iterator.nextIndex should work, i:" + i, iter.nextIndex(),
- i);
- assertEquals("Iterator.previousIndex should work, i:" + i,
- iter.previousIndex(), i - 1);
- Object o = iter.previous();
- assertEquals("Iterator returned correct element b", list.get(i - 1), o);
- i--;
- }
-
- assertTrue("Iterator shouldn't have previous", !iter.hasPrevious());
- int nextIndex = iter.nextIndex();
- assertEquals("nextIndex should be 0, actual value: " + nextIndex, 0, nextIndex);
- int prevIndex = iter.previousIndex();
- assertEquals("previousIndex should be -1, actual value: " + prevIndex, -1, prevIndex);
-
- try {
- iter.previous();
- fail("Exhausted iterator should raise NoSuchElement");
- } catch (NoSuchElementException e) {
- // expected
- }
-
- }
-
- /**
- * Tests the {@link ListIterator#add(Object)} method of the list iterator.
- */
- public void testListIteratorAdd() {
- if (!isAddSupported())
- return;
-
- resetEmpty();
- List list1 = getList();
- List list2 = getConfirmedList();
-
- Object[] elements = getFullElements();
- ListIterator iter1 = list1.listIterator();
- ListIterator iter2 = list2.listIterator();
-
- for (int i = 0; i < elements.length; i++) {
- iter1.add(elements[i]);
- iter2.add(elements[i]);
- verify();
- }
-
- resetFull();
- iter1 = getList().listIterator();
- iter2 = getConfirmedList().listIterator();
- for (int i = 0; i < elements.length; i++) {
- iter1.next();
- iter2.next();
- iter1.add(elements[i]);
- iter2.add(elements[i]);
- verify();
- }
- }
-
- /**
- * Tests the {@link ListIterator#set(Object)} method of the list iterator.
- */
- public void testListIteratorSet() {
- if (!isSetSupported())
- return;
-
- Object[] elements = getFullElements();
-
- resetFull();
- ListIterator iter1 = getList().listIterator();
- ListIterator iter2 = getConfirmedList().listIterator();
- for (int i = 0; i < elements.length; i++) {
- iter1.next();
- iter2.next();
- iter1.set(elements[i]);
- iter2.set(elements[i]);
- verify();
- }
- }
-
-
-
-
- /**
- * Tests {@link List#add(int,Object)}.
- */
- public void testListAddByIndex() {
- if (!isAddSupported()) return;
-
- Object element = getOtherElements()[0];
- int max = getFullElements().length;
-
- for (int i = 0; i <= max; i++) {
- resetFull();
- ((List)collection).add(i, element);
- ((List)confirmed).add(i, element);
- verify();
- }
- }
-
-
- /**
- * Tests {@link List#equals(Object)}.
- */
- public void testListEquals() {
- resetEmpty();
- List list = getList();
- assertTrue("Empty lists should be equal", list.equals(confirmed));
- verify();
- assertTrue("Empty list should equal self", list.equals(list));
- verify();
-
- List list2 = Arrays.asList(getFullElements());
- assertTrue("Empty list shouldn't equal full", !list.equals(list2));
- verify();
-
- list2 = Arrays.asList(getOtherElements());
- assertTrue("Empty list shouldn't equal other", !list.equals(list2));
- verify();
-
- resetFull();
- list = getList();
- assertTrue("Full lists should be equal", list.equals(confirmed));
- verify();
- assertTrue("Full list should equal self", list.equals(list));
- verify();
-
- list2 = makeEmptyList();
- assertTrue("Full list shouldn't equal empty", !list.equals(list2));
- verify();
-
- list2 = Arrays.asList(getOtherElements());
- assertTrue("Full list shouldn't equal other", !list.equals(list2));
- verify();
-
- list2 = Arrays.asList(getFullElements());
- Collections.reverse(list2);
- assertTrue("Full list shouldn't equal full list with same elements" +
- " but different order", !list.equals(list2));
- verify();
-
- assertTrue("List shouldn't equal String", !list.equals(""));
- verify();
-
- final List listForC = Arrays.asList(getFullElements());
- Collection c = new AbstractCollection() {
- @Override
- public int size() {
- return listForC.size();
- }
-
- @Override
- public Iterator iterator() {
- return listForC.iterator();
- }
- };
-
- assertTrue("List shouldn't equal nonlist with same elements " +
- " in same order", !list.equals(c));
- verify();
- }
-
-
- /**
- * Tests {@link List#hashCode()}.
- */
- public void testListHashCode() {
- resetEmpty();
- int hash1 = collection.hashCode();
- int hash2 = confirmed.hashCode();
- assertEquals("Empty lists should have equal hashCodes", hash1, hash2);
- verify();
-
- resetFull();
- hash1 = collection.hashCode();
- hash2 = confirmed.hashCode();
- assertEquals("Full lists should have equal hashCodes", hash1, hash2);
- verify();
- }
-
-
- /**
- * Tests {@link List#get(int)}.
- */
- public void testListGetByIndex() {
- resetFull();
- List list = getList();
- Object[] elements = getFullElements();
- for (int i = 0; i < elements.length; i++) {
- assertEquals("List should contain correct elements",
- elements[i], list.get(i));
- verify();
- }
- }
-
-
-
- /**
- * Tests {@link List#indexOf()}.
- */
- public void testListIndexOf() {
- resetFull();
- List list1 = getList();
- List list2 = getConfirmedList();
-
- Iterator iterator = list2.iterator();
- while (iterator.hasNext()) {
- Object element = iterator.next();
- assertEquals("indexOf should return correct result",
- list1.indexOf(element), list2.indexOf(element));
- verify();
- }
-
- Object[] other = getOtherElements();
- for (int i = 0; i < other.length; i++) {
- assertEquals("indexOf should return -1 for nonexistent element", -1, list1.indexOf(other[i]));
- verify();
- }
- }
-
-
- /**
- * Tests {@link List#lastIndexOf()}.
- */
- public void testListLastIndexOf() {
- resetFull();
- List list1 = getList();
- List list2 = getConfirmedList();
-
- Iterator iterator = list2.iterator();
- while (iterator.hasNext()) {
- Object element = iterator.next();
- assertEquals("lastIndexOf should return correct result",
- list1.lastIndexOf(element), list2.lastIndexOf(element));
- verify();
- }
-
- Object[] other = getOtherElements();
- for (int i = 0; i < other.length; i++) {
- assertEquals(
- "lastIndexOf should return -1 for nonexistent " + "element",
- -1,
- list1.lastIndexOf(other[i]));
- verify();
- }
- }
-
-
-
-
- /**
- * Tests {@link List#remove(int)}.
- */
- public void testListRemoveByIndex() {
- if (!isRemoveSupported()) return;
-
- int max = getFullElements().length;
- for (int i = 0; i < max; i++) {
- resetFull();
- Object o1 = ((List)collection).remove(i);
- Object o2 = ((List)confirmed).remove(i);
- assertEquals("remove should return correct element", o1, o2);
- verify();
- }
- }
-
-
-
-
-
-
-
-
-
- /**
- * Returns an empty {@link ArrayList}.
- */
- @Override
- protected Collection makeConfirmedCollection() {
- ArrayList list = new ArrayList();
- return list;
- }
-
-
- /**
- * Returns a full {@link ArrayList}.
- */
- @Override
- protected Collection makeConfirmedFullCollection() {
- ArrayList list = new ArrayList();
- list.addAll(Arrays.asList(getFullElements()));
- return list;
- }
-
-
- /**
- * Verifies that the test list implementation matches the confirmed list
- * implementation.
- */
- @Override
- protected void verify() {
- super.verify();
-
- List list1 = getList();
- List list2 = getConfirmedList();
-
- assertEquals("List should equal confirmed", list1, list2);
- assertEquals("Confirmed should equal list", list2, list1);
-
- assertEquals("Hash codes should be equal",
- list1.hashCode(), list2.hashCode());
-
- int i = 0;
- Iterator iterator1 = list1.iterator();
- Iterator iterator2 = list2.iterator();
- Object[] array = list1.toArray();
- while (iterator2.hasNext()) {
- assertTrue("List iterator should have next", iterator1.hasNext());
- Object o1 = iterator1.next();
- Object o2 = iterator2.next();
- assertEquals("Iterator elements should be equal", o1, o2);
- o2 = list1.get(i);
- assertEquals("get should return correct element", o1, o2);
- o2 = array[i];
- assertEquals("toArray should have correct element", o1, o2);
- i++;
- }
- }
-
-
-
-
-}
diff --git a/user/test/org/apache/commons/collections/TestMap.java b/user/test/org/apache/commons/collections/TestMap.java
deleted file mode 100644
index 1c4cf29..0000000
--- a/user/test/org/apache/commons/collections/TestMap.java
+++ /dev/null
@@ -1,1169 +0,0 @@
-/*
- * Copyright 1999-2004 The Apache Software Foundation
- *
- * 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 org.apache.commons.collections;
-
-import com.google.gwt.testing.TestUtils;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.ConcurrentModificationException;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-
-import jsinterop.annotations.JsPackage;
-import jsinterop.annotations.JsProperty;
-
-/**
- * Tests base {@link java.util.Map} methods and contracts.
- * <p>
- * The forces at work here are similar to those in {@link TestCollection}.
- * If your class implements the full Map interface, including optional
- * operations, simply extend this class, and implement the {@link
- * #makeEmptyMap()} method.
- * <p>
- * On the other hand, if your map implemenation is weird, you may have to
- * override one or more of the other protected methods. They're described
- * below.<P>
- *
- * <B>Entry Population Methods</B><P>
- *
- * Override these methods if your map requires special entries:
- *
- * <UL>
- * <LI>{@link #getSampleKeys()}
- * <LI>{@link #getSampleValues()}
- * <LI>{@link #getNewSampleValues()}
- * <LI>{@link #getOtherKeys()}
- * <LI>{@link #getOtherValues()}
- * </UL>
- *
- * <B>Supported Operation Methods</B><P>
- *
- * Override these methods if your map doesn't support certain operations:
- *
- * <UL>
- * <LI> {@link #useDuplicateValues()}
- * <LI> {@link #useNullKey()}
- * <LI> {@link #useNullValue()}
- * <LI> {@link #isAddRemoveModifiable()}
- * <LI> {@link #isChangeable()}
- * </UL>
- *
- * <B>Fixture Methods</B><P>
- *
- * For tests on modification operations (puts and removes), fixtures are used
- * to verify that that operation results in correct state for the map and its
- * collection views. Basically, the modification is performed against your
- * map implementation, and an identical modification is performed against
- * a <I>confirmed</I> map implementation. A confirmed map implementation is
- * something like <Code>java.util.HashMap</Code>, which is known to conform
- * exactly to the {@link Map} contract. After the modification takes place
- * on both your map implementation and the confirmed map implementation, the
- * two maps are compared to see if their state is identical. The comparison
- * also compares the collection views to make sure they're still the same.<P>
- *
- * The upshot of all that is that <I>any</I> test that modifies the map in
- * <I>any</I> way will verify that <I>all</I> of the map's state is still
- * correct, including the state of its collection views. So for instance
- * if a key is removed by the map's key set's iterator, then the entry set
- * is checked to make sure the key/value pair no longer appears.<P>
- *
- * The {@link #map} field holds an instance of your collection implementation.
- * The {@link #entrySet}, {@link #keySet} and {@link #collectionValues} fields hold
- * that map's collection views. And the {@link #confirmed} field holds
- * an instance of the confirmed collection implementation. The
- * {@link #resetEmpty()} and {@link #resetFull()} methods set these fields to
- * empty or full maps, so that tests can proceed from a known state.<P>
- *
- * After a modification operation to both {@link #map} and {@link #confirmed},
- * the {@link #verify()} method is invoked to compare the results. The {@link
- * verify()} method calls separate methods to verify the map and its three
- * collection views ({@link verifyMap(), {@link verifyEntrySet()}, {@link
- * verifyKeySet()}, and {@link verifyValues()}). You may want to override one
- * of the verification methodsto perform additional verifications. For
- * instance, {@link TestDoubleOrderedMap} would want override its {@link
- * #verifyValues()} method to verify that the values are unique and in
- * ascending order.<P>
- *
- * <B>Other Notes</B><P>
- *
- * If your {@link Map} fails one of these tests by design, you may still use
- * this base set of cases. Simply override the test case (method) your {@link
- * Map} fails and/or the methods that define the assumptions used by the test
- * cases. For example, if your map does not allow duplicate values, override
- * {@link #useDuplicateValues()} and have it return <code>false</code>
- *
- * @author Michael Smith
- * @author Rodney Waldhoff
- * @author Paul Jack
- * @version $Id: TestMap.java,v 1.20.2.1 2004/05/22 12:14:05 scolebourne Exp $
- */
-@SuppressWarnings({"unchecked", "rawtypes"})
-public abstract class TestMap extends TestObject{
-
- // These instance variables are initialized with the reset method.
- // Tests for map methods that alter the map (put, putAll, remove)
- // first call reset() to create the map and its views; then perform
- // the modification on the map; perform the same modification on the
- // confirmed; and then call verify() to ensure that the map is equal
- // to the confirmed, that the already-constructed collection views
- // are still equal to the confirmed's collection views.
-
-
- /** Map created by reset(). */
- protected Map map;
-
- /** Entry set of map created by reset(). */
- protected Set entrySet;
-
- /** Key set of map created by reset(). */
- protected Set keySet;
-
- /** Values collection of map created by reset(). */
- protected Collection collectionValues;
-
- /** HashMap created by reset(). */
- protected Map confirmed;
-
-
-
-
- /**
- * Override if your map does not allow a <code>null</code> key. The
- * default implementation returns <code>true</code>
- **/
- protected boolean useNullKey() {
- return true;
- }
-
- /**
- * Override if your map does not allow <code>null</code> values. The
- * default implementation returns <code>true</code>.
- **/
- protected boolean useNullValue() {
- return true;
- }
-
- /**
- * Override if your map does not allow duplicate values. The default
- * implementation returns <code>true</code>.
- **/
- protected boolean useDuplicateValues() {
- return true;
- }
-
- /**
- * Override if your map allows its mappings to be changed to new values.
- * The default implementation returns <code>true</code>.
- **/
- protected boolean isChangeable() {
- return true;
- }
-
- /**
- * Override if your map does not allow add/remove modifications. The
- * default implementation returns <code>true</code>.
- **/
- protected boolean isAddRemoveModifiable() {
- return true;
- }
-
- /**
- * Override if your map allows concurrent modifications. The default
- * implementation returns <code>true</code>.
- **/
- protected boolean isFailFastExpected() {
- return true;
- }
-
- /**
- * Returns the set of keys in the mappings used to test the map. This
- * method must return an array with the same length as {@link
- * #getSampleValues()} and all array elements must be different. The
- * default implementation constructs a set of String keys, and includes a
- * single null key if {@link #useNullKey()} returns <code>true</code>.
- **/
- protected Object[] getSampleKeys() {
- Object[] result = new Object[] {
- "blah", "foo", "bar", "baz", "tmp", "gosh", "golly", "gee",
- "hello", "goodbye", "we'll", "see", "you", "all", "again",
- "key",
- "key2",
- (useNullKey()) ? null : "nonnullkey"
- };
- return result;
- }
-
-
- protected Object[] getOtherKeys() {
- return TestCollection.getOtherNonNullStringElements();
- }
-
- protected Object[] getOtherValues() {
- return TestCollection.getOtherNonNullStringElements();
- }
-
- /**
- * Returns the set of values in the mappings used to test the map. This
- * method must return an array with the same length as {@link
- * #getSampleKeys()}. The default implementation contructs a set of
- * String values and includes a single null value if {@link
- * #useNullValue()} returns <code>true</code>, and includes two values
- * that are the same if {@link #useDuplicateValues()} returns
- * <code>true</code>.
- **/
- protected Object[] getSampleValues() {
- Object[] result = new Object[] {
- "blahv", "foov", "barv", "bazv", "tmpv", "goshv", "gollyv", "geev",
- "hellov", "goodbyev", "we'llv", "seev", "youv", "allv", "againv",
- (useNullValue()) ? null : "nonnullvalue",
- "value",
- (useDuplicateValues()) ? "value" : "value2",
- };
- return result;
- }
-
- /**
- * Returns a the set of values that can be used to replace the values
- * returned from {@link #getSampleValues()}. This method must return an
- * array with the same length as {@link #getSampleValues()}. The values
- * returned from this method should not be the same as those returned from
- * {@link #getSampleValues()}. The default implementation constructs a
- * set of String values and includes a single null value if {@link
- * #useNullValue()} returns <code>true</code>, and includes two values
- * that are the same if {@link #useDuplicateValues()} returns
- * <code>true</code>.
- **/
- protected Object[] getNewSampleValues() {
- Object[] result = new Object[] {
- (useNullValue()) ? null : "newnonnullvalue",
- "newvalue",
- (useDuplicateValues()) ? "newvalue" : "newvalue2",
- "newblahv", "newfoov", "newbarv", "newbazv", "newtmpv", "newgoshv",
- "newgollyv", "newgeev", "newhellov", "newgoodbyev", "newwe'llv",
- "newseev", "newyouv", "newallv", "newagainv",
- };
- return result;
- }
-
- /**
- * Helper method to add all the mappings described by {@link
- * #getSampleKeys()} and {@link #getSampleValues()}.
- **/
- protected void addSampleMappings(Map m) {
-
- Object[] keys = getSampleKeys();
- Object[] values = getSampleValues();
-
- for(int i = 0; i < keys.length; i++) {
- try {
- m.put(keys[i], values[i]);
- } catch (NullPointerException exception) {
- assertTrue("NullPointerException only allowed to be thrown " +
- "if either the key or value is null.",
- keys[i] == null || values[i] == null);
-
- if (keys[i] == null) {
- if (useNullKey()) {
- throw new Error("NullPointerException on null key, but " +
- "useNullKey is not overridden to return false.", exception);
- }
- } else if (values[i] == null) {
- if (useNullValue()) {
- throw new Error("NullPointerException on null value, but " +
- "useNullValue is not overridden to return false.", exception);
- }
- } else {
- // Unknown reason for NullPointer.
- throw exception;
- }
- }
- }
- assertEquals("size must reflect number of mappings added.",
- keys.length, m.size());
- }
-
- /**
- * Return a new, empty {@link Map} to be used for testing.
- */
- protected abstract Map makeEmptyMap();
-
- protected Map makeConfirmedMap() {
- return new HashMap();
- }
-
- /**
- * Return a new, populated map. The mappings in the map should match the
- * keys and values returned from {@link #getSampleKeys()} and {@link
- * #getSampleValues()}. The default implementation uses makeEmptyMap()
- * and calls {@link #addSampleMappings()} to add all the mappings to the
- * map.
- **/
- protected Map makeFullMap() {
- Map m = makeEmptyMap();
- addSampleMappings(m);
- return m;
- }
-
- @Override
- public Object makeObject() {
- return makeEmptyMap();
- }
-
- public void testSpecialKeysValues() {
- String[] keys = {"toString", "constructor", "__proto__", "", "null"};
- Object[] values = {new Object(), new Object(), new Object(), new Object(), null};
-
- Map map = makeEmptyMap();
-
- assertMap(map, keys, values);
-
- Object[] undefineds = new Object[values.length];
- Arrays.fill(undefineds, getUndefined());
- assertMap(map, keys, undefineds);
- }
-
- private void assertMap(Map map, String[] keys, Object[] values) {
- assertEmptyMap(map, keys, values);
-
- // Fill the map with special keys/values.
- for (int i = 0; i < keys.length; i++) {
- map.put(keys[i], values[i]);
- }
-
- // Assert the map with filled in keys/values
- for (int i = 0; i < keys.length; i++) {
- assertTrue(keys[i], map.containsKey(keys[i]));
- assertTrue(keys[i], map.containsValue(values[i]));
- assertSame(keys[i], values[i], map.get(keys[i]));
- }
- assertEquals(map.toString(), keys.length, map.size());
-
- // Remove the keys and assert the results
- for (int i = 0; i < keys.length; i++) {
- assertSame(keys[i], values[i], map.remove(keys[i]));
- }
- assertEmptyMap(map, keys, values);
- }
-
- private static void assertEmptyMap(Map map, final String[] keys, final Object[] values) {
- for (int i = 0; i < keys.length; i++) {
- assertFalse(keys[i], map.containsKey(keys[i]));
- assertFalse(keys[i], map.containsValue(values[i]));
- assertNull(keys[i], map.get(keys[i]));
- }
- }
-
- private static Object getUndefined() {
- if (TestUtils.isJvm()) {
- return null;
- }
- return getUndefinedImpl();
- }
-
- @JsProperty(name = "undefined", namespace = JsPackage.GLOBAL)
- private native static Object getUndefinedImpl();
-
- /**
- * Test to ensure the test setup is working properly. This method checks
- * to ensure that the getSampleKeys and getSampleValues methods are
- * returning results that look appropriate. That is, they both return a
- * non-null array of equal length. The keys array must not have any
- * duplicate values, and may only contain a (single) null key if
- * useNullKey() returns true. The values array must only have a null
- * value if useNullValue() is true and may only have duplicate values if
- * useDuplicateValues() returns true.
- **/
- public void testSampleMappings() {
- Object[] keys = getSampleKeys();
- Object[] values = getSampleValues();
- Object[] newValues = getNewSampleValues();
-
- assertTrue("failure in test: Must have keys returned from " +
- "getSampleKeys.", keys != null);
-
- assertTrue("failure in test: Must have values returned from " +
- "getSampleValues.", values != null);
-
- // verify keys and values have equivalent lengths (in case getSampleX are
- // overridden)
- assertEquals("failure in test: not the same number of sample " +
- "keys and values.", keys.length, values.length);
-
- assertEquals("failure in test: not the same number of values and new values.",
- values.length, newValues.length);
-
- // verify there aren't duplicate keys, and check values
- for(int i = 0; i < keys.length - 1; i++) {
- for(int j = i + 1; j < keys.length; j++) {
- assertTrue("failure in test: duplicate null keys.",
- (keys[i] != null || keys[j] != null));
- assertTrue("failure in test: duplicate non-null key.",
- (keys[i] == null || keys[j] == null ||
- (!keys[i].equals(keys[j]) &&
- !keys[j].equals(keys[i]))));
- }
- assertTrue("failure in test: found null key, but useNullKey " +
- "is false.", keys[i] != null || useNullKey());
- assertTrue("failure in test: found null value, but useNullValue " +
- "is false.", values[i] != null || useNullValue());
- assertTrue("failure in test: found null new value, but useNullValue " +
- "is false.", newValues[i] != null || useNullValue());
- assertTrue("failure in test: values should not be the same as new value",
- values[i] != newValues[i] &&
- (values[i] == null || !values[i].equals(newValues[i])));
- }
- }
-
- // tests begin here. Each test adds a little bit of tested functionality.
- // Many methods assume previous methods passed. That is, they do not
- // exhaustively recheck things that have already been checked in a previous
- // test methods.
-
- /**
- * Test to ensure that makeEmptyMap and makeFull returns a new non-null
- * map with each invocation.
- **/
- public void testMakeMap() {
- Map em = makeEmptyMap();
- assertTrue("failure in test: makeEmptyMap must return a non-null map.",
- em != null);
-
- Map em2 = makeEmptyMap();
- assertTrue("failure in test: makeEmptyMap must return a non-null map.",
- em != null);
-
- assertTrue("failure in test: makeEmptyMap must return a new map " +
- "with each invocation.", em != em2);
-
- Map fm = makeFullMap();
- assertTrue("failure in test: makeFullMap must return a non-null map.",
- fm != null);
-
- Map fm2 = makeFullMap();
- assertTrue("failure in test: makeFullMap must return a non-null map.",
- fm != null);
-
- assertTrue("failure in test: makeFullMap must return a new map " +
- "with each invocation.", fm != fm2);
- }
-
- /**
- * Tests Map.isEmpty()
- **/
- public void testMapIsEmpty() {
-
- resetEmpty();
- assertEquals("Map.isEmpty() should return true with an empty map",
- true, map.isEmpty());
- verify();
-
- resetFull();
- assertEquals("Map.isEmpty() should return false with a non-empty map",
- false, map.isEmpty());
- verify();
- }
-
- /**
- * Tests Map.size()
- **/
- public void testMapSize() {
- resetEmpty();
- assertEquals("Map.size() should be 0 with an empty map",
- 0, map.size());
- verify();
-
- resetFull();
- assertEquals("Map.size() should equal the number of entries " +
- "in the map", getSampleKeys().length, map.size());
- verify();
- }
-
- /**
- * Tests {@link Map#clear()}. If the map {@link #isAddRemoveModifiable()
- * can add and remove elements}, then {@link Map#size()} and {@link
- * Map#isEmpty()} are used to ensure that map has no elements after a call
- * to clear. If the map does not support adding and removing elements,
- * this method checks to ensure clear throws an
- * UnsupportedOperationException.
- **/
- public void testMapClear() {
- if (!isAddRemoveModifiable()) return;
-
- resetEmpty();
- map.clear();
- confirmed.clear();
- verify();
-
- resetFull();
- map.clear();
- confirmed.clear();
- verify();
- }
-
-
- /**
- * Tests Map.containsKey(Object) by verifying it returns false for all
- * sample keys on a map created using an empty map and returns true for
- * all sample keys returned on a full map.
- **/
- public void testMapContainsKey() {
- Object[] keys = getSampleKeys();
-
- resetEmpty();
- for(int i = 0; i < keys.length; i++) {
- assertTrue("Map must not contain key when map is empty",
- !map.containsKey(keys[i]));
- }
- verify();
-
- resetFull();
- for(int i = 0; i < keys.length; i++) {
- assertTrue("Map must contain key for a mapping in the map. " +
- "Missing: " + keys[i], map.containsKey(keys[i]));
- }
- verify();
- }
-
- /**
- * Tests Map.containsValue(Object) by verifying it returns false for all
- * sample values on an empty map and returns true for all sample values on
- * a full map.
- **/
- public void testMapContainsValue() {
- Object[] values = getSampleValues();
-
- resetEmpty();
- for(int i = 0; i < values.length; i++) {
- assertTrue("Empty map must not contain value",
- !map.containsValue(values[i]));
- }
- verify();
-
- resetFull();
- for(int i = 0; i < values.length; i++) {
- assertTrue("Map must contain value for a mapping in the map.",
- map.containsValue(values[i]));
- }
- verify();
- }
-
-
- /**
- * Tests Map.equals(Object)
- **/
- public void testMapEquals() {
- resetEmpty();
- assertTrue("Empty maps unequal.", map.equals(confirmed));
- verify();
-
- resetFull();
- assertTrue("Full maps unequal.", map.equals(confirmed));
- verify();
-
- resetFull();
- // modify the HashMap created from the full map and make sure this
- // change results in map.equals() to return false.
- Iterator iter = confirmed.keySet().iterator();
- iter.next();
- iter.remove();
- assertTrue("Different maps equal.", !map.equals(confirmed));
-
- resetFull();
- assertTrue("equals(null) returned true.", !map.equals(null));
- assertTrue("equals(new Object()) returned true.",
- !map.equals(new Object()));
- verify();
- }
-
-
- /**
- * Tests Map.get(Object)
- **/
- public void testMapGet() {
- resetEmpty();
-
- Object[] keys = getSampleKeys();
- Object[] values = getSampleValues();
-
- for (int i = 0; i < keys.length; i++) {
- assertTrue("Empty map.get() should return null.",
- map.get(keys[i]) == null);
- }
- verify();
-
- resetFull();
- for (int i = 0; i < keys.length; i++) {
- assertEquals("Full map.get() should return value from mapping.",
- values[i], map.get(keys[i]));
- }
- }
-
- /**
- * Tests Map.hashCode()
- **/
- public void testMapHashCode() {
- resetEmpty();
- assertTrue("Empty maps have different hashCodes.",
- map.hashCode() == confirmed.hashCode());
-
- resetFull();
- assertTrue("Equal maps have different hashCodes.",
- map.hashCode() == confirmed.hashCode());
- }
-
- /**
- * Tests Map.toString(). Since the format of the string returned by the
- * toString() method is not defined in the Map interface, there is no
- * common way to test the results of the toString() method. Thereforce,
- * it is encouraged that Map implementations override this test with one
- * that checks the format matches any format defined in its API. This
- * default implementation just verifies that the toString() method does
- * not return null.
- **/
- public void testMapToString() {
- resetEmpty();
- assertTrue("Empty map toString() should not return null",
- map.toString() != null);
- verify();
-
- resetFull();
- assertTrue("Empty map toString() should not return null",
- map.toString() != null);
- verify();
- }
-
-
-
-
-
- /**
- * Tests Map.put(Object, Object)
- **/
- public void testMapPut() {
- if (!isAddRemoveModifiable()) return;
-
- resetEmpty();
-
- Object[] keys = getSampleKeys();
- Object[] values = getSampleValues();
- Object[] newValues = getNewSampleValues();
-
- for(int i = 0; i < keys.length; i++) {
- Object o = map.put(keys[i], values[i]);
- confirmed.put(keys[i], values[i]);
- verify();
- assertTrue("First map.put should return null", o == null);
- assertTrue("Map should contain key after put",
- map.containsKey(keys[i]));
- assertTrue("Map should contain value after put",
- map.containsValue(values[i]));
- }
-
- for(int i = 0; i < keys.length; i++) {
- Object o = map.put(keys[i], newValues[i]);
- confirmed.put(keys[i], newValues[i]);
- verify();
- assertEquals("Second map.put should return previous value",
- values[i], o);
- assertTrue("Map should still contain key after put",
- map.containsKey(keys[i]));
- assertTrue("Map should contain new value after put",
- map.containsValue(newValues[i]));
-
- // if duplicates are allowed, we're not guarunteed that the value
- // no longer exists, so don't try checking that.
- if(!useDuplicateValues()) {
- assertTrue("Map should not contain old value after second put",
- !map.containsValue(values[i]));
- }
- }
- }
-
- /**
- * Tests Map.putAll(Collection)
- **/
- public void testMapPutAll() {
- if (!isAddRemoveModifiable()) return;
-
- resetEmpty();
-
- Map m2 = makeFullMap();
-
- map.putAll(m2);
- confirmed.putAll(m2);
- verify();
-
- resetEmpty();
-
- m2 = new HashMap();
- Object[] keys = getSampleKeys();
- Object[] values = getSampleValues();
- for(int i = 0; i < keys.length; i++) {
- m2.put(keys[i], values[i]);
- }
-
- map.putAll(m2);
- confirmed.putAll(m2);
- verify();
- }
-
- /**
- * Tests Map.remove(Object)
- **/
- public void testMapRemove() {
- if (!isAddRemoveModifiable()) return;
-
- resetEmpty();
-
- Object[] keys = getSampleKeys();
- Object[] values = getSampleValues();
- for(int i = 0; i < keys.length; i++) {
- Object o = map.remove(keys[i]);
- assertTrue("First map.remove should return null", o == null);
- }
- verify();
-
- resetFull();
-
- for(int i = 0; i < keys.length; i++) {
- Object o = map.remove(keys[i]);
- confirmed.remove(keys[i]);
- verify();
-
- assertEquals("map.remove with valid key should return value",
- values[i], o);
- }
-
- Object[] other = getOtherKeys();
-
- resetFull();
- int size = map.size();
- for (int i = 0; i < other.length; i++) {
- Object o = map.remove(other[i]);
- assertEquals("map.remove for nonexistent key should return null",
- o, null);
- assertEquals("map.remove for nonexistent key should not " +
- "shrink map", size, map.size());
- }
- verify();
- }
-
- public void testFailFastEntrySet() {
- if (!isAddRemoveModifiable()) {
- return;
- }
- if (!isFailFastExpected()) {
- return;
- }
- resetFull();
- Iterator<Map.Entry> it = map.entrySet().iterator();
- final Map.Entry val = it.next();
- map.remove(val.getKey());
- try {
- it.next();
- fail();
- } catch (ConcurrentModificationException expected) {}
-
- resetFull();
- it = map.entrySet().iterator();
- it.next();
- map.clear();
- try {
- it.next();
- fail();
- } catch (ConcurrentModificationException expected) {}
- }
-
- public void testFailFastKeySet() {
- if (!isAddRemoveModifiable()) {
- return;
- }
- if (!isFailFastExpected()) {
- return;
- }
- resetFull();
- Iterator it = map.keySet().iterator();
- final Object val = it.next();
- map.remove(val);
- try {
- it.next();
- fail();
- } catch (ConcurrentModificationException expected) {}
-
- resetFull();
- it = map.keySet().iterator();
- it.next();
- map.clear();
- try {
- it.next();
- fail();
- } catch (ConcurrentModificationException expected) {}
- }
-
- public void testFailFastValues() {
- if (!isAddRemoveModifiable()) {
- return;
- }
- if (!isFailFastExpected()) {
- return;
- }
- resetFull();
- Iterator it = map.values().iterator();
- it.next();
- map.remove(map.keySet().iterator().next());
- try {
- it.next();
- fail();
- } catch (ConcurrentModificationException expected) {}
-
- resetFull();
- it = map.values().iterator();
- it.next();
- map.clear();
- try {
- it.next();
- fail();
- } catch (ConcurrentModificationException expected) {}
- }
-
- /**
- * Utility methods to create an array of Map.Entry objects
- * out of the given key and value arrays.<P>
- *
- * @param keys the array of keys
- * @param values the array of values
- * @return an array of Map.Entry of those keys to those values
- */
- private Map.Entry[] makeEntryArray(Object[] keys, Object[] values) {
- Map.Entry[] result = new Map.Entry[keys.length];
- for (int i = 0; i < keys.length; i++) {
- result[i] = new DefaultMapEntry(keys[i], values[i]);
- }
- return result;
- }
-
-
- class TestMapEntrySet extends TestSet {
- public TestMapEntrySet() {
- super("");
- }
-
- // Have to implement manually; entrySet doesn't support addAll
- @Override
- protected Object[] getFullElements() {
- Object[] k = getSampleKeys();
- Object[] v = getSampleValues();
- return makeEntryArray(k, v);
- }
-
- // Have to implement manually; entrySet doesn't support addAll
- @Override
- protected Object[] getOtherElements() {
- Object[] k = getOtherKeys();
- Object[] v = getOtherValues();
- return makeEntryArray(k, v);
- }
-
- @Override
- protected Set makeEmptySet() {
- return makeEmptyMap().entrySet();
- }
-
- @Override
- protected Set makeFullSet() {
- return makeFullMap().entrySet();
- }
-
- @Override
- protected boolean isAddSupported() {
- // Collection views don't support add operations.
- return false;
- }
-
- @Override
- protected boolean isRemoveSupported() {
- // Entry set should only support remove if map does
- return isAddRemoveModifiable();
- }
-
- @Override
- protected void resetFull() {
- TestMap.this.resetFull();
- collection = map.entrySet();
- TestMapEntrySet.this.confirmed = TestMap.this.confirmed.entrySet();
- }
-
- @Override
- protected void resetEmpty() {
- TestMap.this.resetEmpty();
- collection = map.entrySet();
- TestMapEntrySet.this.confirmed = TestMap.this.confirmed.entrySet();
- }
-
- @Override
- protected void verify() {
- super.verify();
- TestMap.this.verify();
- }
- }
-
-
-
- class TestMapKeySet extends TestSet {
- public TestMapKeySet() {
- super("");
- }
- @Override
- protected Object[] getFullElements() {
- return getSampleKeys();
- }
-
- @Override
- protected Object[] getOtherElements() {
- return getOtherKeys();
- }
-
- @Override
- protected Set makeEmptySet() {
- return makeEmptyMap().keySet();
- }
-
- @Override
- protected Set makeFullSet() {
- return makeFullMap().keySet();
- }
-
- @Override
- protected boolean isAddSupported() {
- return false;
- }
-
- @Override
- protected boolean isRemoveSupported() {
- return isAddRemoveModifiable();
- }
-
- @Override
- protected void resetEmpty() {
- TestMap.this.resetEmpty();
- collection = map.keySet();
- TestMapKeySet.this.confirmed = TestMap.this.confirmed.keySet();
- }
-
- @Override
- protected void resetFull() {
- TestMap.this.resetFull();
- collection = map.keySet();
- TestMapKeySet.this.confirmed = TestMap.this.confirmed.keySet();
- }
-
- @Override
- protected void verify() {
- super.verify();
- TestMap.this.verify();
- }
- }
-
-
-
- class TestMapValues extends TestCollection {
- public TestMapValues() {
-
- }
-
- @Override
- protected Object[] getFullElements() {
- return getSampleValues();
- }
-
- @Override
- protected Object[] getOtherElements() {
- return getOtherValues();
- }
-
- @Override
- protected Collection makeCollection() {
- return makeEmptyMap().values();
- }
-
- @Override
- protected Collection makeFullCollection() {
- return makeFullMap().values();
- }
-
- @Override
- protected boolean isAddSupported() {
- return false;
- }
-
- @Override
- protected boolean isRemoveSupported() {
- return isAddRemoveModifiable();
- }
-
- @Override
- protected boolean areEqualElementsDistinguishable() {
- // equal values are associated with different keys, so they are
- // distinguishable.
- return true;
- }
-
- @Override
- protected Collection makeConfirmedCollection() {
- // never gets called, reset methods are overridden
- return null;
- }
-
- @Override
- protected Collection makeConfirmedFullCollection() {
- // never gets called, reset methods are overridden
- return null;
- }
-
- @Override
- protected void resetFull() {
- TestMap.this.resetFull();
- collection = map.values();
- TestMapValues.this.confirmed = TestMap.this.confirmed.values();
- }
-
- @Override
- protected void resetEmpty() {
- TestMap.this.resetEmpty();
- collection = map.values();
- TestMapValues.this.confirmed = TestMap.this.confirmed.values();
- }
-
- @Override
- protected void verify() {
- super.verify();
- TestMap.this.verify();
- }
-
- // TODO: should test that a remove on the values collection view
- // removes the proper mapping and not just any mapping that may have
- // the value equal to the value returned from the values iterator.
- }
-
-
- /**
- * Resets the {@link #map}, {@link #entrySet}, {@link #keySet},
- * {@link #collectionValues} and {@link #confirmed} fields to empty.
- */
- protected void resetEmpty() {
- this.map = makeEmptyMap();
- views();
- this.confirmed = makeConfirmedMap();
- }
-
-
- /**
- * Resets the {@link #map}, {@link #entrySet}, {@link #keySet},
- * {@link #collectionValues} and {@link #confirmed} fields to full.
- */
- protected void resetFull() {
- this.map = makeFullMap();
- views();
- this.confirmed = makeConfirmedMap();
- Object[] k = getSampleKeys();
- Object[] v = getSampleValues();
- for (int i = 0; i < k.length; i++) {
- confirmed.put(k[i], v[i]);
- }
- }
-
-
- /**
- * Resets the collection view fields.
- */
- private void views() {
- this.keySet = map.keySet();
- this.collectionValues = map.values();
- this.entrySet = map.entrySet();
- }
-
-
- /**
- * Verifies that {@link #map} is still equal to {@link #confirmed}.
- * This method checks that the map is equal to the HashMap,
- * <I>and</I> that the map's collection views are still equal to
- * the HashMap's collection views. An <Code>equals</Code> test
- * is done on the maps and their collection views; their size and
- * <Code>isEmpty</Code> results are compared; their hashCodes are
- * compared; and <Code>containsAll</Code> tests are run on the
- * collection views.
- */
- protected void verify() {
- verifyMap();
- verifyEntrySet();
- verifyKeySet();
-
- }
-
- protected void verifyMap() {
- int size = confirmed.size();
- boolean empty = confirmed.isEmpty();
- assertEquals("Map should be same size as HashMap",
- size, map.size());
- assertEquals("Map should be empty if HashMap is",
- empty, map.isEmpty());
- assertEquals("hashCodes should be the same",
- confirmed.hashCode(), map.hashCode());
- // this fails for LRUMap because confirmed.equals() somehow modifies
- // map, causing concurrent modification exceptions.
- //assertEquals("Map should still equal HashMap", confirmed, map);
- // this works though and performs the same verification:
- assertTrue("Map should still equal HashMap", map.equals(confirmed));
- // TODO: this should really be rexamined to figure out why LRU map
- // behaves like it does (the equals shouldn't modify since all accesses
- // by the confirmed collection should be through an iterator, thus not
- // causing LRUMap to change).
- }
-
- protected void verifyEntrySet() {
- int size = confirmed.size();
- boolean empty = confirmed.isEmpty();
- assertEquals("entrySet should be same size as HashMap's",
- size, entrySet.size());
- assertEquals("entrySet should be empty if HashMap is",
- empty, entrySet.isEmpty());
- assertTrue("entrySet should contain all HashMap's elements",
- entrySet.containsAll(confirmed.entrySet()));
- assertEquals("entrySet hashCodes should be the same",
- confirmed.entrySet().hashCode(), entrySet.hashCode());
- assertEquals("Map's entry set should still equal HashMap's",
- confirmed.entrySet(), entrySet);
- }
-
- protected void verifyKeySet() {
- int size = confirmed.size();
- boolean empty = confirmed.isEmpty();
- assertEquals("keySet should be same size as HashMap's",
- size, keySet.size());
- assertEquals("keySet should be empty if HashMap is",
- empty, keySet.isEmpty());
- assertTrue("keySet should contain all HashMap's elements",
- keySet.containsAll(confirmed.keySet()));
- assertEquals("keySet hashCodes should be the same",
- confirmed.keySet().hashCode(), keySet.hashCode());
- assertEquals("Map's key set should still equal HashMap's",
- confirmed.keySet(), keySet);
- }
-
-}
diff --git a/user/test/org/apache/commons/collections/TestObject.java b/user/test/org/apache/commons/collections/TestObject.java
deleted file mode 100644
index a66cce2..0000000
--- a/user/test/org/apache/commons/collections/TestObject.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright 1999-2004 The Apache Software Foundation
- *
- * 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 org.apache.commons.collections;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-/**
- * Tests base {@link java.lang.Object} methods and contracts.
- * <p>
- * To use, simply extend this class, and implement
- * the {@link #makeObject()} method.
- * <p>
- * If your {@link Object} fails one of these tests by design,
- * you may still use this base set of cases. Simply override the
- * test case (method) your {@link Object} fails.
- *
- * @author Rodney Waldhoff
- * @version $Id: TestObject.java,v 1.13.2.1 2004/05/22 12:14:05 scolebourne Exp $
- */
-public abstract class TestObject extends EmulTestBase {
-
-
- // current major release for Collections
- public static final int COLLECTIONS_MAJOR_VERSION = 2;
-
- /**
- * This constant makes it possible for TestMap (and other subclasses,
- * if necessary) to automatically check CVS for a versionX copy of a
- * Serialized object, so we can make sure that compatibility is maintained.
- * See, for example, TestMap.getCanonicalFullMapName(Map map).
- * Subclasses can override this variable, indicating compatibility
- * with earlier Collections versions.
- * Defaults to 1, the earliest Collections version. (Note: some
- * collections did not even exist in this version).
- *
- * @return 1
- */
- public int getCompatibilityVersion() {
- return 1;
- }
-
- /**
- * Return a new, empty {@link Object} to used for testing.
- */
- public abstract Object makeObject();
-
- public void testObjectEqualsSelf() {
- Object obj = makeObject();
- assertEquals("A Object should equal itself",obj,obj);
- }
-
- public void testObjectHashCodeEqualsSelfHashCode() {
- Object obj = makeObject();
- assertEquals("hashCode should be repeatable",obj.hashCode(),obj.hashCode());
- }
-
- public void testObjectHashCodeEqualsContract() {
- Object obj1 = makeObject();
- if(obj1.equals(obj1)) {
- assertEquals("[1] When two objects are equal, their hashCodes should be also.",obj1.hashCode(),obj1.hashCode());
- }
- Object obj2 = makeObject();
- if(obj1.equals(obj2)) {
- assertEquals("[2] When two objects are equal, their hashCodes should be also.",obj1.hashCode(),obj2.hashCode());
- assertTrue("When obj1.equals(obj2) is true, then obj2.equals(obj1) should also be true", obj2.equals(obj1));
- }
- }
-
-
-
- public String getCanonicalEmptyCollectionName(Object object) {
- StringBuffer retval = new StringBuffer();
- retval.append("data/test/");
- String colName = object.getClass().getName();
-
- colName = colName.substring(colName.lastIndexOf(".")+1,colName.length());
- retval.append(colName);
- retval.append(".emptyCollection.version");
- retval.append(getCompatibilityVersion());
- retval.append(".obj");
- return retval.toString();
- }
-
- public String getCanonicalFullCollectionName(Object object) {
- StringBuffer retval = new StringBuffer();
- retval.append("data/test/");
- String colName = object.getClass().getName();
- colName = colName.substring(colName.lastIndexOf(".")+1,colName.length());
- retval.append(colName);
- retval.append(".fullCollection.version");
- retval.append(getCompatibilityVersion());
- retval.append(".obj");
- return retval.toString();
- }
-
- /**
- * Override this method if a subclass is testing a
- * Collections that cannot serialize an "empty" Collection
- * (e.g. Comparators have no contents)
- *
- * @return true
- */
- public boolean supportsEmptyCollections() {
- return true;
- }
-
- /**
- * Override this method if a subclass is testing a
- * Collections that cannot serialize a "full" Collection
- * (e.g. Comparators have no contents)
- *
- * @return true
- */
- public boolean supportsFullCollections() {
- return true;
- }
-
-
-
-}
diff --git a/user/test/org/apache/commons/collections/TestSet.java b/user/test/org/apache/commons/collections/TestSet.java
deleted file mode 100644
index 69580f0..0000000
--- a/user/test/org/apache/commons/collections/TestSet.java
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright 1999-2004 The Apache Software Foundation
- *
- * 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 org.apache.commons.collections;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Set;
-
-/**
- * Tests base {@link Set} methods and contracts.<P>
- *
- * Since {@link Set} doesn't stipulate much new behavior that isn't already
- * found in {@link Collection}, this class basically just adds tests for
- * {@link Set#equals()} and {@link Set#hashCode()} along with an updated
- * {@link #verify()} that ensures elements do not appear more than once in the
- * set.<P>
- *
- * To use, subclass and override the {@link #makeEmptySet()}
- * method. You may have to override other protected methods if your
- * set is not modifiable, or if your set restricts what kinds of
- * elements may be added; see {@link TestCollection} for more details.<P>
- *
- * @author Paul Jack
- * @version $Id: TestSet.java,v 1.2.2.1 2004/05/22 12:14:05 scolebourne Exp $
- */
-@SuppressWarnings({"unchecked", "rawtypes"})
-public abstract class TestSet extends TestCollection {
-
-
- /**
- * Constructor.
- *
- * @param name name for test
- */
- public TestSet(String name) {
-
- }
-
-
- /**
- * Makes an empty collection by invoking {@link #makeEmptySet()}.
- *
- * @return an empty collection
- */
- @Override
- protected final Collection makeCollection() {
- return makeEmptySet();
- }
-
-
- /**
- * Makes a full collection by invoking {@link #makeFullSet()}.
- *
- * @return a full collection
- */
- @Override
- protected final Collection makeFullCollection() {
- return makeFullSet();
- }
-
- /**
- * Return the {@link TestCollection#collection} fixture, but cast as a
- * Set.
- */
- protected Set getSet() {
- return (Set)collection;
- }
-
- /**
- * Returns an empty {@link HashSet} for use in modification testing.
- *
- * @return a confirmed empty collection
- */
- @Override
- protected Collection makeConfirmedCollection() {
- return new HashSet();
- }
-
-
- /**
- * Returns a full {@link HashSet} for use in modification testing.
- *
- * @return a confirmed full collection
- */
- @Override
- protected Collection makeConfirmedFullCollection() {
- HashSet set = new HashSet();
- set.addAll(Arrays.asList(getFullElements()));
- return set;
- }
-
- /**
- * Return the {@link TestCollection#confirmed} fixture, but cast as a
- * Set.
- **/
- protected Set getConfirmedSet() {
- return (Set)confirmed;
- }
-
- /**
- * Makes an empty set. The returned set should have no elements.
- *
- * @return an empty set
- */
- protected abstract Set makeEmptySet();
-
-
- /**
- * Makes a full set by first creating an empty set and then adding
- * all the elements returned by {@link #getFullElements()}.
- *
- * Override if your set does not support the add operation.
- *
- * @return a full set
- */
- protected Set makeFullSet() {
- Set set = makeEmptySet();
- set.addAll(Arrays.asList(getFullElements()));
- return set;
- }
-
-
- /**
- * Tests {@link Set#equals(Object)}.
- */
- public void testSetEquals() {
- resetEmpty();
- assertEquals("Empty sets should be equal",
- getSet(), getConfirmedSet());
- verify();
-
- HashSet set2 = new HashSet();
- set2.add("foo");
- assertTrue("Empty set shouldn't equal nonempty set",
- !getSet().equals(set2));
-
- resetFull();
- assertEquals("Full sets should be equal", getSet(), getConfirmedSet());
- verify();
-
- set2.clear();
- set2.addAll(Arrays.asList(getOtherElements()));
- assertTrue("Sets with different contents shouldn't be equal",
- !getSet().equals(set2));
- }
-
-
- /**
- * Tests {@link Set#hashCode()}.
- */
- public void testSetHashCode() {
- resetEmpty();
- assertEquals("Empty sets have equal hashCodes",
- getSet().hashCode(), getConfirmedSet().hashCode());
-
- resetFull();
- assertEquals("Equal sets have equal hashCodes",
- getSet().hashCode(), getConfirmedSet().hashCode());
- }
-
-
- /**
- * Provides additional verifications for sets.
- */
- @Override
- protected void verify() {
- super.verify();
- assertEquals("Sets should be equal", confirmed, collection);
- assertEquals("Sets should have equal hashCodes",
- confirmed.hashCode(), collection.hashCode());
- HashSet set = new HashSet();
- Iterator iterator = collection.iterator();
- while (iterator.hasNext()) {
- assertTrue("Set.iterator should only return unique elements",
- set.add(iterator.next()));
- }
- }
-
-}
diff --git a/user/test/org/apache/commons/collections/package-info.java b/user/test/org/apache/commons/collections/package-info.java
deleted file mode 100644
index a1615b4..0000000
--- a/user/test/org/apache/commons/collections/package-info.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright 2010 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.
- */
-
-/**
- * This packages code originated from Apache, so it seperate from gwt
- * code. However, as gwt does not support all of Apache Collections,
- * this package has been <b>heavily</b> modified, so replace it with a
- * new version only if you wish to do all the modifications again.
- */
-package org.apache.commons.collections;
