concurrentlinkedqueuetest.java

SRI international 发布的OAA框架软件

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/licenses/publicdomain
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */

import junit.framework.*;
import edu.emory.mathcs.backport.java.util.*;
import edu.emory.mathcs.backport.java.util.concurrent.*;
import java.io.*;

public class ConcurrentLinkedQueueTest extends JSR166TestCase {
//
//    public static void main(String[] args) {
//	junit.textui.TestRunner.run (suite());
//    }
//
//    public static Test suite() {
//	return new TestSuite(ConcurrentLinkedQueueTest.class);
//    }
//
//    /**
//     * Create a queue of given size containing consecutive
//     * Integers 0 ... n.
//     */
//    private ConcurrentLinkedQueue populatedQueue(int n) {
//        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
//        assertTrue(q.isEmpty());
//	for(int i = 0; i < n; ++i)
//	    assertTrue(q.offer(new Integer(i)));
//        assertFalse(q.isEmpty());
//	assertEquals(n, q.size());
//        return q;
//    }
//
//    /**
//     * new queue is empty
//     */
//    public void testConstructor1() {
//        assertEquals(0, new ConcurrentLinkedQueue().size());
//    }
//
//    /**
//     *  Initializing from null Collection throws NPE
//     */
//    public void testConstructor3() {
//        try {
//            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue((Collection)null);
//            shouldThrow();
//        }
//        catch (NullPointerException success) {}
//    }
//
//    /**
//     * Initializing from Collection of null elements throws NPE
//     */
//    public void testConstructor4() {
//        try {
//            Integer[] ints = new Integer[SIZE];
//            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
//            shouldThrow();
//        }
//        catch (NullPointerException success) {}
//    }
//
//    /**
//     * Initializing from Collection with some null elements throws NPE
//     */
//    public void testConstructor5() {
//        try {
//            Integer[] ints = new Integer[SIZE];
//            for (int i = 0; i < SIZE-1; ++i)
//                ints[i] = new Integer(i);
//            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
//            shouldThrow();
//        }
//        catch (NullPointerException success) {}
//    }
//
//    /**
//     * Queue contains all elements of collection used to initialize
//     */
//    public void testConstructor6() {
//        try {
//            Integer[] ints = new Integer[SIZE];
//            for (int i = 0; i < SIZE; ++i)
//                ints[i] = new Integer(i);
//            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
//            for (int i = 0; i < SIZE; ++i)
//                assertEquals(ints[i], q.poll());
//        }
//        finally {}
//    }
//
//    /**
//     * isEmpty is true before add, false after
//     */
//    public void testEmpty() {
//        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
//        assertTrue(q.isEmpty());
//        q.add(one);
//        assertFalse(q.isEmpty());
//        q.add(two);
//        q.remove();
//        q.remove();
//        assertTrue(q.isEmpty());
//    }
//
//    /**
//     * size changes when elements added and removed
//     */
//    public void testSize() {
//        ConcurrentLinkedQueue q = populatedQueue(SIZE);
//        for (int i = 0; i < SIZE; ++i) {
//            assertEquals(SIZE-i, q.size());
//            q.remove();
//        }
//        for (int i = 0; i < SIZE; ++i) {
//            assertEquals(i, q.size());
//            q.add(new Integer(i));
//        }
//    }
//
//    /**
//     * offer(null) throws NPE
//     */
//    public void testOfferNull() {
//	try {
//            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
//            q.offer(null);
//            shouldThrow();
//        } catch (NullPointerException success) { }
//    }
//
//    /**
//     * add(null) throws NPE
//     */
//    public void testAddNull() {
//	try {
//            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
//            q.add(null);
//            shouldThrow();
//        } catch (NullPointerException success) { }
//    }
//
//
//    /**
//     * Offer returns true
//     */
//    public void testOffer() {
//        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
//        assertTrue(q.offer(zero));
//        assertTrue(q.offer(one));
//    }
//
//    /**
//     * add returns true
//     */
//    public void testAdd() {
//        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
//        for (int i = 0; i < SIZE; ++i) {
//            assertEquals(i, q.size());
//            assertTrue(q.add(new Integer(i)));
//        }
//    }
//
//    /**
//     * addAll(null) throws NPE
//     */
//    public void testAddAll1() {
//        try {
//            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
//            q.addAll(null);
//            shouldThrow();
//        }
//        catch (NullPointerException success) {}
//    }
//
//    /**
//     * addAll(this) throws IAE
//     */
//    public void testAddAllSelf() {
//        try {
//            ConcurrentLinkedQueue q = populatedQueue(SIZE);
//            q.addAll(q);
//            shouldThrow();
//        }
//        catch (IllegalArgumentException success) {}
//    }
//
//    /**
//     * addAll of a collection with null elements throws NPE
//     */
//    public void testAddAll2() {
//        try {
//            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
//            Integer[] ints = new Integer[SIZE];
//            q.addAll(Arrays.asList(ints));
//            shouldThrow();
//        }
//        catch (NullPointerException success) {}
//    }
//    /**
//     *  addAll of a collection with any null elements throws NPE after
//     * possibly adding some elements
//     */
//    public void testAddAll3() {
//        try {
//            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
//            Integer[] ints = new Integer[SIZE];
//            for (int i = 0; i < SIZE-1; ++i)
//                ints[i] = new Integer(i);
//            q.addAll(Arrays.asList(ints));
//            shouldThrow();
//        }
//        catch (NullPointerException success) {}
//    }
//
//    /**
//     * Queue contains all elements, in traversal order, of successful addAll
//     */
//    public void testAddAll5() {
//        try {
//            Integer[] empty = new Integer[0];
//            Integer[] ints = new Integer[SIZE];
//            for (int i = 0; i < SIZE; ++i)
//                ints[i] = new Integer(i);
//            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
//            assertFalse(q.addAll(Arrays.asList(empty)));
//            assertTrue(q.addAll(Arrays.asList(ints)));
//            for (int i = 0; i < SIZE; ++i)
//                assertEquals(ints[i], q.poll());
//        }
//        finally {}
//    }
//
//    /**
//     * poll succeeds unless empty
//     */
//    public void testPoll() {
//        ConcurrentLinkedQueue q = populatedQueue(SIZE);
//        for (int i = 0; i < SIZE; ++i) {
//            assertEquals(i, ((Integer)q.poll()).intValue());
//        }
//	assertNull(q.poll());
//    }
//
//    /**
//     * peek returns next element, or null if empty
//     */
//    public void testPeek() {
//        ConcurrentLinkedQueue q = populatedQueue(SIZE);
//        for (int i = 0; i < SIZE; ++i) {
//            assertEquals(i, ((Integer)q.peek()).intValue());
//            q.poll();
//            assertTrue(q.peek() == null ||
//                       i != ((Integer)q.peek()).intValue());
//        }
//	assertNull(q.peek());
//    }
//
//    /**
//     * element returns next element, or throws NSEE if empty
//     */
//    public void testElement() {
//        ConcurrentLinkedQueue q = populatedQueue(SIZE);