static List populatedArray(int n) {
List a = ParallelArray.createEmpty(n, Object.class, ParallelArray.defaultExecutor()).asList();
assertTrue(a.isEmpty());
for (int i = 0; i < n; ++i) a.add(new Integer(i));
assertFalse(a.isEmpty());
assertEquals(n, a.size());
return a;
}
/** listIterator only returns those elements after the given index */
public void testListIterator2() {
List full = populatedArray(3);
ListIterator i = full.listIterator(1);
int j;
for (j = 0; i.hasNext(); j++) assertEquals(j + 1, ((Integer) i.next()).intValue());
assertEquals(2, j);
}
/** lastIndexOf returns the index for the given object */
public void testLastIndexOf1() {
List full = populatedArray(3);
full.add(one);
full.add(three);
assertEquals(3, full.lastIndexOf(one));
assertEquals(-1, full.lastIndexOf(six));
}
/** toString contains toString of elements */
public void testToString() {
List full = populatedArray(3);
String s = full.toString();
for (int i = 0; i < 3; ++i) {
assertTrue(s.indexOf(String.valueOf(i)) >= 0);
}
}
/** iterator() returns an iterator containing the elements of the list */
public void testIterator() {
List full = populatedArray(SIZE);
Iterator i = full.iterator();
int j;
for (j = 0; i.hasNext(); j++) assertEquals(j, ((Integer) i.next()).intValue());
assertEquals(SIZE, j);
}
/** get throws an IndexOutOfBoundsException on a negative index */
public void testGet1_IndexOutOfBoundsException() {
try {
List c = emptyArray();
c.get(-1);
shouldThrow();
} catch (IndexOutOfBoundsException e) {
}
}
/** remove throws an IndexOutOfBoundsException on a negative index */
public void testRemove1_IndexOutOfBounds() {
try {
List c = emptyArray();
c.remove(-1);
shouldThrow();
} catch (IndexOutOfBoundsException e) {
}
}
/** addAll throws an IndexOutOfBoundsException on a negative index */
public void testAddAll1_IndexOutOfBoundsException() {
try {
List c = emptyArray();
c.addAll(-1, new LinkedList());
shouldThrow();
} catch (IndexOutOfBoundsException e) {
}
}
/** toArray returns an Integer array containing all elements from the list */
public void testToArray2() {
List full = populatedArray(3);
Integer[] i = new Integer[3];
assertSame(i, full.toArray(i));
assertEquals(0, i[0].intValue());
assertEquals(1, i[1].intValue());
assertEquals(2, i[2].intValue());
}
/** toArray returns an Object array containing all elements from the list */
public void testToArray() {
List full = populatedArray(3);
Object[] o = full.toArray();
assertEquals(3, o.length);
assertEquals(0, ((Integer) o[0]).intValue());
assertEquals(1, ((Integer) o[1]).intValue());
assertEquals(2, ((Integer) o[2]).intValue());
}
/** listIterator throws an IndexOutOfBoundsException on a negative index */
public void testListIterator1_IndexOutOfBoundsException() {
try {
List c = emptyArray();
c.listIterator(-1);
shouldThrow();
} catch (IndexOutOfBoundsException e) {
}
}
/** removeAll removes all elements from the given collection */
public void testRemoveAll() {
List full = populatedArray(3);
Vector v = new Vector();
v.add(one);
v.add(two);
full.removeAll(v);
assertEquals(1, full.size());
}
/** iterator.remove removes element */
public void testIteratorRemove() {
List full = populatedArray(SIZE);
Iterator it = full.iterator();
Object first = full.get(0);
it.next();
it.remove();
assertFalse(full.contains(first));
}
/** add throws an IndexOutOfBoundsException on a negative index */
public void testAdd1_IndexOutOfBoundsException() {
try {
List c = emptyArray();
c.add(-1, "qwerty");
shouldThrow();
} catch (IndexOutOfBoundsException e) {
}
}
/** containsAll returns true for collection with subset of elements */
public void testContainsAll() {
List full = populatedArray(3);
Vector v = new Vector();
v.add(one);
v.add(two);
assertTrue(full.containsAll(v));
v.add(six);
assertFalse(full.containsAll(v));
}
/** subList throws an IndexOutOfBoundsException on a too high index */
public void testSubList2_IndexOutOfBoundsException() {
try {
List c = emptyArray();
c.add("asdasd");
c.subList(1, 100);
shouldThrow();
} catch (IndexOutOfBoundsException e) {
}
}
/** addAll adds each element from the given collection */
public void testAddAll() {
List full = populatedArray(3);
Vector v = new Vector();
v.add(three);
v.add(four);
v.add(five);
full.addAll(v);
assertEquals(6, full.size());
}
/** subList throws IndexOutOfBoundsException when the second index is lower then the first */
public void testSubList3_IndexOutOfBoundsException() {
try {
List c = emptyArray();
c.subList(3, 1);
shouldThrow();
} catch (IndexOutOfBoundsException e) {
}
}
/** remove throws an IndexOutOfBoundsException on a too high index */
public void testRemove2_IndexOutOfBounds() {
try {
List c = emptyArray();
c.add("asdasd");
c.add("adasdasd");
c.remove(100);
shouldThrow();
} catch (IndexOutOfBoundsException e) {
}
}
/** listIterator throws an IndexOutOfBoundsException on a too high index */
public void testListIterator2_IndexOutOfBoundsException() {
try {
List c = emptyArray();
c.add("adasd");
c.add("asdasdas");
c.listIterator(100);
shouldThrow();
} catch (IndexOutOfBoundsException e) {
}
}
/**
* toArray throws an ArrayStoreException when the given array can not store the objects inside the
* list
*/
public void testToArray_ArrayStoreException() {
try {
List c = emptyArray();
c.add("zfasdfsdf");
c.add("asdadasd");
c.toArray(new Long[5]);
shouldThrow();
} catch (ArrayStoreException e) {
}
}
/** set throws an IndexOutOfBoundsException on a too high index */
public void testSet2() {
try {
List c = emptyArray();
c.add("asdasd");
c.add("asdad");
c.set(100, "qwerty");
shouldThrow();
} catch (IndexOutOfBoundsException e) {
}
}
/** adding at an index places it in the indicated index */
public void testAddIndex() {
List full = populatedArray(3);
full.add(0, m1);
assertEquals(4, full.size());
assertEquals(m1, full.get(0));
assertEquals(zero, full.get(1));
full.add(2, m2);
assertEquals(5, full.size());
assertEquals(m2, full.get(2));
assertEquals(two, full.get(4));
}
/** lists with same elements are equal and have same hashCode */
public void testEquals() {
List a = populatedArray(3);
List b = populatedArray(3);
assertTrue(a.equals(b));
assertTrue(b.equals(a));
assertEquals(a.hashCode(), b.hashCode());
a.add(m1);
assertFalse(a.equals(b));
assertFalse(b.equals(a));
b.add(m1);
assertTrue(a.equals(b));
assertTrue(b.equals(a));
assertEquals(a.hashCode(), b.hashCode());
}
/** contains is true for added elements */
public void testContains() {
List full = populatedArray(3);
assertTrue(full.contains(one));
assertFalse(full.contains(five));
}
/** clear removes all elements from the list */
public void testClear() {
List full = populatedArray(SIZE);
full.clear();
assertEquals(0, full.size());
}
/** new list contains all elements of initializing array */
public void testConstructor2() {
Integer[] ints = new Integer[SIZE];
for (int i = 0; i < SIZE - 1; ++i) ints[i] = new Integer(i);
List a = ParallelArray.createUsingHandoff(ints, ParallelArray.defaultExecutor()).asList();
for (int i = 0; i < SIZE; ++i) assertEquals(ints[i], a.get(i));
}
/** a new list is empty */
public void testConstructor() {
List a = ParallelArray.createEmpty(1, Object.class, ParallelArray.defaultExecutor()).asList();
assertTrue(a.isEmpty());
}
/** size returns the number of elements */
public void testSize() {
List empty = emptyArray();
List full = populatedArray(SIZE);
assertEquals(SIZE, full.size());
assertEquals(0, empty.size());
}
/** sublists contains elements at indexes offset from their base */
public void testSubList() {
List a = populatedArray(10);
assertTrue(a.subList(1, 1).isEmpty());
for (int j = 0; j < 9; ++j) {
for (int i = j; i < 10; ++i) {
List b = a.subList(j, i);
for (int k = j; k < i; ++k) {
assertEquals(new Integer(k), b.get(k - j));
}
}
}
List s = a.subList(2, 5);
assertEquals(3, s.size());
s.set(2, m1);
assertEquals(a.get(4), m1);
s.clear();
assertEquals(7, a.size());
}
