/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.emultest.java.util;
import org.apache.commons.collections.TestArrayList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.ListIterator;
/**
* 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;
public void testAddAll() {
assertFalse(makeEmptyList().addAll(makeEmptyList()));
assertTrue(makeEmptyList().addAll(makeFullList()));
assertFalse(makeEmptyList().addAll(0, makeEmptyList()));
assertTrue(makeEmptyList().addAll(0, makeFullList()));
assertFalse(makeFullList().addAll(makeEmptyList()));
assertTrue(makeFullList().addAll(makeFullList()));
assertFalse(makeFullList().addAll(1, makeEmptyList()));
assertTrue(makeFullList().addAll(1, makeFullList()));
}
public void testAddWatch() {
List s = makeEmptyList();
s.add("watch");
assertEquals(s.get(0), "watch");
}
public void testListIteratorAddInSeveralPositions() {
List l = makeEmptyList();
ListIterator i = l.listIterator();
l.add(new Integer(0));
for (int n = 2; n < 5; n += 2) {
l.add(new Integer(n));
}
i = l.listIterator();
i.next();
i.add(new Integer(1));
i.next();
i.next();
i.previous();
i.add(new Integer(3));
i.next();
i.add(new Integer(5));
i.add(new Integer(6));
for (int n = 0; n < 6; n++) {
assertEquals(new Integer(n), l.get(n));
}
}
public void testListIteratorCreateInvalid() {
List l = makeEmptyList();
l.add(new Integer(1));
l.listIterator(0);
try {
l.listIterator(1);
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
l.listIterator(-1);
} catch (IndexOutOfBoundsException e) {
// expected
}
}
public void testListIteratorHasNextHasPreviousAndIndexes() {
List l = makeEmptyList();
ListIterator i = l.listIterator();
assertFalse(i.hasNext());
assertFalse(i.hasPrevious());
i.add(new Integer(1));
assertEquals(1, i.nextIndex());
assertEquals(0, i.previousIndex());
i = l.listIterator();
assertEquals(0, i.nextIndex());
assertEquals(-1, i.previousIndex());
assertTrue(i.hasNext());
assertFalse(i.hasPrevious());
i.next();
assertEquals(1, i.nextIndex());
assertEquals(0, i.previousIndex());
assertFalse(i.hasNext());
assertTrue(i.hasPrevious());
}
public void testListIteratorRemove() {
// TODO(jat): implement
}
public void testListIteratorSetInSeveralPositions() {
List l = makeEmptyList();
for (int n = 0; n < 5; n += 2) {
l.add(new Integer(n));
}
l.listIterator();
for (int n = 0; n < 3; n++) {
l.set(n, new Integer(n));
}
for (int n = 0; n < 3; n++) {
assertEquals(new Integer(n), l.get(n));
}
}
public void testRemoveAllDuplicates() {
Collection c = makeCollection();
c.add("a");
c.add("a");
Collection d = makeCollection();
d.add("a");
assertTrue(c.removeAll(d));
assertEquals(0, c.size());
}
public void testSubList() {
List<Integer> wrappedList = createListWithContent(new int[] {1, 2, 3, 4, 5});
List<Integer> testList = wrappedList.subList(1, 4);
assertEquals(3, testList.size());
assertEquals(testList, Arrays.asList(2, 3, 4));
checkListSizeAndContent(testList, 2, 3, 4);
testList.add(1, 6);
assertEquals(testList, Arrays.asList(2, 6, 3, 4));
checkListSizeAndContent(testList, 2, 6, 3, 4);
assertEquals(wrappedList, Arrays.asList(1, 2, 6, 3, 4, 5));
checkListSizeAndContent(wrappedList, 1, 2, 6, 3, 4, 5);
testList.remove(2);
assertEquals(testList, Arrays.asList(2, 6, 4));
checkListSizeAndContent(testList, 2, 6, 4);
try {
testList.remove(3);
fail("Expected remove to fail");
} catch (IndexOutOfBoundsException e) {
}
checkListSizeAndContent(wrappedList, 1, 2, 6, 4, 5);
testList.set(0, 7);
checkListSizeAndContent(testList, 7, 6, 4);
checkListSizeAndContent(wrappedList, 1, 7, 6, 4, 5);
try {
wrappedList.subList(-1, 5);
fail("expected IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
}
try {
wrappedList.subList(0, 15);
fail("expected IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
}
try {
wrappedList.subList(5, 1);
fail("expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
}
try {
wrappedList.subList(0, 1).add(2, 5);
fail("expected IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
}
try {
wrappedList.subList(0, 1).add(-1, 5);
fail("expected IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
}
try {
wrappedList.subList(0, 1).get(1);
fail("expected IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
}
try {
wrappedList.subList(0, 1).get(-1);
fail("expected IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
}
try {
wrappedList.subList(0, 1).set(2, 2);
fail("expected IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
}
try {
wrappedList.subList(0, 1).set(-1, 5);
fail("expected IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
}
}
/**
* 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);
assertEquals(2, sublist.size());
sublist.add(33);
sublist.add(34);
assertEquals(4, sublist.size());
assertEquals(7, baseList.size());
/*
* Assert correct values are found right before and after insertion. We're
* checking the original list (baseList) even though the changes were made
* in the sublist. That is because modifications made to the list returned
* by sublist method should reflect in the original list.
*/
assertEquals(3, (int) baseList.get(2));
assertEquals(33, (int) baseList.get(3));
assertEquals(34, (int) baseList.get(4));
assertEquals(4, (int) baseList.get(5));
/*
* Assert that it is possible to add element at the beginning of the
* sublist.
*/
sublist.add(0, 22);
sublist.add(0, 21);
checkListSizeAndContent(sublist, 21, 22, 2, 3, 33, 34);
checkListSizeAndContent(baseList, 1, 21, 22, 2, 3, 33, 34, 4, 5);
// check adding at the end by specifying the index
sublist.add(6, 35);
checkListSizeAndContent(sublist, 21, 22, 2, 3, 33, 34, 35);
checkListSizeAndContent(baseList, 1, 21, 22, 2, 3, 33, 34, 35, 4, 5);
/*
* Assert adding to underlying list after the sublist view has been defined.
* After such an action behavior of sublist is undefined.
*/
baseList.add(9, 44);
baseList.add(55);
baseList.add(0, 10);
checkListSizeAndContent(baseList, 10, 1, 21, 22, 2, 3, 33, 34, 35, 4, 44, 5, 55);
}
public void testSubListRemove() {
List<Integer> baseList = createListWithContent(new int[] {1, 2, 3, 4, 5});
List<Integer> sublist = baseList.subList(1, 3);
sublist.remove(0);
assertEquals(4, baseList.size());
assertEquals(3, baseList.get(1).intValue());
try {
sublist.remove(1);
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);
}
public void testToArray() {
List l = makeEmptyList();
for (int i = 0; i < 10; i++) {
l.add(new Integer(i));
}
{
Object[] objArray = l.toArray();
assertEquals(10, objArray.length);
for (int i = 0; i < 10; i++) {
Integer elem = (Integer) objArray[i];
assertEquals(i, elem.intValue());
}
// should not cause ArrayStore
objArray[0] = new Object();
}
{
Integer[] firstArray = new Integer[13];
firstArray[10] = new Integer(10);
firstArray[11] = new Integer(11);
firstArray[12] = new Integer(12);
Integer[] intArray = (Integer[]) l.toArray(firstArray);
assertTrue(firstArray == intArray);
assertEquals(13, intArray.length);
for (int i = 0; i < 13; i++) {
if (i == 10) {
assertNull(intArray[i]);
} else {
Integer elem = intArray[i];
assertEquals(i, elem.intValue());
}
}
try {
Object[] objArray = NO_OPTIMIZE_FALSE ? new Object[1] : intArray;
assertTrue(objArray instanceof Integer[]);
objArray[0] = new Object();
fail("expected ArrayStoreException");
} catch (ArrayStoreException e) {
}
}
{
Integer[] firstArray = new Integer[0];
Integer[] intArray = (Integer[]) l.toArray(firstArray);
assertFalse(firstArray == intArray);
assertEquals(10, intArray.length);
for (int i = 0; i < 10; i++) {
Integer elem = intArray[i];
assertEquals(i, elem.intValue());
}
try {
Object[] objArray = NO_OPTIMIZE_FALSE ? new Object[1] : intArray;
assertTrue(objArray instanceof Integer[]);
objArray[0] = new Object();
fail("expected ArrayStoreException");
} catch (ArrayStoreException e) {
}
}
}
private void checkListSizeAndContent(List<Integer> in, int... expected) {
assertEquals(expected.length, in.size());
for (int i = 0; i < expected.length; i++) {
assertEquals(expected[i], (int) in.get(i));
}
}
private List<Integer> createListWithContent(int[] in) {
List<Integer> results = new ArrayList<Integer>();
for (int i = 0; i < in.length; i++) {
results.add(in[i]);
}
return results;
}
}