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;