ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/LockSupportTest.java
(Generate patch)

Comparing jsr166/src/test/tck/LockSupportTest.java (file contents):
Revision 1.1 by dl, Sun Aug 31 19:24:55 2003 UTC vs.
Revision 1.4 by dl, Thu Sep 25 11:02:41 2003 UTC

# Line 10 | Line 10 | import java.util.*;
10   import java.util.concurrent.*;
11   import java.util.concurrent.locks.*;
12  
13 < public class LockSupportTest extends TestCase{
14 <
13 > public class LockSupportTest extends JSR166TestCase{
14      public static void main(String[] args) {
15          junit.textui.TestRunner.run (suite());  
16      }
18 –    
19 –
17      public static Test suite() {
18          return new TestSuite(LockSupportTest.class);
19      }
20  
21 <    public void testUnpark() {
22 <        Thread t = new Thread(new Runnable(){
23 <                public void run(){
24 <                    try{
21 >    /**
22 >     * park is released by unpark occuring after park
23 >     */
24 >    public void testPark() {
25 >        Thread t = new Thread(new Runnable() {
26 >                public void run() {
27 >                    try {
28 >                        LockSupport.park();
29 >                    } catch(Exception e){
30 >                        threadUnexpectedException();
31 >                    }
32 >                }
33 >            });
34 >        try {
35 >            t.start();
36 >            Thread.sleep(SHORT_DELAY_MS);
37 >            LockSupport.unpark(t);
38 >            t.join();
39 >        }
40 >        catch(Exception e) {
41 >            unexpectedException();
42 >        }
43 >    }
44 >
45 >    /**
46 >     * park is released by unpark occuring before park
47 >     */
48 >    public void testPark2() {
49 >        Thread t = new Thread(new Runnable() {
50 >                public void run() {
51 >                    try {
52 >                        Thread.sleep(SHORT_DELAY_MS);
53                          LockSupport.park();
54 <                    }catch(Exception e){
55 <                        fail("unexpected exception");
54 >                    } catch(Exception e){
55 >                        threadUnexpectedException();
56                      }
57                  }
58              });
59 <        t.start();
60 <        try{
59 >        try {
60 >            t.start();
61              LockSupport.unpark(t);
62              t.join();
63          }
64          catch(Exception e) {
65 <            fail("unexpected exception");
65 >            unexpectedException();
66          }
67      }
68  
69 +    /**
70 +     * park is released by interrupt
71 +     */
72 +    public void testPark3() {
73 +        Thread t = new Thread(new Runnable() {
74 +                public void run() {
75 +                    try {
76 +                        LockSupport.park();
77 +                        threadAssertTrue(Thread.interrupted());
78 +                    } catch(Exception e){
79 +                        threadUnexpectedException();
80 +                    }
81 +                }
82 +            });
83 +        try {
84 +            t.start();
85 +            Thread.sleep(SHORT_DELAY_MS);
86 +            t.interrupt();
87 +            t.join();
88 +        }
89 +        catch(Exception e) {
90 +            unexpectedException();
91 +        }
92 +    }
93 +
94 +    /**
95 +     * park returns if interrupted before park
96 +     */
97 +    public void testPark4() {
98 +        final ReentrantLock lock = new ReentrantLock();
99 +        lock.lock();
100 +        Thread t = new Thread(new Runnable() {
101 +                public void run() {
102 +                    try {
103 +                        lock.lock();
104 +                        LockSupport.park();
105 +                    } catch(Exception e){
106 +                        threadUnexpectedException();
107 +                    }
108 +                }
109 +            });
110 +        try {
111 +            t.start();
112 +            t.interrupt();
113 +            lock.unlock();
114 +            t.join();
115 +        }
116 +        catch(Exception e) {
117 +            unexpectedException();
118 +        }
119 +    }
120 +
121 +    /**
122 +     * parkNanos times out if not unparked
123 +     */
124      public void testParkNanos() {
125 <        Thread t = new Thread(new Runnable(){
126 <                public void run(){
127 <                    try{
125 >        Thread t = new Thread(new Runnable() {
126 >                public void run() {
127 >                    try {
128                          LockSupport.parkNanos(1000);
129 <                    }catch(Exception e){
130 <                        fail("unexpected exception");
129 >                    } catch(Exception e){
130 >                        threadUnexpectedException();
131                      }
132                  }
133              });
134 <        try{
134 >        try {
135              t.start();
136              t.join();
137          }
138          catch(Exception e) {
139 <            fail("unexpected exception");
139 >            unexpectedException();
140          }
141      }
142  
143  
144 +    /**
145 +     * parkUntil times out if not unparked
146 +     */
147      public void testParkUntil() {
148 <        Thread t = new Thread(new Runnable(){
149 <                public void run(){
150 <                    try{
148 >        Thread t = new Thread(new Runnable() {
149 >                public void run() {
150 >                    try {
151                          long d = new Date().getTime() + 100;
152                          LockSupport.parkUntil(d);
153 <                    }catch(Exception e){
154 <                        fail("unexpected exception");
153 >                    } catch(Exception e){
154 >                        threadUnexpectedException();
155                      }
156                  }
157              });
158 <        try{
158 >        try {
159              t.start();
160              t.join();
161          }
162          catch(Exception e) {
163 <            fail("unexpected exception");
163 >            unexpectedException();
164          }
165      }
83 –
84 –
166   }

Diff Legend

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