ViewVC Help

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

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

Comparing jsr166/src/test/tck/LinkedTransferQueueTest.java (file contents):
Revision 1.14 by jsr166, Sat Aug 15 03:20:36 2009 UTC vs.
Revision 1.18 by jsr166, Sat Nov 21 21:00:34 2009 UTC

#	Line 44 | Line 44 | public class LinkedTransferQueueTest ext
44		try {
45		q.element();
46		shouldThrow();
47	<	} catch (NoSuchElementException success) {
48	<	}
47	>	} catch (NoSuchElementException success) {}
48		try {
49		q.iterator().next();
50		shouldThrow();
51	<	} catch (NoSuchElementException success) {
53	<	}
51	>	} catch (NoSuchElementException success) {}
52		try {
53		q.remove();
54		shouldThrow();
55	<	} catch (NoSuchElementException success) {
58	<	}
55	>	} catch (NoSuchElementException success) {}
56		}
57
58		/**
#	Line 75 | Line 72 | public class LinkedTransferQueueTest ext
72		try {
73		new LinkedTransferQueue(null);
74		shouldThrow();
75	<	} catch (NullPointerException success) {
79	<	}
75	>	} catch (NullPointerException success) {}
76		}
77
78		/**
#	Line 88 | Line 84 | public class LinkedTransferQueueTest ext
84		Integer[] ints = new Integer[SIZE];
85		new LinkedTransferQueue(Arrays.asList(ints));
86		shouldThrow();
87	<	} catch (NullPointerException success) {
92	<	}
87	>	} catch (NullPointerException success) {}
88		}
89
90		/**
#	Line 104 | Line 99 | public class LinkedTransferQueueTest ext
99		}
100		new LinkedTransferQueue(Arrays.asList(ints));
101		shouldThrow();
102	<	} catch (NullPointerException success) {
108	<	}
102	>	} catch (NullPointerException success) {}
103		}
104
105		/**
#	Line 157 | Line 151 | public class LinkedTransferQueueTest ext
151		LinkedTransferQueue q = new LinkedTransferQueue();
152		q.offer(null);
153		shouldThrow();
154	<	} catch (NullPointerException success) {
161	<	}
154	>	} catch (NullPointerException success) {}
155		}
156
157		/**
#	Line 169 | Line 162 | public class LinkedTransferQueueTest ext
162		LinkedTransferQueue q = new LinkedTransferQueue();
163		q.add(null);
164		shouldThrow();
165	<	} catch (NullPointerException success) {
173	<	}
165	>	} catch (NullPointerException success) {}
166		}
167
168		/**
#	Line 181 | Line 173 | public class LinkedTransferQueueTest ext
173		LinkedTransferQueue q = new LinkedTransferQueue();
174		q.addAll(null);
175		shouldThrow();
176	<	} catch (NullPointerException success) {
185	<	}
176	>	} catch (NullPointerException success) {}
177		}
178
179		/**
#	Line 193 | Line 184 | public class LinkedTransferQueueTest ext
184		LinkedTransferQueue q = populatedQueue(SIZE);
185		q.addAll(q);
186		shouldThrow();
187	<	} catch (IllegalArgumentException success) {
197	<	}
187	>	} catch (IllegalArgumentException success) {}
188		}
189
190		/**
#	Line 206 | Line 196 | public class LinkedTransferQueueTest ext
196		Integer[] ints = new Integer[SIZE];
197		q.addAll(Arrays.asList(ints));
198		shouldThrow();
199	<	} catch (NullPointerException success) {
210	<	}
199	>	} catch (NullPointerException success) {}
200		}
201
202		/**
#	Line 223 | Line 212 | public class LinkedTransferQueueTest ext
212		}
213		q.addAll(Arrays.asList(ints));
214		shouldThrow();
215	<	} catch (NullPointerException success) {
227	<	}
215	>	} catch (NullPointerException success) {}
216		}
217
218		/**
#	Line 354 | Line 342 | public class LinkedTransferQueueTest ext
342		*/
343		public void testInterruptedTimedPoll() throws InterruptedException {
344		final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
345	<	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
345	>	Thread t = newStartedThread(new CheckedRunnable() {
346		void realRun() throws InterruptedException {
347		for (int i = 0; i < SIZE; ++i) {
348		long t0 = System.nanoTime();
#	Line 363 | Line 351 | public class LinkedTransferQueueTest ext
351		long millisElapsed = (System.nanoTime() - t0)/(1024 * 1024);
352		assertTrue(millisElapsed < SMALL_DELAY_MS);
353		}
354	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
354	>	try {
355	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
356	>	shouldThrow();
357	>	} catch (InterruptedException success) {}
358		}});
359	+
360		Thread.sleep(SMALL_DELAY_MS);
361		t.interrupt();
362		t.join();
#	Line 377 | Line 369 | public class LinkedTransferQueueTest ext
369		*/
370		public void testTimedPollWithOffer() throws InterruptedException {
371		final LinkedTransferQueue q = new LinkedTransferQueue();
372	<	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
372	>	Thread t = new Thread(new CheckedRunnable() {
373		void realRun() throws InterruptedException {
374	<	threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
375	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
376	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
374	>	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
375	>	assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
376	>	try {
377	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
378	>	shouldThrow();
379	>	} catch (InterruptedException success) {}
380		}});
381	+
382		Thread.sleep(SMALL_DELAY_MS);
383		assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
384		t.interrupt();
#	Line 416 | Line 412 | public class LinkedTransferQueueTest ext
412		try {
413		q.element();
414		shouldThrow();
415	<	} catch (NoSuchElementException success) {
420	<	}
415	>	} catch (NoSuchElementException success) {}
416		checkEmpty(q);
417		}
418
#	Line 432 | Line 427 | public class LinkedTransferQueueTest ext
427		try {
428		q.remove();
429		shouldThrow();
430	<	} catch (NoSuchElementException success) {
436	<	}
430	>	} catch (NoSuchElementException success) {}
431		checkEmpty(q);
432		}
433
#	Line 574 | Line 568 | public class LinkedTransferQueueTest ext
568		LinkedTransferQueue q = populatedQueue(SIZE);
569		Object o[] = q.toArray(null);
570		shouldThrow();
571	<	} catch (NullPointerException success) {
578	<	}
571	>	} catch (NullPointerException success) {}
572		}
573
574		/**
#	Line 586 | Line 579 | public class LinkedTransferQueueTest ext
579		LinkedTransferQueue q = populatedQueue(SIZE);
580		Object o[] = q.toArray(new String[10]);
581		shouldThrow();
582	<	} catch (ArrayStoreException success) {
590	<	}
582	>	} catch (ArrayStoreException success) {}
583		}
584
585		/**
#	Line 746 | Line 738 | public class LinkedTransferQueueTest ext
738		try {
739		q.drainTo(null);
740		shouldThrow();
741	<	} catch (NullPointerException success) {
750	<	}
741	>	} catch (NullPointerException success) {}
742		}
743
744		/**
#	Line 758 | Line 749 | public class LinkedTransferQueueTest ext
749		try {
750		q.drainTo(q);
751		shouldThrow();
752	<	} catch (IllegalArgumentException success) {
762	<	}
752	>	} catch (IllegalArgumentException success) {}
753		}
754
755		/**
#	Line 815 | Line 805 | public class LinkedTransferQueueTest ext
805		try {
806		q.drainTo(null, SIZE);
807		shouldThrow();
808	<	} catch (NullPointerException success) {
819	<	}
808	>	} catch (NullPointerException success) {}
809		}
810
811		/**
#	Line 827 | Line 816 | public class LinkedTransferQueueTest ext
816		try {
817		q.drainTo(q, SIZE);
818		shouldThrow();
819	<	} catch (IllegalArgumentException success) {
831	<	}
819	>	} catch (IllegalArgumentException success) {}
820		}
821
822		/**
#	Line 886 | Line 874 | public class LinkedTransferQueueTest ext
874		LinkedTransferQueue q = new LinkedTransferQueue();
875		q.transfer(null);
876		shouldThrow();
877	<	} catch (NullPointerException ex) {
890	<	}
877	>	} catch (NullPointerException success) {}
878		}
879
880		/**
#	Line 994 | Line 981 | public class LinkedTransferQueueTest ext
981		final LinkedTransferQueue q = new LinkedTransferQueue();
982		q.tryTransfer(null);
983		shouldThrow();
984	<	} catch (NullPointerException ex) {
998	<	}
984	>	} catch (NullPointerException success) {}
985		}
986
987		/**

Diff Legend

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