concurrentskiplistsubsettest.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
 */

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

public class ConcurrentSkipListSubSetTest extends JSR166TestCase {
//    public static void main(String[] args) {
//	junit.textui.TestRunner.run (suite());
//    }
//    public static Test suite() {
//	return new TestSuite(ConcurrentSkipListSubSetTest.class);
//    }
//
//    static class MyReverseComparator implements Comparator {
//        public int compare(Object x, Object y) {
//            int i = ((Integer)x).intValue();
//            int j = ((Integer)y).intValue();
//            if (i < j) return 1;
//            if (i > j) return -1;
//            return 0;
//        }
//    }
//
//    /**
//     * Create a set of given size containing consecutive
//     * Integers 0 ... n.
//     */
//    private NavigableSet populatedSet(int n) {
//        ConcurrentSkipListSet q = new ConcurrentSkipListSet();
//        assertTrue(q.isEmpty());
//
//	for(int i = n-1; i >= 0; i-=2)
//	    assertTrue(q.add(new Integer(i)));
//	for(int i = (n & 1); i < n; i+=2)
//	    assertTrue(q.add(new Integer(i)));
//        assertTrue(q.add(new Integer(-n)));
//        assertTrue(q.add(new Integer(n)));
//        NavigableSet s = q.subSet(new Integer(0), new Integer(n));
//        assertFalse(s.isEmpty());
//	assertEquals(n, s.size());
//        return s;
//    }
//
//    /**
//     * Create set of first 5 ints
//     */
//    private NavigableSet set5() {
//        ConcurrentSkipListSet q = new ConcurrentSkipListSet();
//        assertTrue(q.isEmpty());
//        q.add(one);
//        q.add(two);
//        q.add(three);
//        q.add(four);
//        q.add(five);
//        q.add(zero);
//        q.add(seven);
//        NavigableSet s = q.subSet(one, seven);
//	assertEquals(5, s.size());
//        return s;
//    }
//
//    private static NavigableSet set0() {
//	ConcurrentSkipListSet set = new ConcurrentSkipListSet();
//        assertTrue(set.isEmpty());
//        return set.tailSet(m1);
//    }
//
//    /**
//     * A new set has unbounded capacity
//     */
//    public void testConstructor1() {
//        assertEquals(0, set0().size());
//    }
//
//
//    /**
//     * isEmpty is true before add, false after
//     */
//    public void testEmpty() {
//        NavigableSet q = set0();
//        assertTrue(q.isEmpty());
//        q.add(new Integer(1));
//        assertFalse(q.isEmpty());
//        q.add(new Integer(2));
//        q.pollFirst();
//        q.pollFirst();
//        assertTrue(q.isEmpty());
//    }
//
//    /**
//     * size changes when elements added and removed
//     */
//    public void testSize() {
//        NavigableSet q = populatedSet(SIZE);
//        for (int i = 0; i < SIZE; ++i) {
//            assertEquals(SIZE-i, q.size());
//            q.pollFirst();
//        }
//        for (int i = 0; i < SIZE; ++i) {
//            assertEquals(i, q.size());
//            q.add(new Integer(i));
//        }
//    }
//
//    /**
//     * add(null) throws NPE
//     */
//    public void testAddNull() {
//	try {
//            NavigableSet q = set0();
//            q.add(null);
//            shouldThrow();
//        } catch (NullPointerException success) { }
//    }
//
//    /**
//     * Add of comparable element succeeds
//     */
//    public void testAdd() {
//        NavigableSet q = set0();
//        assertTrue(q.add(six));
//    }
//
//    /**
//     * Add of duplicate element fails
//     */
//    public void testAddDup() {
//        NavigableSet q = set0();
//        assertTrue(q.add(six));
//        assertFalse(q.add(six));
//    }
//
//    /**
//     * Add of non-Comparable throws CCE
//     */
//    public void testAddNonComparable() {
//        try {
//            NavigableSet q = set0();
//            q.add(new Object());
//            q.add(new Object());
//            q.add(new Object());
//            shouldThrow();
//        }
//        catch(ClassCastException success) {}
//    }
//
//
//    /**
//     * addAll(null) throws NPE
//     */
//    public void testAddAll1() {
//        try {
//            NavigableSet q = set0();
//            q.addAll(null);
//            shouldThrow();
//        }
//        catch (NullPointerException success) {}
//    }
//    /**
//     * addAll of a collection with null elements throws NPE
//     */
//    public void testAddAll2() {
//        try {
//            NavigableSet q = set0();
//            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 {
//            NavigableSet q = set0();
//            Integer[] ints = new Integer[SIZE];
//            for (int i = 0; i < SIZE-1; ++i)
//                ints[i] = new Integer(i+SIZE);
//            q.addAll(Arrays.asList(ints));
//            shouldThrow();
//        }
//        catch (NullPointerException success) {}
//    }
//
//    /**
//     * Set contains all elements 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(SIZE-1- i);
//            NavigableSet q = set0();
//            assertFalse(q.addAll(Arrays.asList(empty)));
//            assertTrue(q.addAll(Arrays.asList(ints)));
//            for (int i = 0; i < SIZE; ++i)
//                assertEquals(new Integer(i), q.pollFirst());
//        }
//        finally {}
//    }
//
//    /**
//     * poll succeeds unless empty
//     */
//    public void testPoll() {
//        NavigableSet q = populatedSet(SIZE);
//        for (int i = 0; i < SIZE; ++i) {
//            assertEquals(i, ((Integer)q.pollFirst()).intValue());
//        }
//	assertNull(q.pollFirst());
//    }
//
//    /**
//     * remove(x) removes x and returns true if present
//     */
//    public void testRemoveElement() {
//        NavigableSet q = populatedSet(SIZE);
//        for (int i = 1; i < SIZE; i+=2) {
//            assertTrue(q.remove(new Integer(i)));
//        }
//        for (int i = 0; i < SIZE; i+=2) {
//            assertTrue(q.remove(new Integer(i)));
//            assertFalse(q.remove(new Integer(i+1)));
//        }
//        assertTrue(q.isEmpty());
//    }
//
//    /**
//     * contains(x) reports true when elements added but not yet removed
//     */
//    public void testContains() {
//        NavigableSet q = populatedSet(SIZE);
//        for (int i = 0; i < SIZE; ++i) {
//            assertTrue(q.contains(new Integer(i)));
//            q.pollFirst();
//            assertFalse(q.contains(new Integer(i)));
//        }
//    }
//
//    /**
//     * clear removes all elements
//     */
//    public void testClear() {
//        NavigableSet q = populatedSet(SIZE);
//        q.clear();
//        assertTrue(q.isEmpty());
//        assertEquals(0, q.size());
//        q.add(new Integer(1));
//        assertFalse(q.isEmpty());
//        q.clear();
//        assertTrue(q.isEmpty());
//    }
//
//    /**
//     * containsAll(c) is true when c contains a subset of elements
//     */
//    public void testContainsAll() {
//        NavigableSet q = populatedSet(SIZE);
//        NavigableSet p = set0();
//        for (int i = 0; i < SIZE; ++i) {
//            assertTrue(q.containsAll(p));
//            assertFalse(p.containsAll(q));
//            p.add(new Integer(i));
//        }
//        assertTrue(p.containsAll(q));
//    }
//
//    /**
//     * retainAll(c) retains only those elements of c and reports true if changed
//     */
//    public void testRetainAll() {
//        NavigableSet q = populatedSet(SIZE);
//        NavigableSet p = populatedSet(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.pollFirst();
//        }
//    }
//
//    /**
//     * removeAll(c) removes only those elements of c and reports true if changed
//     */
//    public void testRemoveAll() {
//        for (int i = 1; i < SIZE; ++i) {
//            NavigableSet q = populatedSet(SIZE);
//            NavigableSet p = populatedSet(i);
//            assertTrue(q.removeAll(p));
//            assertEquals(SIZE-i, q.size());
//            for (int j = 0; j < i; ++j) {
//                Integer I = (Integer)(p.pollFirst());
//                assertFalse(q.contains(I));
//            }