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

Comparing jsr166/src/test/tck/AtomicLongTest.java (file contents):
Revision 1.22 by jsr166, Tue May 31 16:16:23 2011 UTC vs.
Revision 1.31 by jsr166, Fri Jun 17 01:38:28 2016 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import junit.framework.*;
9   import java.util.concurrent.atomic.AtomicLong;
10  
11 + import junit.framework.Test;
12 + import junit.framework.TestSuite;
13 +
14   public class AtomicLongTest extends JSR166TestCase {
15      public static void main(String[] args) {
16 <        junit.textui.TestRunner.run(suite());
16 >        main(suite(), args);
17      }
18      public static Test suite() {
19          return new TestSuite(AtomicLongTest.class);
# Line 28 | Line 30 | public class AtomicLongTest extends JSR1
30       */
31      public void testConstructor() {
32          AtomicLong ai = new AtomicLong(1);
33 <        assertEquals(1,ai.get());
33 >        assertEquals(1, ai.get());
34      }
35  
36      /**
# Line 36 | Line 38 | public class AtomicLongTest extends JSR1
38       */
39      public void testConstructor2() {
40          AtomicLong ai = new AtomicLong();
41 <        assertEquals(0,ai.get());
41 >        assertEquals(0, ai.get());
42      }
43  
44      /**
# Line 44 | Line 46 | public class AtomicLongTest extends JSR1
46       */
47      public void testGetSet() {
48          AtomicLong ai = new AtomicLong(1);
49 <        assertEquals(1,ai.get());
49 >        assertEquals(1, ai.get());
50          ai.set(2);
51 <        assertEquals(2,ai.get());
51 >        assertEquals(2, ai.get());
52          ai.set(-3);
53 <        assertEquals(-3,ai.get());
53 >        assertEquals(-3, ai.get());
54      }
55  
56      /**
# Line 56 | Line 58 | public class AtomicLongTest extends JSR1
58       */
59      public void testGetLazySet() {
60          AtomicLong ai = new AtomicLong(1);
61 <        assertEquals(1,ai.get());
61 >        assertEquals(1, ai.get());
62          ai.lazySet(2);
63 <        assertEquals(2,ai.get());
63 >        assertEquals(2, ai.get());
64          ai.lazySet(-3);
65 <        assertEquals(-3,ai.get());
65 >        assertEquals(-3, ai.get());
66      }
67  
68      /**
# Line 68 | Line 70 | public class AtomicLongTest extends JSR1
70       */
71      public void testCompareAndSet() {
72          AtomicLong ai = new AtomicLong(1);
73 <        assertTrue(ai.compareAndSet(1,2));
74 <        assertTrue(ai.compareAndSet(2,-4));
75 <        assertEquals(-4,ai.get());
76 <        assertFalse(ai.compareAndSet(-5,7));
77 <        assertEquals(-4,ai.get());
78 <        assertTrue(ai.compareAndSet(-4,7));
79 <        assertEquals(7,ai.get());
73 >        assertTrue(ai.compareAndSet(1, 2));
74 >        assertTrue(ai.compareAndSet(2, -4));
75 >        assertEquals(-4, ai.get());
76 >        assertFalse(ai.compareAndSet(-5, 7));
77 >        assertEquals(-4, ai.get());
78 >        assertTrue(ai.compareAndSet(-4, 7));
79 >        assertEquals(7, ai.get());
80      }
81  
82      /**
# Line 93 | Line 95 | public class AtomicLongTest extends JSR1
95          assertTrue(ai.compareAndSet(1, 2));
96          t.join(LONG_DELAY_MS);
97          assertFalse(t.isAlive());
98 <        assertEquals(ai.get(), 3);
98 >        assertEquals(3, ai.get());
99      }
100  
101      /**
# Line 102 | Line 104 | public class AtomicLongTest extends JSR1
104       */
105      public void testWeakCompareAndSet() {
106          AtomicLong ai = new AtomicLong(1);
107 <        while (!ai.weakCompareAndSet(1,2));
108 <        while (!ai.weakCompareAndSet(2,-4));
109 <        assertEquals(-4,ai.get());
110 <        while (!ai.weakCompareAndSet(-4,7));
111 <        assertEquals(7,ai.get());
107 >        do {} while (!ai.weakCompareAndSet(1, 2));
108 >        do {} while (!ai.weakCompareAndSet(2, -4));
109 >        assertEquals(-4, ai.get());
110 >        do {} while (!ai.weakCompareAndSet(-4, 7));
111 >        assertEquals(7, ai.get());
112      }
113  
114      /**
# Line 114 | Line 116 | public class AtomicLongTest extends JSR1
116       */
117      public void testGetAndSet() {
118          AtomicLong ai = new AtomicLong(1);
119 <        assertEquals(1,ai.getAndSet(0));
120 <        assertEquals(0,ai.getAndSet(-10));
121 <        assertEquals(-10,ai.getAndSet(1));
119 >        assertEquals(1, ai.getAndSet(0));
120 >        assertEquals(0, ai.getAndSet(-10));
121 >        assertEquals(-10, ai.getAndSet(1));
122      }
123  
124      /**
# Line 124 | Line 126 | public class AtomicLongTest extends JSR1
126       */
127      public void testGetAndAdd() {
128          AtomicLong ai = new AtomicLong(1);
129 <        assertEquals(1,ai.getAndAdd(2));
130 <        assertEquals(3,ai.get());
131 <        assertEquals(3,ai.getAndAdd(-4));
132 <        assertEquals(-1,ai.get());
129 >        assertEquals(1, ai.getAndAdd(2));
130 >        assertEquals(3, ai.get());
131 >        assertEquals(3, ai.getAndAdd(-4));
132 >        assertEquals(-1, ai.get());
133      }
134  
135      /**
# Line 135 | Line 137 | public class AtomicLongTest extends JSR1
137       */
138      public void testGetAndDecrement() {
139          AtomicLong ai = new AtomicLong(1);
140 <        assertEquals(1,ai.getAndDecrement());
141 <        assertEquals(0,ai.getAndDecrement());
142 <        assertEquals(-1,ai.getAndDecrement());
140 >        assertEquals(1, ai.getAndDecrement());
141 >        assertEquals(0, ai.getAndDecrement());
142 >        assertEquals(-1, ai.getAndDecrement());
143      }
144  
145      /**
# Line 145 | Line 147 | public class AtomicLongTest extends JSR1
147       */
148      public void testGetAndIncrement() {
149          AtomicLong ai = new AtomicLong(1);
150 <        assertEquals(1,ai.getAndIncrement());
151 <        assertEquals(2,ai.get());
150 >        assertEquals(1, ai.getAndIncrement());
151 >        assertEquals(2, ai.get());
152          ai.set(-2);
153 <        assertEquals(-2,ai.getAndIncrement());
154 <        assertEquals(-1,ai.getAndIncrement());
155 <        assertEquals(0,ai.getAndIncrement());
156 <        assertEquals(1,ai.get());
153 >        assertEquals(-2, ai.getAndIncrement());
154 >        assertEquals(-1, ai.getAndIncrement());
155 >        assertEquals(0, ai.getAndIncrement());
156 >        assertEquals(1, ai.get());
157      }
158  
159      /**
# Line 159 | Line 161 | public class AtomicLongTest extends JSR1
161       */
162      public void testAddAndGet() {
163          AtomicLong ai = new AtomicLong(1);
164 <        assertEquals(3,ai.addAndGet(2));
165 <        assertEquals(3,ai.get());
166 <        assertEquals(-1,ai.addAndGet(-4));
167 <        assertEquals(-1,ai.get());
164 >        assertEquals(3, ai.addAndGet(2));
165 >        assertEquals(3, ai.get());
166 >        assertEquals(-1, ai.addAndGet(-4));
167 >        assertEquals(-1, ai.get());
168      }
169  
170      /**
# Line 170 | Line 172 | public class AtomicLongTest extends JSR1
172       */
173      public void testDecrementAndGet() {
174          AtomicLong ai = new AtomicLong(1);
175 <        assertEquals(0,ai.decrementAndGet());
176 <        assertEquals(-1,ai.decrementAndGet());
177 <        assertEquals(-2,ai.decrementAndGet());
178 <        assertEquals(-2,ai.get());
175 >        assertEquals(0, ai.decrementAndGet());
176 >        assertEquals(-1, ai.decrementAndGet());
177 >        assertEquals(-2, ai.decrementAndGet());
178 >        assertEquals(-2, ai.get());
179      }
180  
181      /**
# Line 181 | Line 183 | public class AtomicLongTest extends JSR1
183       */
184      public void testIncrementAndGet() {
185          AtomicLong ai = new AtomicLong(1);
186 <        assertEquals(2,ai.incrementAndGet());
187 <        assertEquals(2,ai.get());
186 >        assertEquals(2, ai.incrementAndGet());
187 >        assertEquals(2, ai.get());
188          ai.set(-2);
189 <        assertEquals(-1,ai.incrementAndGet());
190 <        assertEquals(0,ai.incrementAndGet());
191 <        assertEquals(1,ai.incrementAndGet());
192 <        assertEquals(1,ai.get());
189 >        assertEquals(-1, ai.incrementAndGet());
190 >        assertEquals(0, ai.incrementAndGet());
191 >        assertEquals(1, ai.incrementAndGet());
192 >        assertEquals(1, ai.get());
193      }
194  
195      /**
# Line 196 | Line 198 | public class AtomicLongTest extends JSR1
198      public void testSerialization() throws Exception {
199          AtomicLong x = new AtomicLong();
200          AtomicLong y = serialClone(x);
201 <        assertTrue(x != y);
201 >        assertNotSame(x, y);
202          x.set(-22);
203          AtomicLong z = serialClone(x);
204 +        assertNotSame(y, z);
205          assertEquals(-22, x.get());
206          assertEquals(0, y.get());
207          assertEquals(-22, z.get());
# Line 210 | Line 213 | public class AtomicLongTest extends JSR1
213      public void testToString() {
214          AtomicLong ai = new AtomicLong();
215          assertEquals("0", ai.toString());
216 <        for (long i : VALUES) {
217 <            ai.set(i);
218 <            assertEquals(ai.toString(), Long.toString(i));
216 >        for (long x : VALUES) {
217 >            ai.set(x);
218 >            assertEquals(Long.toString(x), ai.toString());
219          }
220      }
221  
# Line 264 | Line 267 | public class AtomicLongTest extends JSR1
267          }
268      }
269  
270 +    // jdk9
271 +
272 +    /**
273 +     * getPlain returns the last value set
274 +     */
275 +    public void testGetPlainSet() {
276 +        AtomicLong ai = new AtomicLong(1);
277 +        assertEquals(1, ai.getPlain());
278 +        ai.set(2);
279 +        assertEquals(2, ai.getPlain());
280 +        ai.set(-3);
281 +        assertEquals(-3, ai.getPlain());
282 +    }
283 +
284 +    /**
285 +     * getOpaque returns the last value set
286 +     */
287 +    public void testGetOpaqueSet() {
288 +        AtomicLong ai = new AtomicLong(1);
289 +        assertEquals(1, ai.getOpaque());
290 +        ai.set(2);
291 +        assertEquals(2, ai.getOpaque());
292 +        ai.set(-3);
293 +        assertEquals(-3, ai.getOpaque());
294 +    }
295 +
296 +    /**
297 +     * getAcquire returns the last value set
298 +     */
299 +    public void testGetAcquireSet() {
300 +        AtomicLong ai = new AtomicLong(1);
301 +        assertEquals(1, ai.getAcquire());
302 +        ai.set(2);
303 +        assertEquals(2, ai.getAcquire());
304 +        ai.set(-3);
305 +        assertEquals(-3, ai.getAcquire());
306 +    }
307 +
308 +    /**
309 +     * get returns the last value setPlain
310 +     */
311 +    public void testGetSetPlain() {
312 +        AtomicLong ai = new AtomicLong(1);
313 +        assertEquals(1, ai.get());
314 +        ai.setPlain(2);
315 +        assertEquals(2, ai.get());
316 +        ai.setPlain(-3);
317 +        assertEquals(-3, ai.get());
318 +    }
319 +
320 +    /**
321 +     * get returns the last value setOpaque
322 +     */
323 +    public void testGetSetOpaque() {
324 +        AtomicLong ai = new AtomicLong(1);
325 +        assertEquals(1, ai.get());
326 +        ai.setOpaque(2);
327 +        assertEquals(2, ai.get());
328 +        ai.setOpaque(-3);
329 +        assertEquals(-3, ai.get());
330 +    }
331 +
332 +    /**
333 +     * get returns the last value setRelease
334 +     */
335 +    public void testGetSetRelease() {
336 +        AtomicLong ai = new AtomicLong(1);
337 +        assertEquals(1, ai.get());
338 +        ai.setRelease(2);
339 +        assertEquals(2, ai.get());
340 +        ai.setRelease(-3);
341 +        assertEquals(-3, ai.get());
342 +    }
343 +
344 +    /**
345 +     * compareAndExchange succeeds in changing value if equal to
346 +     * expected else fails
347 +     */
348 +    public void testCompareAndExchange() {
349 +        AtomicLong ai = new AtomicLong(1);
350 +        assertEquals(1, ai.compareAndExchange(1, 2));
351 +        assertEquals(2, ai.compareAndExchange(2, -4));
352 +        assertEquals(-4, ai.get());
353 +        assertEquals(-4, ai.compareAndExchange(-5, 7));
354 +        assertEquals(-4, ai.get());
355 +        assertEquals(-4, ai.compareAndExchange(-4, 7));
356 +        assertEquals(7, ai.get());
357 +    }
358 +
359 +    /**
360 +     * compareAndExchangeAcquire succeeds in changing value if equal to
361 +     * expected else fails
362 +     */
363 +    public void testCompareAndExchangeAcquire() {
364 +        AtomicLong ai = new AtomicLong(1);
365 +        assertEquals(1, ai.compareAndExchangeAcquire(1, 2));
366 +        assertEquals(2, ai.compareAndExchangeAcquire(2, -4));
367 +        assertEquals(-4, ai.get());
368 +        assertEquals(-4, ai.compareAndExchangeAcquire(-5, 7));
369 +        assertEquals(-4, ai.get());
370 +        assertEquals(-4, ai.compareAndExchangeAcquire(-4, 7));
371 +        assertEquals(7, ai.get());
372 +    }
373 +
374 +    /**
375 +     * compareAndExchangeRelease succeeds in changing value if equal to
376 +     * expected else fails
377 +     */
378 +    public void testCompareAndExchangeRelease() {
379 +        AtomicLong ai = new AtomicLong(1);
380 +        assertEquals(1, ai.compareAndExchangeRelease(1, 2));
381 +        assertEquals(2, ai.compareAndExchangeRelease(2, -4));
382 +        assertEquals(-4, ai.get());
383 +        assertEquals(-4, ai.compareAndExchangeRelease(-5, 7));
384 +        assertEquals(-4, ai.get());
385 +        assertEquals(-4, ai.compareAndExchangeRelease(-4, 7));
386 +        assertEquals(7, ai.get());
387 +    }
388 +
389 +    /**
390 +     * repeated weakCompareAndSetVolatile succeeds in changing value when equal
391 +     * to expected
392 +     */
393 +    public void testWeakCompareAndSetVolatile() {
394 +        AtomicLong ai = new AtomicLong(1);
395 +        do {} while (!ai.weakCompareAndSetVolatile(1, 2));
396 +        do {} while (!ai.weakCompareAndSetVolatile(2, -4));
397 +        assertEquals(-4, ai.get());
398 +        do {} while (!ai.weakCompareAndSetVolatile(-4, 7));
399 +        assertEquals(7, ai.get());
400 +    }
401 +
402 +    /**
403 +     * repeated weakCompareAndSetAcquire succeeds in changing value when equal
404 +     * to expected
405 +     */
406 +    public void testWeakCompareAndSetAcquire() {
407 +        AtomicLong ai = new AtomicLong(1);
408 +        do {} while (!ai.weakCompareAndSetAcquire(1, 2));
409 +        do {} while (!ai.weakCompareAndSetAcquire(2, -4));
410 +        assertEquals(-4, ai.get());
411 +        do {} while (!ai.weakCompareAndSetAcquire(-4, 7));
412 +        assertEquals(7, ai.get());
413 +    }
414 +
415 +    /**
416 +     * repeated weakCompareAndSetRelease succeeds in changing value when equal
417 +     * to expected
418 +     */
419 +    public void testWeakCompareAndSetRelease() {
420 +        AtomicLong ai = new AtomicLong(1);
421 +        do {} while (!ai.weakCompareAndSetRelease(1, 2));
422 +        do {} while (!ai.weakCompareAndSetRelease(2, -4));
423 +        assertEquals(-4, ai.get());
424 +        do {} while (!ai.weakCompareAndSetRelease(-4, 7));
425 +        assertEquals(7, ai.get());
426 +    }
427 +
428   }

Diff Legend

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