ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/BlockingQueueTest.java

Comparing jsr166/src/test/tck/BlockingQueueTest.java (file contents):
Revision 1.7 by jsr166, Fri May 27 19:32:04 2011 UTC vs.
Revision 1.11 by jsr166, Tue Jun 14 04:30:06 2011 UTC

#	Line 8 | Line 8
8		*/
9
10		import junit.framework.*;
11	<	import java.util.*;
12	<	import java.util.concurrent.*;
11	>	import java.util.ArrayList;
12	>	import java.util.Arrays;
13	>	import java.util.Collection;
14	>	import java.util.Queue;
15	>	import java.util.concurrent.BlockingQueue;
16	>	import java.util.concurrent.CountDownLatch;
17		import static java.util.concurrent.TimeUnit.MILLISECONDS;
18
19		/**
20	<	* Contains tests generally applicable to BlockingQueue implementations.
20	>	* Contains "contract" tests applicable to all BlockingQueue implementations.
21		*/
22		public abstract class BlockingQueueTest extends JSR166TestCase {
23		/*
#	Line 33 | Line 37 | public abstract class BlockingQueueTest
37		return new TestSuite(this.getClass());
38		}
39
40	+	//----------------------------------------------------------------
41	+	// Configuration methods
42	+	//----------------------------------------------------------------
43	+
44		/** Returns an empty instance of the implementation class. */
45		protected abstract BlockingQueue emptyCollection();
46
47		/**
48	+	* Returns an element suitable for insertion in the collection.
49	+	* Override for collections with unusual element types.
50	+	*/
51	+	protected Object makeElement(int i) {
52	+	return Integer.valueOf(i);
53	+	}
54	+
55	+	//----------------------------------------------------------------
56	+	// Tests
57	+	//----------------------------------------------------------------
58	+
59	+	/**
60	+	* offer(null) throws NullPointerException
61	+	*/
62	+	public void testOfferNull() {
63	+	final Queue q = emptyCollection();
64	+	try {
65	+	q.offer(null);
66	+	shouldThrow();
67	+	} catch (NullPointerException success) {}
68	+	}
69	+
70	+	/**
71	+	* add(null) throws NullPointerException
72	+	*/
73	+	public void testAddNull() {
74	+	final Collection q = emptyCollection();
75	+	try {
76	+	q.add(null);
77	+	shouldThrow();
78	+	} catch (NullPointerException success) {}
79	+	}
80	+
81	+	/**
82	+	* timed offer(null) throws NullPointerException
83	+	*/
84	+	public void testTimedOfferNull() throws InterruptedException {
85	+	final BlockingQueue q = emptyCollection();
86	+	long startTime = System.nanoTime();
87	+	try {
88	+	q.offer(null, LONG_DELAY_MS, MILLISECONDS);
89	+	shouldThrow();
90	+	} catch (NullPointerException success) {}
91	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
92	+	}
93	+
94	+	/**
95	+	* put(null) throws NullPointerException
96	+	*/
97	+	public void testPutNull() throws InterruptedException {
98	+	final BlockingQueue q = emptyCollection();
99	+	try {
100	+	q.put(null);
101	+	shouldThrow();
102	+	} catch (NullPointerException success) {}
103	+	}
104	+
105	+	/**
106	+	* put(null) throws NullPointerException
107	+	*/
108	+	public void testAddAllNull() throws InterruptedException {
109	+	final Collection q = emptyCollection();
110	+	try {
111	+	q.addAll(null);
112	+	shouldThrow();
113	+	} catch (NullPointerException success) {}
114	+	}
115	+
116	+	/**
117	+	* addAll of a collection with null elements throws NullPointerException
118	+	*/
119	+	public void testAddAllNullElements() {
120	+	final Collection q = emptyCollection();
121	+	final Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
122	+	try {
123	+	q.addAll(elements);
124	+	shouldThrow();
125	+	} catch (NullPointerException success) {}
126	+	}
127	+
128	+	/**
129	+	* toArray(null) throws NullPointerException
130	+	*/
131	+	public void testToArray_NullArray() {
132	+	final Collection q = emptyCollection();
133	+	try {
134	+	q.toArray(null);
135	+	shouldThrow();
136	+	} catch (NullPointerException success) {}
137	+	}
138	+
139	+	/**
140	+	* drainTo(null) throws NullPointerException
141	+	*/
142	+	public void testDrainToNull() {
143	+	final BlockingQueue q = emptyCollection();
144	+	try {
145	+	q.drainTo(null);
146	+	shouldThrow();
147	+	} catch (NullPointerException success) {}
148	+	}
149	+
150	+	/**
151	+	* drainTo(this) throws IllegalArgumentException
152	+	*/
153	+	public void testDrainToSelf() {
154	+	final BlockingQueue q = emptyCollection();
155	+	try {
156	+	q.drainTo(q);
157	+	shouldThrow();
158	+	} catch (IllegalArgumentException success) {}
159	+	}
160	+
161	+	/**
162	+	* drainTo(null, n) throws NullPointerException
163	+	*/
164	+	public void testDrainToNullN() {
165	+	final BlockingQueue q = emptyCollection();
166	+	try {
167	+	q.drainTo(null, 0);
168	+	shouldThrow();
169	+	} catch (NullPointerException success) {}
170	+	}
171	+
172	+	/**
173	+	* drainTo(this, n) throws IllegalArgumentException
174	+	*/
175	+	public void testDrainToSelfN() {
176	+	final BlockingQueue q = emptyCollection();
177	+	try {
178	+	q.drainTo(q, 0);
179	+	shouldThrow();
180	+	} catch (IllegalArgumentException success) {}
181	+	}
182	+
183	+	/**
184	+	* drainTo(c, n) returns 0 and does nothing when n <= 0
185	+	*/
186	+	public void testDrainToNonPositiveMaxElements() {
187	+	final BlockingQueue q = emptyCollection();
188	+	final int[] ns = { 0, -1, -42, Integer.MIN_VALUE };
189	+	for (int n : ns)
190	+	assertEquals(0, q.drainTo(new ArrayList(), n));
191	+	if (q.remainingCapacity() > 0) {
192	+	// Not SynchronousQueue, that is
193	+	Object one = makeElement(1);
194	+	q.add(one);
195	+	ArrayList c = new ArrayList();
196	+	for (int n : ns)
197	+	assertEquals(0, q.drainTo(new ArrayList(), n));
198	+	assertEquals(1, q.size());
199	+	assertSame(one, q.poll());
200	+	assertTrue(c.isEmpty());
201	+	}
202	+	}
203	+
204	+	/**
205		* timed poll before a delayed offer times out; after offer succeeds;
206		* on interruption throws
207		*/
208		public void testTimedPollWithOffer() throws InterruptedException {
209		final BlockingQueue q = emptyCollection();
210		final CheckedBarrier barrier = new CheckedBarrier(2);
211	+	final Object zero = makeElement(0);
212		Thread t = newStartedThread(new CheckedRunnable() {
213		public void realRun() throws InterruptedException {
214		long startTime = System.nanoTime();

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines