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()); }