linkedlisttest.java

SRI international 发布的OAA框架软件

//    }
//
//    /**
//     * retainAll(c) retains only those elements of c and reports true if changed
//     */
//    public void testRetainAll() {
//        LinkedList q = populatedQueue(SIZE);
//        LinkedList p = populatedQueue(SIZE);
//        for (int i = 0; i < SIZE; ++i) {
//            boolean changed = q.retainAll(p);
//            if (i == 0)
//                assertFalse(changed);
//            else
//                assertTrue(changed);
//
//            assertTrue(q.containsAll(p));
//            assertEquals(SIZE-i, q.size());
//            p.remove();
//        }
//    }
//
//    /**
//     * removeAll(c) removes only those elements of c and reports true if changed
//     */
//    public void testRemoveAll() {
//        for (int i = 1; i < SIZE; ++i) {
//            LinkedList q = populatedQueue(SIZE);
//            LinkedList p = populatedQueue(i);
//            assertTrue(q.removeAll(p));
//            assertEquals(SIZE-i, q.size());
//            for (int j = 0; j < i; ++j) {
//                Integer I = (Integer)(p.remove());
//                assertFalse(q.contains(I));
//            }
//        }
//    }
//
//    /**
//     *  toArray contains all elements
//     */
//    public void testToArray() {
//        LinkedList q = populatedQueue(SIZE);
//	Object[] o = q.toArray();
//        Arrays.sort(o);
//	for(int i = 0; i < o.length; i++)
//	    assertEquals(o[i], q.poll());
//    }
//
//    /**
//     *  toArray(a) contains all elements
//     */
//    public void testToArray2() {
//        LinkedList q = populatedQueue(SIZE);
//	Integer[] ints = new Integer[SIZE];
//	ints = (Integer[])q.toArray(ints);
//        Arrays.sort(ints);
//        for(int i = 0; i < ints.length; i++)
//            assertEquals(ints[i], q.poll());
//    }
//
//    /**
//     * toArray(null) throws NPE
//     */
//    public void testToArray_BadArg() {
//	try {
//	    LinkedList l = new LinkedList();
//	    l.add(new Object());
//	    Object o[] = l.toArray(null);
//	    shouldThrow();
//	} catch(NullPointerException success){}
//    }
//
//    /**
//     * toArray with incompatable aray type throws CCE
//     */
//    public void testToArray1_BadArg() {
//	try {
//	    LinkedList l = new LinkedList();
//	    l.add(new Integer(5));
//	    Object o[] = l.toArray(new String[10] );
//	    shouldThrow();
//	} catch(ArrayStoreException  success){}
//    }
//
//    /**
//     *  iterator iterates through all elements
//     */
//    public void testIterator() {
//        LinkedList q = populatedQueue(SIZE);
//        int i = 0;
//	Iterator it = q.iterator();
//        while(it.hasNext()) {
//            assertTrue(q.contains(it.next()));
//            ++i;
//        }
//        assertEquals(i, SIZE);
//    }
//
//    /**
//     *  iterator ordering is FIFO
//     */
//    public void testIteratorOrdering() {
//        final LinkedList q = new LinkedList();
//        q.add(new Integer(1));
//        q.add(new Integer(2));
//        q.add(new Integer(3));
//        int k = 0;
//        for (Iterator it = q.iterator(); it.hasNext();) {
//            int i = ((Integer)(it.next())).intValue();
//            assertEquals(++k, i);
//        }
//
//        assertEquals(3, k);
//    }
//
//    /**
//     * iterator.remove removes current element
//     */
//    public void testIteratorRemove () {
//        final LinkedList q = new LinkedList();
//        q.add(new Integer(1));
//        q.add(new Integer(2));
//        q.add(new Integer(3));
//        Iterator it = q.iterator();
//        it.next();
//        it.remove();
//        it = q.iterator();
//        assertEquals(it.next(), new Integer(2));
//        assertEquals(it.next(), new Integer(3));
//        assertFalse(it.hasNext());
//    }
//
//
//    /**
//     * toString contains toStrings of elements
//     */
//    public void testToString() {
//        LinkedList q = populatedQueue(SIZE);
//        String s = q.toString();
//        for (int i = 0; i < SIZE; ++i) {
//            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
//        }
//    }
//
//    /**
//     * peek returns element inserted with addFirst
//     */
//    public void testAddFirst() {
//        LinkedList q = populatedQueue(3);
//	q.addFirst(four);
//	assertEquals(four,q.peek());
//    }
//
//    /**
//     * peekFirst returns element inserted with push
//     */
//    public void testPush() {
//        LinkedList q = populatedQueue(3);
//        q.pollLast();
//	q.push(four);
//	assertEquals(four,q.peekFirst());
//    }
//
//    /**
//     *  pop removes next element, or throws NSEE if empty
//     */
//    public void testPop() {
//        LinkedList q = populatedQueue(SIZE);
//        for (int i = 0; i < SIZE; ++i) {
//            assertEquals(i, ((Integer)q.pop()).intValue());
//        }
//        try {
//            q.pop();
//            shouldThrow();
//        } catch (NoSuchElementException success){
//	}
//    }
//
//    /**
//     * OfferFirst succeeds
//     */
//    public void testOfferFirst() {
//        LinkedList q = new LinkedList();
//        assertTrue(q.offerFirst(new Integer(0)));
//        assertTrue(q.offerFirst(new Integer(1)));
//    }
//
//    /**
//     * OfferLast succeeds
//     */
//    public void testOfferLast() {
//        LinkedList q = new LinkedList();
//        assertTrue(q.offerLast(new Integer(0)));
//        assertTrue(q.offerLast(new Integer(1)));
//    }
//
//    /**
//     *  pollLast succeeds unless empty
//     */
//    public void testPollLast() {
//        LinkedList q = populatedQueue(SIZE);
//        for (int i = SIZE-1; i >= 0; --i) {
//            assertEquals(i, ((Integer)q.pollLast()).intValue());
//        }
//	assertNull(q.pollLast());
//    }
//
//    /**
//     *  peekFirst returns next element, or null if empty
//     */
//    public void testPeekFirst() {
//        LinkedList q = populatedQueue(SIZE);
//        for (int i = 0; i < SIZE; ++i) {
//            assertEquals(i, ((Integer)q.peekFirst()).intValue());
//            q.pollFirst();
//            assertTrue(q.peekFirst() == null ||
//                       i != ((Integer)q.peekFirst()).intValue());
//        }
//	assertNull(q.peekFirst());
//    }
//
//
//    /**
//     *  peekLast returns next element, or null if empty
//     */
//    public void testPeekLast() {
//        LinkedList q = populatedQueue(SIZE);
//        for (int i = SIZE-1; i >= 0; --i) {
//            assertEquals(i, ((Integer)q.peekLast()).intValue());
//            q.pollLast();
//            assertTrue(q.peekLast() == null ||
//                       i != ((Integer)q.peekLast()).intValue());
//        }
//	assertNull(q.peekLast());
//    }
//
//    public void testFirstElement() {
//        LinkedList q = populatedQueue(SIZE);
//        for (int i = 0; i < SIZE; ++i) {
//            assertEquals(i, ((Integer)q.getFirst()).intValue());
//            q.pollFirst();
//        }
//        try {
//            q.getFirst();
//            shouldThrow();
//        }
//        catch (NoSuchElementException success) {}
//    }
//
//    /**
//     *  getLast returns next element, or throws NSEE if empty
//     */
//    public void testLastElement() {
//        LinkedList q = populatedQueue(SIZE);
//        for (int i = SIZE-1; i >= 0; --i) {
//            assertEquals(i, ((Integer)q.getLast()).intValue());
//            q.pollLast();
//        }
//        try {
//            q.getLast();
//            shouldThrow();
//        }
//        catch (NoSuchElementException success) {}
//	assertNull(q.peekLast());
//    }
//
//    /**
//     * removeFirstOccurrence(x) removes x and returns true if present
//     */
//    public void testRemoveFirstOccurrence() {
//        LinkedList q = populatedQueue(SIZE);
//        for (int i = 1; i < SIZE; i+=2) {
//            assertTrue(q.removeFirstOccurrence(new Integer(i)));
//        }
//        for (int i = 0; i < SIZE; i+=2) {
//            assertTrue(q.removeFirstOccurrence(new Integer(i)));
//            assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
//        }
//        assertTrue(q.isEmpty());
//    }
//
//    /**
//     * removeLastOccurrence(x) removes x and returns true if present
//     */
//    public void testRemoveLastOccurrence() {
//        LinkedList q = populatedQueue(SIZE);
//        for (int i = 1; i < SIZE; i+=2) {
//            assertTrue(q.removeLastOccurrence(new Integer(i)));
//        }
//        for (int i = 0; i < SIZE; i+=2) {
//            assertTrue(q.removeLastOccurrence(new Integer(i)));
//            assertFalse(q.removeLastOccurrence(new Integer(i+1)));
//        }
//        assertTrue(q.isEmpty());
//    }
}