test/tck/CollectionTest.java

/*
 * Written by Doug Lea and Martin Buchholz with assistance from
 * members of JCP JSR-166 Expert Group and released to the public
 * domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

import java.util.ArrayList;
import java.util.Collection;
import java.util.Deque;
import java.util.NoSuchElementException;
import java.util.Queue;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
import java.util.function.Predicate;

import junit.framework.Test;

/**
 * Contains tests applicable to all Collection implementations.
 */
public class CollectionTest extends JSR166TestCase {
    final CollectionImplementation impl;

    /** Tests are parameterized by a Collection implementation. */
    CollectionTest(CollectionImplementation impl, String methodName) {
        super(methodName);
        this.impl = impl;
    }

    public static Test testSuite(CollectionImplementation impl) {
        return newTestSuite
            (parameterizedTestSuite(CollectionTest.class,
                                    CollectionImplementation.class,
                                    impl),
             jdk8ParameterizedTestSuite(CollectionTest.class,
                                        CollectionImplementation.class,
                                        impl));
    }

    /** Checks properties of empty collections. */
    public void testEmptyMeansEmpty() {
        Collection c = impl.emptyCollection();
        assertTrue(c.isEmpty());
        assertEquals(0, c.size());
        assertEquals("[]", c.toString());
        assertEquals(0, c.toArray().length);
        {
            Object[] a = new Object[0];
            assertSame(a, c.toArray(a));
        }
        assertIteratorExhausted(c.iterator());
        Consumer alwaysThrows = (e) -> { throw new AssertionError(); };
        c.forEach(alwaysThrows);
        c.iterator().forEachRemaining(alwaysThrows);
        c.spliterator().forEachRemaining(alwaysThrows);
        assertFalse(c.spliterator().tryAdvance(alwaysThrows));
        if (Queue.class.isAssignableFrom(impl.klazz())) {
            Queue q = (Queue) c;
            assertNull(q.peek());
            assertNull(q.poll());
        }
        if (Deque.class.isAssignableFrom(impl.klazz())) {
            Deque d = (Deque) c;
            assertNull(d.peekFirst());
            assertNull(d.peekLast());
            assertNull(d.pollFirst());
            assertNull(d.pollLast());
            assertIteratorExhausted(d.descendingIterator());
        }
    }

    public void testNullPointerExceptions() {
        Collection c = impl.emptyCollection();
        assertThrows(
            NullPointerException.class,
            () -> c.addAll(null),
            () -> c.containsAll(null),
            () -> c.retainAll(null),
            () -> c.removeAll(null),
            () -> c.removeIf(null));

        if (!impl.permitsNulls()) {
            assertThrows(
                NullPointerException.class,
                () -> c.add(null));
        }
        if (!impl.permitsNulls()
            && Queue.class.isAssignableFrom(impl.klazz())) {
            Queue q = (Queue) c;
            assertThrows(
                NullPointerException.class,
                () -> q.offer(null));
        }
        if (!impl.permitsNulls()
            && Deque.class.isAssignableFrom(impl.klazz())) {
            Deque d = (Deque) c;
            assertThrows(
                NullPointerException.class,
                () -> d.addFirst(null),
                () -> d.addLast(null),
                () -> d.offerFirst(null),
                () -> d.offerLast(null),
                () -> d.push(null));
        }
    }

    public void testNoSuchElementExceptions() {
        Collection c = impl.emptyCollection();
        assertThrows(
            NoSuchElementException.class,
            () -> c.iterator().next());

        if (Queue.class.isAssignableFrom(impl.klazz())) {
            Queue q = (Queue) c;
            assertThrows(
                NoSuchElementException.class,
                () -> q.element(),
                () -> q.remove());
        }
        if (Deque.class.isAssignableFrom(impl.klazz())) {
            Deque d = (Deque) c;
            assertThrows(
                NoSuchElementException.class,
                () -> d.getFirst(),
                () -> d.getLast(),
                () -> d.removeFirst(),
                () -> d.removeLast(),
                () -> d.pop(),
                () -> d.descendingIterator().next());
        }
    }

    public void testRemoveIf() {
        Collection c = impl.emptyCollection();
        ThreadLocalRandom rnd = ThreadLocalRandom.current();
        int n = rnd.nextInt(6);
        for (int i = 0; i < n; i++) c.add(impl.makeElement(i));
        AtomicReference threwAt = new AtomicReference(null);
        ArrayList survivors = new ArrayList(c);
        ArrayList accepts = new ArrayList();
        ArrayList rejects = new ArrayList();
        Predicate randomPredicate = (e) -> {
            assertNull(threwAt.get());
            switch (rnd.nextInt(3)) {
            case 0: accepts.add(e); return true;
            case 1: rejects.add(e); return false;
            case 2: threwAt.set(e); throw new ArithmeticException();
            default: throw new AssertionError();
            }
        };
        try {
            boolean modified = c.removeIf(randomPredicate);
            if (!modified) {
                assertNull(threwAt.get());
                assertEquals(n, rejects.size());
                assertEquals(0, accepts.size());
            }
        } catch (ArithmeticException ok) {}
        survivors.removeAll(accepts);
        if (n - accepts.size() != c.size()) {
            System.err.println(impl.klazz());
            System.err.println(c);
            System.err.println(accepts);
            System.err.println(rejects);
            System.err.println(survivors);
            System.err.println(threwAt.get());
        }
        assertEquals(n - accepts.size(), c.size());
        assertTrue(c.containsAll(survivors));
        assertTrue(survivors.containsAll(rejects));
        for (Object x : accepts) assertFalse(c.contains(x));
        if (threwAt.get() == null)
            assertEquals(accepts.size() + rejects.size(), n);
    }

//     public void testCollectionDebugFail() {
//         fail(impl.klazz().getSimpleName());
//     }
}
Revision:	1.7
Committed:	Mon Oct 17 20:45:31 2016 UTC (7 years, 6 months ago) by jsr166
Branch:	MAIN
Changes since 1.6:	+8 -0 lines
Log Message:	debugging helper
#	User	Rev	Content
1	jsr166	1.1	/*
2			* Written by Doug Lea and Martin Buchholz with assistance from
3			* members of JCP JSR-166 Expert Group and released to the public
4			* domain, as explained at
5			* http://creativecommons.org/publicdomain/zero/1.0/
6			*/
7
8	jsr166	1.6	import java.util.ArrayList;
9	jsr166	1.1	import java.util.Collection;
10	jsr166	1.2	import java.util.Deque;
11			import java.util.NoSuchElementException;
12			import java.util.Queue;
13	jsr166	1.6	import java.util.concurrent.ThreadLocalRandom;
14			import java.util.concurrent.atomic.AtomicReference;
15	jsr166	1.3	import java.util.function.Consumer;
16	jsr166	1.6	import java.util.function.Predicate;
17	jsr166	1.1
18			import junit.framework.Test;
19
20			/**
21			* Contains tests applicable to all Collection implementations.
22			*/
23			public class CollectionTest extends JSR166TestCase {
24			final CollectionImplementation impl;
25
26			/** Tests are parameterized by a Collection implementation. */
27			CollectionTest(CollectionImplementation impl, String methodName) {
28			super(methodName);
29			this.impl = impl;
30			}
31
32			public static Test testSuite(CollectionImplementation impl) {
33			return newTestSuite
34			(parameterizedTestSuite(CollectionTest.class,
35			CollectionImplementation.class,
36			impl),
37			jdk8ParameterizedTestSuite(CollectionTest.class,
38			CollectionImplementation.class,
39			impl));
40			}
41
42	jsr166	1.2	/** Checks properties of empty collections. */
43	jsr166	1.1	public void testEmptyMeansEmpty() {
44	jsr166	1.2	Collection c = impl.emptyCollection();
45			assertTrue(c.isEmpty());
46			assertEquals(0, c.size());
47			assertEquals("[]", c.toString());
48			assertEquals(0, c.toArray().length);
49			{
50			Object[] a = new Object[0];
51			assertSame(a, c.toArray(a));
52			}
53	jsr166	1.5	assertIteratorExhausted(c.iterator());
54	jsr166	1.3	Consumer alwaysThrows = (e) -> { throw new AssertionError(); };
55			c.forEach(alwaysThrows);
56			c.iterator().forEachRemaining(alwaysThrows);
57			c.spliterator().forEachRemaining(alwaysThrows);
58			assertFalse(c.spliterator().tryAdvance(alwaysThrows));
59	jsr166	1.2	if (Queue.class.isAssignableFrom(impl.klazz())) {
60			Queue q = (Queue) c;
61			assertNull(q.peek());
62			assertNull(q.poll());
63			}
64			if (Deque.class.isAssignableFrom(impl.klazz())) {
65			Deque d = (Deque) c;
66			assertNull(d.peekFirst());
67			assertNull(d.peekLast());
68			assertNull(d.pollFirst());
69			assertNull(d.pollLast());
70	jsr166	1.5	assertIteratorExhausted(d.descendingIterator());
71	jsr166	1.2	}
72			}
73
74			public void testNullPointerExceptions() {
75			Collection c = impl.emptyCollection();
76			assertThrows(
77			NullPointerException.class,
78			() -> c.addAll(null),
79			() -> c.containsAll(null),
80			() -> c.retainAll(null),
81			() -> c.removeAll(null),
82			() -> c.removeIf(null));
83
84			if (!impl.permitsNulls()) {
85			assertThrows(
86			NullPointerException.class,
87			() -> c.add(null));
88			}
89			if (!impl.permitsNulls()
90			&& Queue.class.isAssignableFrom(impl.klazz())) {
91			Queue q = (Queue) c;
92			assertThrows(
93			NullPointerException.class,
94			() -> q.offer(null));
95			}
96			if (!impl.permitsNulls()
97			&& Deque.class.isAssignableFrom(impl.klazz())) {
98			Deque d = (Deque) c;
99			assertThrows(
100			NullPointerException.class,
101			() -> d.addFirst(null),
102			() -> d.addLast(null),
103			() -> d.offerFirst(null),
104			() -> d.offerLast(null),
105			() -> d.push(null));
106			}
107			}
108
109			public void testNoSuchElementExceptions() {
110			Collection c = impl.emptyCollection();
111	jsr166	1.3	assertThrows(
112			NoSuchElementException.class,
113			() -> c.iterator().next());
114	jsr166	1.2
115			if (Queue.class.isAssignableFrom(impl.klazz())) {
116			Queue q = (Queue) c;
117			assertThrows(
118			NoSuchElementException.class,
119			() -> q.element(),
120			() -> q.remove());
121			}
122			if (Deque.class.isAssignableFrom(impl.klazz())) {
123			Deque d = (Deque) c;
124			assertThrows(
125			NoSuchElementException.class,
126			() -> d.getFirst(),
127			() -> d.getLast(),
128			() -> d.removeFirst(),
129			() -> d.removeLast(),
130	jsr166	1.5	() -> d.pop(),
131			() -> d.descendingIterator().next());
132	jsr166	1.2	}
133	jsr166	1.1	}
134
135	jsr166	1.6	public void testRemoveIf() {
136			Collection c = impl.emptyCollection();
137			ThreadLocalRandom rnd = ThreadLocalRandom.current();
138			int n = rnd.nextInt(6);
139			for (int i = 0; i < n; i++) c.add(impl.makeElement(i));
140			AtomicReference threwAt = new AtomicReference(null);
141			ArrayList survivors = new ArrayList(c);
142			ArrayList accepts = new ArrayList();
143			ArrayList rejects = new ArrayList();
144			Predicate randomPredicate = (e) -> {
145			assertNull(threwAt.get());
146			switch (rnd.nextInt(3)) {
147			case 0: accepts.add(e); return true;
148			case 1: rejects.add(e); return false;
149			case 2: threwAt.set(e); throw new ArithmeticException();
150			default: throw new AssertionError();
151			}
152			};
153			try {
154			boolean modified = c.removeIf(randomPredicate);
155			if (!modified) {
156			assertNull(threwAt.get());
157			assertEquals(n, rejects.size());
158			assertEquals(0, accepts.size());
159			}
160			} catch (ArithmeticException ok) {}
161			survivors.removeAll(accepts);
162	jsr166	1.7	if (n - accepts.size() != c.size()) {
163			System.err.println(impl.klazz());
164			System.err.println(c);
165			System.err.println(accepts);
166			System.err.println(rejects);
167			System.err.println(survivors);
168			System.err.println(threwAt.get());
169			}
170	jsr166	1.6	assertEquals(n - accepts.size(), c.size());
171			assertTrue(c.containsAll(survivors));
172			assertTrue(survivors.containsAll(rejects));
173			for (Object x : accepts) assertFalse(c.contains(x));
174			if (threwAt.get() == null)
175			assertEquals(accepts.size() + rejects.size(), n);
176			}
177
178	jsr166	1.4	// public void testCollectionDebugFail() {
179			// fail(impl.klazz().getSimpleName());
180			// }
181	jsr166	1.1	}