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

Comparing jsr166/src/test/tck/AtomicBooleanTest.java (file contents):
Revision 1.11 by jsr166, Mon Nov 16 04:57:10 2009 UTC vs.
Revision 1.26 by jsr166, Fri Jun 17 01:38:28 2016 UTC

# Line 1 | Line 1
1   /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
10 < import java.util.concurrent.atomic.*;
11 < import java.io.*;
9 > import java.util.concurrent.atomic.AtomicBoolean;
10 >
11 > import junit.framework.Test;
12 > import junit.framework.TestSuite;
13  
14   public class AtomicBooleanTest extends JSR166TestCase {
15 <    public static void main (String[] args) {
16 <        junit.textui.TestRunner.run (suite());
15 >    public static void main(String[] args) {
16 >        main(suite(), args);
17      }
18      public static Test suite() {
19          return new TestSuite(AtomicBooleanTest.class);
# Line 22 | Line 23 | public class AtomicBooleanTest extends J
23       * constructor initializes to given value
24       */
25      public void testConstructor() {
26 <        AtomicBoolean ai = new AtomicBoolean(true);
27 <        assertEquals(true,ai.get());
26 >        assertTrue(new AtomicBoolean(true).get());
27 >        assertFalse(new AtomicBoolean(false).get());
28      }
29  
30      /**
# Line 31 | Line 32 | public class AtomicBooleanTest extends J
32       */
33      public void testConstructor2() {
34          AtomicBoolean ai = new AtomicBoolean();
35 <        assertEquals(false,ai.get());
35 >        assertFalse(ai.get());
36      }
37  
38      /**
# Line 39 | Line 40 | public class AtomicBooleanTest extends J
40       */
41      public void testGetSet() {
42          AtomicBoolean ai = new AtomicBoolean(true);
43 <        assertEquals(true,ai.get());
44 <        ai.set(false);
45 <        assertEquals(false,ai.get());
46 <        ai.set(true);
47 <        assertEquals(true,ai.get());
47 <
43 >        assertTrue(ai.get());
44 >        ai.set(false);
45 >        assertFalse(ai.get());
46 >        ai.set(true);
47 >        assertTrue(ai.get());
48      }
49  
50      /**
# Line 52 | Line 52 | public class AtomicBooleanTest extends J
52       */
53      public void testGetLazySet() {
54          AtomicBoolean ai = new AtomicBoolean(true);
55 <        assertEquals(true,ai.get());
56 <        ai.lazySet(false);
57 <        assertEquals(false,ai.get());
58 <        ai.lazySet(true);
59 <        assertEquals(true,ai.get());
60 <
55 >        assertTrue(ai.get());
56 >        ai.lazySet(false);
57 >        assertFalse(ai.get());
58 >        ai.lazySet(true);
59 >        assertTrue(ai.get());
60      }
61  
62      /**
# Line 65 | Line 64 | public class AtomicBooleanTest extends J
64       */
65      public void testCompareAndSet() {
66          AtomicBoolean ai = new AtomicBoolean(true);
67 <        assertTrue(ai.compareAndSet(true,false));
68 <        assertEquals(false,ai.get());
69 <        assertTrue(ai.compareAndSet(false,false));
70 <        assertEquals(false,ai.get());
71 <        assertFalse(ai.compareAndSet(true,false));
72 <        assertFalse((ai.get()));
73 <        assertTrue(ai.compareAndSet(false,true));
74 <        assertEquals(true,ai.get());
67 >        assertTrue(ai.compareAndSet(true, false));
68 >        assertFalse(ai.get());
69 >        assertTrue(ai.compareAndSet(false, false));
70 >        assertFalse(ai.get());
71 >        assertFalse(ai.compareAndSet(true, false));
72 >        assertFalse(ai.get());
73 >        assertTrue(ai.compareAndSet(false, true));
74 >        assertTrue(ai.get());
75      }
76  
77      /**
78       * compareAndSet in one thread enables another waiting for value
79       * to succeed
80       */
81 <    public void testCompareAndSetInMultipleThreads() {
81 >    public void testCompareAndSetInMultipleThreads() throws Exception {
82          final AtomicBoolean ai = new AtomicBoolean(true);
83 <        Thread t = new Thread(new Runnable() {
84 <                public void run() {
85 <                    while (!ai.compareAndSet(false, true)) Thread.yield();
86 <                }});
87 <        try {
88 <            t.start();
89 <            assertTrue(ai.compareAndSet(true, false));
90 <            t.join(LONG_DELAY_MS);
91 <            assertFalse(t.isAlive());
93 <        }
94 <        catch (Exception e) {
95 <            unexpectedException();
96 <        }
83 >        Thread t = new Thread(new CheckedRunnable() {
84 >            public void realRun() {
85 >                while (!ai.compareAndSet(false, true)) Thread.yield();
86 >            }});
87 >
88 >        t.start();
89 >        assertTrue(ai.compareAndSet(true, false));
90 >        t.join(LONG_DELAY_MS);
91 >        assertFalse(t.isAlive());
92      }
93  
94      /**
# Line 102 | Line 97 | public class AtomicBooleanTest extends J
97       */
98      public void testWeakCompareAndSet() {
99          AtomicBoolean ai = new AtomicBoolean(true);
100 <        while (!ai.weakCompareAndSet(true,false));
101 <        assertEquals(false,ai.get());
102 <        while (!ai.weakCompareAndSet(false,false));
103 <        assertEquals(false,ai.get());
104 <        while (!ai.weakCompareAndSet(false,true));
105 <        assertEquals(true,ai.get());
100 >        do {} while (!ai.weakCompareAndSet(true, false));
101 >        assertFalse(ai.get());
102 >        do {} while (!ai.weakCompareAndSet(false, false));
103 >        assertFalse(ai.get());
104 >        do {} while (!ai.weakCompareAndSet(false, true));
105 >        assertTrue(ai.get());
106      }
107  
108      /**
# Line 115 | Line 110 | public class AtomicBooleanTest extends J
110       */
111      public void testGetAndSet() {
112          AtomicBoolean ai = new AtomicBoolean(true);
113 <        assertEquals(true,ai.getAndSet(false));
114 <        assertEquals(false,ai.getAndSet(false));
115 <        assertEquals(false,ai.getAndSet(true));
116 <        assertEquals(true,ai.get());
113 >        assertEquals(true, ai.getAndSet(false));
114 >        assertEquals(false, ai.getAndSet(false));
115 >        assertEquals(false, ai.getAndSet(true));
116 >        assertTrue(ai.get());
117      }
118  
119      /**
120       * a deserialized serialized atomic holds same value
121       */
122 <    public void testSerialization() {
123 <        AtomicBoolean l = new AtomicBoolean();
124 <
125 <        try {
126 <            l.set(true);
127 <            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
128 <            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
129 <            out.writeObject(l);
135 <            out.close();
136 <
137 <            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
138 <            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
139 <            AtomicBoolean r = (AtomicBoolean) in.readObject();
140 <            assertEquals(l.get(), r.get());
141 <        } catch (Exception e){
142 <            e.printStackTrace();
143 <            unexpectedException();
144 <        }
122 >    public void testSerialization() throws Exception {
123 >        AtomicBoolean x = new AtomicBoolean();
124 >        AtomicBoolean y = serialClone(x);
125 >        x.set(true);
126 >        AtomicBoolean z = serialClone(x);
127 >        assertTrue(x.get());
128 >        assertFalse(y.get());
129 >        assertTrue(z.get());
130      }
131  
132      /**
# Line 149 | Line 134 | public class AtomicBooleanTest extends J
134       */
135      public void testToString() {
136          AtomicBoolean ai = new AtomicBoolean();
137 <        assertEquals(ai.toString(), Boolean.toString(false));
137 >        assertEquals(Boolean.toString(false), ai.toString());
138 >        ai.set(true);
139 >        assertEquals(Boolean.toString(true), ai.toString());
140 >    }
141 >
142 >    // jdk9
143 >
144 >    /**
145 >     * getPlain returns the last value set
146 >     */
147 >    public void testGetPlainSet() {
148 >        AtomicBoolean ai = new AtomicBoolean(true);
149 >        assertEquals(true, ai.getPlain());
150 >        ai.set(false);
151 >        assertEquals(false, ai.getPlain());
152 >        ai.set(true);
153 >        assertEquals(true, ai.getPlain());
154 >    }
155 >
156 >    /**
157 >     * getOpaque returns the last value set
158 >     */
159 >    public void testGetOpaqueSet() {
160 >        AtomicBoolean ai = new AtomicBoolean(true);
161 >        assertEquals(true, ai.getOpaque());
162 >        ai.set(false);
163 >        assertEquals(false, ai.getOpaque());
164          ai.set(true);
165 <        assertEquals(ai.toString(), Boolean.toString(true));
165 >        assertEquals(true, ai.getOpaque());
166 >    }
167 >
168 >    /**
169 >     * getAcquire returns the last value set
170 >     */
171 >    public void testGetAcquireSet() {
172 >        AtomicBoolean ai = new AtomicBoolean(true);
173 >        assertEquals(true, ai.getAcquire());
174 >        ai.set(false);
175 >        assertEquals(false, ai.getAcquire());
176 >        ai.set(true);
177 >        assertEquals(true, ai.getAcquire());
178 >    }
179 >
180 >    /**
181 >     * get returns the last value setPlain
182 >     */
183 >    public void testGetSetPlain() {
184 >        AtomicBoolean ai = new AtomicBoolean(true);
185 >        assertEquals(true, ai.get());
186 >        ai.setPlain(false);
187 >        assertEquals(false, ai.get());
188 >        ai.setPlain(true);
189 >        assertEquals(true, ai.get());
190 >    }
191 >
192 >    /**
193 >     * get returns the last value setOpaque
194 >     */
195 >    public void testGetSetOpaque() {
196 >        AtomicBoolean ai = new AtomicBoolean(true);
197 >        assertEquals(true, ai.get());
198 >        ai.setOpaque(false);
199 >        assertEquals(false, ai.get());
200 >        ai.setOpaque(true);
201 >        assertEquals(true, ai.get());
202 >    }
203 >
204 >    /**
205 >     * get returns the last value setRelease
206 >     */
207 >    public void testGetSetRelease() {
208 >        AtomicBoolean ai = new AtomicBoolean(true);
209 >        assertEquals(true, ai.get());
210 >        ai.setRelease(false);
211 >        assertEquals(false, ai.get());
212 >        ai.setRelease(true);
213 >        assertEquals(true, ai.get());
214 >    }
215 >
216 >    /**
217 >     * compareAndExchange succeeds in changing value if equal to
218 >     * expected else fails
219 >     */
220 >    public void testCompareAndExchange() {
221 >        AtomicBoolean ai = new AtomicBoolean(true);
222 >        assertEquals(true, ai.compareAndExchange(true, false));
223 >        assertEquals(false, ai.compareAndExchange(false, false));
224 >        assertEquals(false, ai.get());
225 >        assertEquals(false, ai.compareAndExchange(true, true));
226 >        assertEquals(false, ai.get());
227 >        assertEquals(false, ai.compareAndExchange(false, true));
228 >        assertEquals(true, ai.get());
229 >    }
230 >
231 >    /**
232 >     * compareAndExchangeAcquire succeeds in changing value if equal to
233 >     * expected else fails
234 >     */
235 >    public void testCompareAndExchangeAcquire() {
236 >        AtomicBoolean ai = new AtomicBoolean(true);
237 >        assertEquals(true, ai.compareAndExchangeAcquire(true, false));
238 >        assertEquals(false, ai.compareAndExchangeAcquire(false, false));
239 >        assertEquals(false, ai.get());
240 >        assertEquals(false, ai.compareAndExchangeAcquire(true, true));
241 >        assertEquals(false, ai.get());
242 >        assertEquals(false, ai.compareAndExchangeAcquire(false, true));
243 >        assertEquals(true, ai.get());
244 >    }
245 >
246 >    /**
247 >     * compareAndExchangeRelease succeeds in changing value if equal to
248 >     * expected else fails
249 >     */
250 >    public void testCompareAndExchangeRelease() {
251 >        AtomicBoolean ai = new AtomicBoolean(true);
252 >        assertEquals(true, ai.compareAndExchangeRelease(true, false));
253 >        assertEquals(false, ai.compareAndExchangeRelease(false, false));
254 >        assertEquals(false, ai.get());
255 >        assertEquals(false, ai.compareAndExchangeRelease(true, true));
256 >        assertEquals(false, ai.get());
257 >        assertEquals(false, ai.compareAndExchangeRelease(false, true));
258 >        assertEquals(true, ai.get());
259 >    }
260 >
261 >    /**
262 >     * repeated weakCompareAndSetVolatile succeeds in changing value when equal
263 >     * to expected
264 >     */
265 >    public void testWeakCompareAndSetVolatile() {
266 >        AtomicBoolean ai = new AtomicBoolean(true);
267 >        do {} while (!ai.weakCompareAndSetVolatile(true, false));
268 >        do {} while (!ai.weakCompareAndSetVolatile(false, false));
269 >        assertEquals(false, ai.get());
270 >        do {} while (!ai.weakCompareAndSetVolatile(false, true));
271 >        assertEquals(true, ai.get());
272 >    }
273 >
274 >    /**
275 >     * repeated weakCompareAndSetAcquire succeeds in changing value when equal
276 >     * to expected
277 >     */
278 >    public void testWeakCompareAndSetAcquire() {
279 >        AtomicBoolean ai = new AtomicBoolean(true);
280 >        do {} while (!ai.weakCompareAndSetAcquire(true, false));
281 >        do {} while (!ai.weakCompareAndSetAcquire(false, false));
282 >        assertEquals(false, ai.get());
283 >        do {} while (!ai.weakCompareAndSetAcquire(false, true));
284 >        assertEquals(true, ai.get());
285 >    }
286 >
287 >    /**
288 >     * repeated weakCompareAndSetRelease succeeds in changing value when equal
289 >     * to expected
290 >     */
291 >    public void testWeakCompareAndSetRelease() {
292 >        AtomicBoolean ai = new AtomicBoolean(true);
293 >        do {} while (!ai.weakCompareAndSetRelease(true, false));
294 >        do {} while (!ai.weakCompareAndSetRelease(false, false));
295 >        assertEquals(false, ai.get());
296 >        do {} while (!ai.weakCompareAndSetRelease(false, true));
297 >        assertEquals(true, ai.get());
298      }
299  
300   }

Diff Legend

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