ViewVC Help

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

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

Comparing jsr166/src/test/tck/CancellableTaskTest.java (file contents):
Revision 1.2 by dl, Fri Sep 12 15:40:25 2003 UTC vs.
Revision 1.3 by dl, Sun Sep 14 20:42:40 2003 UTC

#	Line 9 | Line 9 | import junit.framework.*;
9		import java.util.*;
10		import java.util.concurrent.*;
11
12	<	public class CancellableTaskTest extends TestCase{
12	>	public class CancellableTaskTest extends JSR166TestCase {
13		public static void main(String[] args) {
14		junit.textui.TestRunner.run (suite());
15		}
#	Line 17 | Line 17 | public class CancellableTaskTest extends
17		return new TestSuite(CancellableTaskTest.class);
18		}
19
20	<	private static long SHORT_DELAY_MS = 100;
21	<	private static long MEDIUM_DELAY_MS = 1000;
22	<	private static long LONG_DELAY_MS = 10000;
23	<
20	>	/**
21	>	* Subclass to expose protected methods
22	>	*/
23	>	static class MyCancellableTask extends CancellableTask {
24	>	public MyCancellableTask() {}
25	>	public MyCancellableTask(Runnable r) { super(r); }
26	>	public boolean reset() { return super.reset(); }
27	>	public Runnable getRunnable() { return super.getRunnable(); }
28	>	public void setRunnable(Runnable r) { super.setRunnable(r); }
29	>	public void setCancelled() { super.setCancelled(); }
30	>	public void setDone() { super.setDone(); }
31	>	}
32
33		public void testConstructor(){
34		try {
#	Line 32 | Line 40 | public class CancellableTaskTest extends
40		}
41
42		public void testIsDone(){
43	<	CancellableTask task = new CancellableTask(new Runnable() {
36	<	public void run() {} });
43	>	CancellableTask task = new CancellableTask(new NoOpRunnable());
44		task.run();
45		assertTrue(task.isDone());
46		assertFalse(task.isCancelled());
47		}
48
49	+	public void testReset(){
50	+	MyCancellableTask task = new MyCancellableTask(new NoOpRunnable());
51	+	task.run();
52	+	assertTrue(task.isDone());
53	+	assertTrue(task.reset());
54	+	}
55	+
56		public void testCancelBeforeRun() {
57	<	CancellableTask task = new CancellableTask(new Runnable() {
58	<	public void run() {} });
57	>	CancellableTask task = new CancellableTask(new NoOpRunnable());
58	>	assertTrue(task.cancel(false));
59	>	task.run();
60	>	assertTrue(task.isDone());
61	>	assertTrue(task.isCancelled());
62	>	}
63	>
64	>	public void testResetAfterCancel() {
65	>	MyCancellableTask task = new MyCancellableTask(new NoOpRunnable());
66	>	assertTrue(task.cancel(false));
67	>	task.run();
68	>	assertTrue(task.isDone());
69	>	assertTrue(task.isCancelled());
70	>	assertFalse(task.reset());
71	>	}
72	>
73	>	public void testSetRunnable() {
74	>	MyCancellableTask task = new MyCancellableTask();
75	>	assertNull(task.getRunnable());
76	>	Runnable r = new NoOpRunnable();
77	>	task.setRunnable(r);
78	>	assertEquals(r, task.getRunnable());
79		assertTrue(task.cancel(false));
80		task.run();
81		assertTrue(task.isDone());
82		assertTrue(task.isCancelled());
83	+	assertFalse(task.reset());
84	+	}
85	+
86	+	public void testSetDone() {
87	+	MyCancellableTask task = new MyCancellableTask(new NoOpRunnable());
88	+	task.setDone();
89	+	assertTrue(task.isDone());
90	+	assertFalse(task.isCancelled());
91	+	}
92	+
93	+	public void testSetCancelled() {
94	+	MyCancellableTask task = new MyCancellableTask(new NoOpRunnable());
95	+	assertTrue(task.cancel(false));
96	+	task.setCancelled();
97	+	assertTrue(task.isDone());
98	+	assertTrue(task.isCancelled());
99		}
100
101		public void testCancelBeforeRun2() {
102	<	CancellableTask task = new CancellableTask(new Runnable() {
53	<	public void run() {} });
102	>	CancellableTask task = new CancellableTask(new NoOpRunnable());
103		assertTrue(task.cancel(true));
104		task.run();
105		assertTrue(task.isDone());
#	Line 58 | Line 107 | public class CancellableTaskTest extends
107		}
108
109		public void testCancelAfterRun() {
110	<	CancellableTask task = new CancellableTask(new Runnable() {
62	<	public void run() {} });
110	>	CancellableTask task = new CancellableTask(new NoOpRunnable());
111		task.run();
112		assertFalse(task.cancel(false));
113		assertTrue(task.isDone());
#	Line 67 | Line 115 | public class CancellableTaskTest extends
115		}
116
117		public void testCancelInterrupt(){
118	<	CancellableTask task = new CancellableTask(new Runnable() {
71	<	public void run() {
72	<	try {
73	<	Thread.sleep(SHORT_DELAY_MS* 2);
74	<	fail("should throw");
75	<	}
76	<	catch (InterruptedException success) {}
77	<	} });
118	>	CancellableTask task = new CancellableTask(new SmallInterruptedRunnable());
119		Thread t = new  Thread(task);
79	–	t.start();
120
121		try{
122	+	t.start();
123		Thread.sleep(SHORT_DELAY_MS);
124		assertTrue(task.cancel(true));
125		t.join();
#	Line 91 | Line 132 | public class CancellableTaskTest extends
132
133
134		public void testCancelNoInterrupt(){
135	<	CancellableTask task = new CancellableTask(new Runnable() {
95	<	public void run() {
96	<	try {
97	<	Thread.sleep(SHORT_DELAY_MS* 2);
98	<	}
99	<	catch (InterruptedException success) {
100	<	fail("should not interrupt");
101	<	}
102	<	} });
135	>	CancellableTask task = new CancellableTask(new SmallRunnable());
136		Thread t = new  Thread(task);
104	–	t.start();
105	–
137		try{
138	+	t.start();
139		Thread.sleep(SHORT_DELAY_MS);
140		assertTrue(task.cancel(false));
141		t.join();

Diff Legend

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