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

Comparing jsr166/src/test/tck/AtomicReferenceTest.java (file contents):
Revision 1.18 by jsr166, Tue May 31 16:16:23 2011 UTC vs.
Revision 1.30 by dl, Tue Jan 26 13:33:05 2021 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import junit.framework.*;
9   import java.util.concurrent.atomic.AtomicReference;
10  
11 + import junit.framework.Test;
12 + import junit.framework.TestSuite;
13 +
14   public class AtomicReferenceTest 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(AtomicReferenceTest.class);
# Line 21 | Line 23 | public class AtomicReferenceTest extends
23       * constructor initializes to given value
24       */
25      public void testConstructor() {
26 <        AtomicReference ai = new AtomicReference(one);
27 <        assertSame(one,ai.get());
26 >        AtomicReference<Item> ai = new AtomicReference<Item>(one);
27 >        assertSame(one, ai.get());
28      }
29  
30      /**
31       * default constructed initializes to null
32       */
33      public void testConstructor2() {
34 <        AtomicReference ai = new AtomicReference();
34 >        AtomicReference<Item> ai = new AtomicReference<Item>();
35          assertNull(ai.get());
36      }
37  
# Line 37 | Line 39 | public class AtomicReferenceTest extends
39       * get returns the last value set
40       */
41      public void testGetSet() {
42 <        AtomicReference ai = new AtomicReference(one);
43 <        assertSame(one,ai.get());
42 >        AtomicReference<Item> ai = new AtomicReference<Item>(one);
43 >        assertSame(one, ai.get());
44          ai.set(two);
45 <        assertSame(two,ai.get());
46 <        ai.set(m3);
47 <        assertSame(m3,ai.get());
45 >        assertSame(two, ai.get());
46 >        ai.set(minusThree);
47 >        assertSame(minusThree, ai.get());
48      }
49  
50      /**
51       * get returns the last value lazySet in same thread
52       */
53      public void testGetLazySet() {
54 <        AtomicReference ai = new AtomicReference(one);
55 <        assertSame(one,ai.get());
54 >        AtomicReference<Item> ai = new AtomicReference<Item>(one);
55 >        assertSame(one, ai.get());
56          ai.lazySet(two);
57 <        assertSame(two,ai.get());
58 <        ai.lazySet(m3);
59 <        assertSame(m3,ai.get());
57 >        assertSame(two, ai.get());
58 >        ai.lazySet(minusThree);
59 >        assertSame(minusThree, ai.get());
60      }
61  
62      /**
63       * compareAndSet succeeds in changing value if equal to expected else fails
64       */
65      public void testCompareAndSet() {
66 <        AtomicReference ai = new AtomicReference(one);
67 <        assertTrue(ai.compareAndSet(one,two));
68 <        assertTrue(ai.compareAndSet(two,m4));
69 <        assertSame(m4,ai.get());
70 <        assertFalse(ai.compareAndSet(m5,seven));
71 <        assertSame(m4,ai.get());
72 <        assertTrue(ai.compareAndSet(m4,seven));
73 <        assertSame(seven,ai.get());
66 >        AtomicReference<Item> ai = new AtomicReference<Item>(one);
67 >        assertTrue(ai.compareAndSet(one, two));
68 >        assertTrue(ai.compareAndSet(two, minusFour));
69 >        assertSame(minusFour, ai.get());
70 >        assertFalse(ai.compareAndSet(minusFive, seven));
71 >        assertSame(minusFour, ai.get());
72 >        assertTrue(ai.compareAndSet(minusFour, seven));
73 >        assertSame(seven, ai.get());
74      }
75  
76      /**
# Line 76 | Line 78 | public class AtomicReferenceTest extends
78       * to succeed
79       */
80      public void testCompareAndSetInMultipleThreads() throws Exception {
81 <        final AtomicReference ai = new AtomicReference(one);
81 >        final AtomicReference<Item> ai = new AtomicReference<Item>(one);
82          Thread t = new Thread(new CheckedRunnable() {
83              public void realRun() {
84                  while (!ai.compareAndSet(two, three))
# Line 87 | Line 89 | public class AtomicReferenceTest extends
89          assertTrue(ai.compareAndSet(one, two));
90          t.join(LONG_DELAY_MS);
91          assertFalse(t.isAlive());
92 <        assertSame(ai.get(), three);
92 >        assertSame(three, ai.get());
93      }
94  
95      /**
96       * repeated weakCompareAndSet succeeds in changing value when equal
97       * to expected
98       */
99 +    @SuppressWarnings("deprecation")
100      public void testWeakCompareAndSet() {
101 <        AtomicReference ai = new AtomicReference(one);
102 <        while (!ai.weakCompareAndSet(one,two));
103 <        while (!ai.weakCompareAndSet(two,m4));
104 <        assertSame(m4,ai.get());
105 <        while (!ai.weakCompareAndSet(m4,seven));
106 <        assertSame(seven,ai.get());
101 >        AtomicReference<Item> ai = new AtomicReference<Item>(one);
102 >        do {} while (!ai.weakCompareAndSet(one, two));
103 >        do {} while (!ai.weakCompareAndSet(two, minusFour));
104 >        assertSame(minusFour, ai.get());
105 >        do {} while (!ai.weakCompareAndSet(minusFour, seven));
106 >        assertSame(seven, ai.get());
107      }
108  
109      /**
110       * getAndSet returns previous value and sets to given value
111       */
112      public void testGetAndSet() {
113 <        AtomicReference ai = new AtomicReference(one);
114 <        assertSame(one,ai.getAndSet(zero));
115 <        assertSame(zero,ai.getAndSet(m10));
116 <        assertSame(m10,ai.getAndSet(one));
113 >        AtomicReference<Item> ai = new AtomicReference<Item>(one);
114 >        assertSame(one, ai.getAndSet(zero));
115 >        assertSame(zero, ai.getAndSet(minusTen));
116 >        assertSame(minusTen, ai.getAndSet(one));
117      }
118  
119      /**
120 <     * a deserialized serialized atomic holds same value
120 >     * a deserialized/reserialized atomic holds same value
121       */
122      public void testSerialization() throws Exception {
123 <        AtomicReference x = new AtomicReference();
124 <        AtomicReference y = serialClone(x);
125 <        assertTrue(x != y);
123 >        AtomicReference<Item> x = new AtomicReference<Item>();
124 >        AtomicReference<Item> y = serialClone(x);
125 >        assertNotSame(x, y);
126          x.set(one);
127 <        AtomicReference z = serialClone(x);
127 >        AtomicReference<Item> z = serialClone(x);
128 >        assertNotSame(y, z);
129          assertEquals(one, x.get());
130 <        assertEquals(null, y.get());
130 >        assertNull(y.get());
131          assertEquals(one, z.get());
132      }
133  
# Line 131 | Line 135 | public class AtomicReferenceTest extends
135       * toString returns current value.
136       */
137      public void testToString() {
138 <        AtomicReference<Integer> ai = new AtomicReference<Integer>(one);
139 <        assertEquals(ai.toString(), one.toString());
138 >        AtomicReference<Item> ai = new AtomicReference<Item>(one);
139 >        assertEquals(one.toString(), ai.toString());
140          ai.set(two);
141 <        assertEquals(ai.toString(), two.toString());
141 >        assertEquals(two.toString(), ai.toString());
142      }
143  
144   }

Diff Legend

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