concurrentskiplistsettest.java

SRI international 发布的OAA框架软件

//    }
//
//    /**
//     * retainAll(c) retains only those elements of c and reports true if changed
//     */
//    public void testRetainAll() {
//        ConcurrentSkipListSet q = populatedSet(SIZE);
//        ConcurrentSkipListSet 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) {
//            ConcurrentSkipListSet q = populatedSet(SIZE);
//            ConcurrentSkipListSet 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));
//            }
//        }
//    }
//
//
//
//    /**
//     * lower returns preceding element
//     */
//    public void testLower() {
//        ConcurrentSkipListSet q = set5();
//        Object e1 = q.lower(three);
//        assertEquals(two, e1);
//
//        Object e2 = q.lower(six);
//        assertEquals(five, e2);
//
//        Object e3 = q.lower(one);
//        assertNull(e3);
//
//        Object e4 = q.lower(zero);
//        assertNull(e4);
//
//    }
//
//    /**
//     * higher returns next element
//     */
//    public void testHigher() {
//        ConcurrentSkipListSet q = set5();
//        Object e1 = q.higher(three);
//        assertEquals(four, e1);
//
//        Object e2 = q.higher(zero);
//        assertEquals(one, e2);
//
//        Object e3 = q.higher(five);
//        assertNull(e3);
//
//        Object e4 = q.higher(six);
//        assertNull(e4);
//
//    }
//
//    /**
//     * floor returns preceding element
//     */
//    public void testFloor() {
//        ConcurrentSkipListSet q = set5();
//        Object e1 = q.floor(three);
//        assertEquals(three, e1);
//
//        Object e2 = q.floor(six);
//        assertEquals(five, e2);
//
//        Object e3 = q.floor(one);
//        assertEquals(one, e3);
//
//        Object e4 = q.floor(zero);
//        assertNull(e4);
//
//    }
//
//    /**
//     * ceiling returns next element
//     */
//    public void testCeiling() {
//        ConcurrentSkipListSet q = set5();
//        Object e1 = q.ceiling(three);
//        assertEquals(three, e1);
//
//        Object e2 = q.ceiling(zero);
//        assertEquals(one, e2);
//
//        Object e3 = q.ceiling(five);
//        assertEquals(five, e3);
//
//        Object e4 = q.ceiling(six);
//        assertNull(e4);
//
//    }
//
//    /**
//     * toArray contains all elements
//     */
//    public void testToArray() {
//        ConcurrentSkipListSet q = populatedSet(SIZE);
//	Object[] o = q.toArray();
//        Arrays.sort(o);
//	for(int i = 0; i < o.length; i++)
//	    assertEquals(o[i], q.pollFirst());
//    }
//
//    /**
//     * toArray(a) contains all elements
//     */
//    public void testToArray2() {
//        ConcurrentSkipListSet q = populatedSet(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.pollFirst());
//    }
//
//    /**
//     * iterator iterates through all elements
//     */
//    public void testIterator() {
//        ConcurrentSkipListSet q = populatedSet(SIZE);
//        int i = 0;
//	Iterator it = q.iterator();
//        while(it.hasNext()) {
//            assertTrue(q.contains(it.next()));
//            ++i;
//        }
//        assertEquals(i, SIZE);
//    }
//
//    /**
//     * iterator of empty set has no elements
//     */
//    public void testEmptyIterator() {
//        ConcurrentSkipListSet q = new ConcurrentSkipListSet();
//        int i = 0;
//	Iterator it = q.iterator();
//        while(it.hasNext()) {
//            assertTrue(q.contains(it.next()));
//            ++i;
//        }
//        assertEquals(i, 0);
//    }
//
//    /**
//     * iterator.remove removes current element
//     */
//    public void testIteratorRemove () {
//        final ConcurrentSkipListSet q = new ConcurrentSkipListSet();
//        q.add(new Integer(2));
//        q.add(new Integer(1));
//        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() {
//        ConcurrentSkipListSet q = populatedSet(SIZE);
//        String s = q.toString();
//        for (int i = 0; i < SIZE; ++i) {
//            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
//        }
//    }
//
//    /**
//     * A deserialized serialized set has same elements
//     */
//    public void testSerialization() {
//        ConcurrentSkipListSet q = populatedSet(SIZE);
//        try {
//            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
//            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
//            out.writeObject(q);
//            out.close();
//
//            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
//            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
//            ConcurrentSkipListSet r = (ConcurrentSkipListSet)in.readObject();
//            assertEquals(q.size(), r.size());
//            while (!q.isEmpty())
//                assertEquals(q.pollFirst(), r.pollFirst());
//        } catch(Exception e){
//            e.printStackTrace();
//            unexpectedException();
//        }
//    }
//
//    /**
//     * subSet returns set with keys in requested range
//     */
//    public void testSubSetContents() {
//        ConcurrentSkipListSet set = set5();
//        SortedSet sm = set.subSet(two, four);
//        assertEquals(two, sm.first());
//        assertEquals(three, sm.last());
//        assertEquals(2, sm.size());
//        assertFalse(sm.contains(one));
//        assertTrue(sm.contains(two));
//        assertTrue(sm.contains(three));
//        assertFalse(sm.contains(four));
//        assertFalse(sm.contains(five));
//        Iterator i = sm.iterator();
//        Object k;
//        k = (Integer)(i.next());
//        assertEquals(two, k);
//        k = (Integer)(i.next());
//        assertEquals(three, k);
//        assertFalse(i.hasNext());
//        Iterator j = sm.iterator();
//        j.next();
//        j.remove();
//        assertFalse(set.contains(two));
//        assertEquals(4, set.size());
//        assertEquals(1, sm.size());
//        assertEquals(three, sm.first());
//        assertEquals(three, sm.last());
//        assertTrue(sm.remove(three));
//        assertTrue(sm.isEmpty());
//        assertEquals(3, set.size());
//    }
//
//    public void testSubSetContents2() {
//        ConcurrentSkipListSet set = set5();
//        SortedSet sm = set.subSet(two, three);
//        assertEquals(1, sm.size());
//        assertEquals(two, sm.first());
//        assertEquals(two, sm.last());
//        assertFalse(sm.contains(one));
//        assertTrue(sm.contains(two));
//        assertFalse(sm.contains(three));
//        assertFalse(sm.contains(four));
//        assertFalse(sm.contains(five));
//        Iterator i = sm.iterator();
//        Object k;
//        k = (Integer)(i.next());
//        assertEquals(two, k);
//        assertFalse(i.hasNext());
//        Iterator j = sm.iterator();
//        j.next();
//        j.remove();
//        assertFalse(set.contains(two));
//        assertEquals(4, set.size());
//        assertEquals(0, sm.size());
//        assertTrue(sm.isEmpty());
//        assertFalse(sm.remove(three));
//        assertEquals(4, set.size());
//    }
//
//    /**
//     * headSet returns set with keys in requested range
//     */
//    public void testHeadSetContents() {
//        ConcurrentSkipListSet set = set5();
//        SortedSet sm = set.headSet(four);
//        assertTrue(sm.contains(one));
//        assertTrue(sm.contains(two));
//        assertTrue(sm.contains(three));
//        assertFalse(sm.contains(four));
//        assertFalse(sm.contains(five));
//        Iterator i = sm.iterator();
//        Object k;
//        k = (Integer)(i.next());
//        assertEquals(one, k);
//        k = (Integer)(i.next());
//        assertEquals(two, k);
//        k = (Integer)(i.next());
//        assertEquals(three, k);
//        assertFalse(i.hasNext());
//        sm.clear();
//        assertTrue(sm.isEmpty());
//        assertEquals(2, set.size());
//        assertEquals(four, set.first());
//    }
//
//    /**
//     * tailSet returns set with keys in requested range
//     */
//    public void testTailSetContents() {
//        ConcurrentSkipListSet set = set5();
//        SortedSet sm = set.tailSet(two);
//        assertFalse(sm.contains(one));
//        assertTrue(sm.contains(two));
//        assertTrue(sm.contains(three));
//        assertTrue(sm.contains(four));
//        assertTrue(sm.contains(five));
//        Iterator i = sm.iterator();
//        Object k;
//        k = (Integer)(i.next());
//        assertEquals(two, k);
//        k = (Integer)(i.next());
//        assertEquals(three, k);
//        k = (Integer)(i.next());
//        assertEquals(four, k);
//        k = (Integer)(i.next());
//        assertEquals(five, k);
//        assertFalse(i.hasNext());
//
//        SortedSet ssm = sm.tailSet(four);
//        assertEquals(four, ssm.first());
//        assertEquals(five, ssm.last());
//        assertTrue(ssm.remove(four));
//        assertEquals(1, ssm.size());
//        assertEquals(3, sm.size());
//        assertEquals(4, set.size());
//    }
//
}