ViewVC Help

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

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

Comparing jsr166/src/test/tck/ConcurrentLinkedDequeTest.java (file contents):
Revision 1.19 by jsr166, Sat Apr 25 04:55:30 2015 UTC vs.
Revision 1.20 by jsr166, Fri May 15 18:21:19 2015 UTC

#	Line 65 | Line 65 | public class ConcurrentLinkedDequeTest e
65		*/
66		public void testConstructor4() {
67		try {
68	<	Integer[] ints = new Integer[SIZE];
69	<	new ConcurrentLinkedDeque(Arrays.asList(ints));
68	>	new ConcurrentLinkedDeque(Arrays.asList(new Integer[SIZE]));
69		shouldThrow();
70		} catch (NullPointerException success) {}
71		}
#	Line 75 | Line 74 | public class ConcurrentLinkedDequeTest e
74		* Initializing from Collection with some null elements throws NPE
75		*/
76		public void testConstructor5() {
77	+	Integer[] ints = new Integer[SIZE];
78	+	for (int i = 0; i < SIZE-1; ++i)
79	+	ints[i] = new Integer(i);
80		try {
79	–	Integer[] ints = new Integer[SIZE];
80	–	for (int i = 0; i < SIZE-1; ++i)
81	–	ints[i] = new Integer(i);
81		new ConcurrentLinkedDeque(Arrays.asList(ints));
82		shouldThrow();
83		} catch (NullPointerException success) {}
#	Line 129 | Line 128 | public class ConcurrentLinkedDequeTest e
128		* push(null) throws NPE
129		*/
130		public void testPushNull() {
131	+	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
132		try {
133	–	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
133		q.push(null);
134		shouldThrow();
135		} catch (NullPointerException success) {}
#	Line 164 | Line 163 | public class ConcurrentLinkedDequeTest e
163		* offer(null) throws NPE
164		*/
165		public void testOfferNull() {
166	+	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
167		try {
168	–	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
168		q.offer(null);
169		shouldThrow();
170		} catch (NullPointerException success) {}
#	Line 175 | Line 174 | public class ConcurrentLinkedDequeTest e
174		* offerFirst(null) throws NPE
175		*/
176		public void testOfferFirstNull() {
177	+	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
178		try {
179	–	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
179		q.offerFirst(null);
180		shouldThrow();
181		} catch (NullPointerException success) {}
#	Line 186 | Line 185 | public class ConcurrentLinkedDequeTest e
185		* offerLast(null) throws NPE
186		*/
187		public void testOfferLastNull() {
188	+	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
189		try {
190	–	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
190		q.offerLast(null);
191		shouldThrow();
192		} catch (NullPointerException success) {}
#	Line 230 | Line 229 | public class ConcurrentLinkedDequeTest e
229		* add(null) throws NPE
230		*/
231		public void testAddNull() {
232	+	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
233		try {
234	–	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
234		q.add(null);
235		shouldThrow();
236		} catch (NullPointerException success) {}
#	Line 241 | Line 240 | public class ConcurrentLinkedDequeTest e
240		* addFirst(null) throws NPE
241		*/
242		public void testAddFirstNull() {
243	+	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
244		try {
245	–	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
245		q.addFirst(null);
246		shouldThrow();
247		} catch (NullPointerException success) {}
#	Line 252 | Line 251 | public class ConcurrentLinkedDequeTest e
251		* addLast(null) throws NPE
252		*/
253		public void testAddLastNull() {
254	+	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
255		try {
256	–	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
256		q.addLast(null);
257		shouldThrow();
258		} catch (NullPointerException success) {}
#	Line 296 | Line 295 | public class ConcurrentLinkedDequeTest e
295		* addAll(null) throws NPE
296		*/
297		public void testAddAll1() {
298	+	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
299		try {
300	–	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
300		q.addAll(null);
301		shouldThrow();
302		} catch (NullPointerException success) {}
#	Line 307 | Line 306 | public class ConcurrentLinkedDequeTest e
306		* addAll(this) throws IAE
307		*/
308		public void testAddAllSelf() {
309	+	ConcurrentLinkedDeque q = populatedDeque(SIZE);
310		try {
311	–	ConcurrentLinkedDeque q = populatedDeque(SIZE);
311		q.addAll(q);
312		shouldThrow();
313		} catch (IllegalArgumentException success) {}
#	Line 318 | Line 317 | public class ConcurrentLinkedDequeTest e
317		* addAll of a collection with null elements throws NPE
318		*/
319		public void testAddAll2() {
320	+	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
321		try {
322	<	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
323	<	Integer[] ints = new Integer[SIZE];
324	<	q.addAll(Arrays.asList(ints));
322	>	q.addAll(Arrays.asList(new Integer[SIZE]));
323		shouldThrow();
324		} catch (NullPointerException success) {}
325		}
#	Line 331 | Line 329 | public class ConcurrentLinkedDequeTest e
329		* possibly adding some elements
330		*/
331		public void testAddAll3() {
332	+	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
333	+	Integer[] ints = new Integer[SIZE];
334	+	for (int i = 0; i < SIZE-1; ++i)
335	+	ints[i] = new Integer(i);
336		try {
335	–	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
336	–	Integer[] ints = new Integer[SIZE];
337	–	for (int i = 0; i < SIZE-1; ++i)
338	–	ints[i] = new Integer(i);
337		q.addAll(Arrays.asList(ints));
338		shouldThrow();
339		} catch (NullPointerException success) {}

Diff Legend

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