ViewVC Help

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

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

Comparing jsr166/src/test/tck/ArrayBlockingQueueTest.java (file contents):
Revision 1.47 by jsr166, Fri May 27 20:07:24 2011 UTC vs.
Revision 1.48 by jsr166, Mon May 30 22:43:20 2011 UTC

#	Line 7 | Line 7
7		*/
8
9		import junit.framework.*;
10	<	import java.util.*;
11	<	import java.util.concurrent.*;
10	>	import java.util.Arrays;
11	>	import java.util.ArrayList;
12	>	import java.util.Collection;
13	>	import java.util.Iterator;
14	>	import java.util.NoSuchElementException;
15	>	import java.util.concurrent.ArrayBlockingQueue;
16	>	import java.util.concurrent.BlockingQueue;
17	>	import java.util.concurrent.CountDownLatch;
18	>	import java.util.concurrent.Executors;
19	>	import java.util.concurrent.ExecutorService;
20		import static java.util.concurrent.TimeUnit.MILLISECONDS;
21		import java.io.*;
22
#	Line 63 | Line 71 | public class ArrayBlockingQueueTest exte
71		*/
72		public void testConstructor2() {
73		try {
74	<	ArrayBlockingQueue q = new ArrayBlockingQueue(0);
74	>	new ArrayBlockingQueue(0);
75		shouldThrow();
76		} catch (IllegalArgumentException success) {}
77		}
#	Line 73 | Line 81 | public class ArrayBlockingQueueTest exte
81		*/
82		public void testConstructor3() {
83		try {
84	<	ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);
84	>	new ArrayBlockingQueue(1, true, null);
85		shouldThrow();
86		} catch (NullPointerException success) {}
87		}
#	Line 82 | Line 90 | public class ArrayBlockingQueueTest exte
90		* Initializing from Collection of null elements throws NPE
91		*/
92		public void testConstructor4() {
93	+	Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
94		try {
95	<	Integer[] ints = new Integer[SIZE];
87	<	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
95	>	new ArrayBlockingQueue(SIZE, false, elements);
96		shouldThrow();
97		} catch (NullPointerException success) {}
98		}
#	Line 93 | Line 101 | public class ArrayBlockingQueueTest exte
101		* Initializing from Collection with some null elements throws NPE
102		*/
103		public void testConstructor5() {
104	+	Integer[] ints = new Integer[SIZE];
105	+	for (int i = 0; i < SIZE-1; ++i)
106	+	ints[i] = i;
107	+	Collection<Integer> elements = Arrays.asList(ints);
108		try {
109	<	Integer[] ints = new Integer[SIZE];
98	<	for (int i = 0; i < SIZE-1; ++i)
99	<	ints[i] = new Integer(i);
100	<	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
109	>	new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
110		shouldThrow();
111		} catch (NullPointerException success) {}
112		}
#	Line 106 | Line 115 | public class ArrayBlockingQueueTest exte
115		* Initializing from too large collection throws IAE
116		*/
117		public void testConstructor6() {
118	+	Integer[] ints = new Integer[SIZE];
119	+	for (int i = 0; i < SIZE; ++i)
120	+	ints[i] = i;
121	+	Collection<Integer> elements = Arrays.asList(ints);
122		try {
123	<	Integer[] ints = new Integer[SIZE];
111	<	for (int i = 0; i < SIZE; ++i)
112	<	ints[i] = new Integer(i);
113	<	ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));
123	>	new ArrayBlockingQueue(SIZE - 1, false, elements);
124		shouldThrow();
125		} catch (IllegalArgumentException success) {}
126		}
#	Line 121 | Line 131 | public class ArrayBlockingQueueTest exte
131		public void testConstructor7() {
132		Integer[] ints = new Integer[SIZE];
133		for (int i = 0; i < SIZE; ++i)
134	<	ints[i] = new Integer(i);
135	<	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, Arrays.asList(ints));
134	>	ints[i] = i;
135	>	Collection<Integer> elements = Arrays.asList(ints);
136	>	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, elements);
137		for (int i = 0; i < SIZE; ++i)
138		assertEquals(ints[i], q.poll());
139		}
#	Line 160 | Line 171 | public class ArrayBlockingQueueTest exte
171		}
172
173		/**
163	–	* offer(null) throws NPE
164	–	*/
165	–	public void testOfferNull() {
166	–	try {
167	–	ArrayBlockingQueue q = new ArrayBlockingQueue(1);
168	–	q.offer(null);
169	–	shouldThrow();
170	–	} catch (NullPointerException success) {}
171	–	}
172	–
173	–	/**
174	–	* add(null) throws NPE
175	–	*/
176	–	public void testAddNull() {
177	–	try {
178	–	ArrayBlockingQueue q = new ArrayBlockingQueue(1);
179	–	q.add(null);
180	–	shouldThrow();
181	–	} catch (NullPointerException success) {}
182	–	}
183	–
184	–	/**
174		* Offer succeeds if not full; fails if full
175		*/
176		public void testOffer() {
#	Line 206 | Line 195 | public class ArrayBlockingQueueTest exte
195		}
196
197		/**
209	–	* addAll(null) throws NPE
210	–	*/
211	–	public void testAddAll1() {
212	–	try {
213	–	ArrayBlockingQueue q = new ArrayBlockingQueue(1);
214	–	q.addAll(null);
215	–	shouldThrow();
216	–	} catch (NullPointerException success) {}
217	–	}
218	–
219	–	/**
198		* addAll(this) throws IAE
199		*/
200		public void testAddAllSelf() {
#	Line 228 | Line 206 | public class ArrayBlockingQueueTest exte
206		}
207
208		/**
231	–	* addAll of a collection with null elements throws NPE
232	–	*/
233	–	public void testAddAll2() {
234	–	try {
235	–	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
236	–	Integer[] ints = new Integer[SIZE];
237	–	q.addAll(Arrays.asList(ints));
238	–	shouldThrow();
239	–	} catch (NullPointerException success) {}
240	–	}
241	–
242	–	/**
209		* addAll of a collection with any null elements throws NPE after
210		* possibly adding some elements
211		*/
#	Line 284 | Line 250 | public class ArrayBlockingQueueTest exte
250		}
251
252		/**
287	–	* put(null) throws NPE
288	–	*/
289	–	public void testPutNull() throws InterruptedException {
290	–	try {
291	–	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
292	–	q.put(null);
293	–	shouldThrow();
294	–	} catch (NullPointerException success) {}
295	–	}
296	–
297	–	/**
253		* all elements successfully put are contained
254		*/
255		public void testPut() throws InterruptedException {
#	Line 674 | Line 629 | public class ArrayBlockingQueueTest exte
629		}
630
631		/**
677	–	* toArray(null) throws NullPointerException
678	–	*/
679	–	public void testToArray_NullArg() {
680	–	ArrayBlockingQueue q = populatedQueue(SIZE);
681	–	try {
682	–	q.toArray(null);
683	–	shouldThrow();
684	–	} catch (NullPointerException success) {}
685	–	}
686	–
687	–	/**
632		* toArray(incompatible array type) throws ArrayStoreException
633		*/
634		public void testToArray1_BadArg() {
#	Line 840 | Line 784 | public class ArrayBlockingQueueTest exte
784		}
785
786		/**
843	–	* drainTo(null) throws NPE
844	–	*/
845	–	public void testDrainToNull() {
846	–	ArrayBlockingQueue q = populatedQueue(SIZE);
847	–	try {
848	–	q.drainTo(null);
849	–	shouldThrow();
850	–	} catch (NullPointerException success) {}
851	–	}
852	–
853	–	/**
854	–	* drainTo(this) throws IAE
855	–	*/
856	–	public void testDrainToSelf() {
857	–	ArrayBlockingQueue q = populatedQueue(SIZE);
858	–	try {
859	–	q.drainTo(q);
860	–	shouldThrow();
861	–	} catch (IllegalArgumentException success) {}
862	–	}
863	–
864	–	/**
787		* drainTo(c) empties queue into another collection c
788		*/
789		public void testDrainTo() {
#	Line 906 | Line 828 | public class ArrayBlockingQueueTest exte
828		}
829
830		/**
909	–	* drainTo(null, n) throws NPE
910	–	*/
911	–	public void testDrainToNullN() {
912	–	ArrayBlockingQueue q = populatedQueue(SIZE);
913	–	try {
914	–	q.drainTo(null, 0);
915	–	shouldThrow();
916	–	} catch (NullPointerException success) {}
917	–	}
918	–
919	–	/**
920	–	* drainTo(this, n) throws IAE
921	–	*/
922	–	public void testDrainToSelfN() {
923	–	ArrayBlockingQueue q = populatedQueue(SIZE);
924	–	try {
925	–	q.drainTo(q, 0);
926	–	shouldThrow();
927	–	} catch (IllegalArgumentException success) {}
928	–	}
929	–
930	–	/**
831		* drainTo(c, n) empties first min(n, size) elements of queue into c
832		*/
833		public void testDrainToN() {

Diff Legend

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