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.25 by dl, Thu Jun 16 23:35:25 2016 UTC vs.
Revision 1.31 by jsr166, Wed Jan 27 01:57:24 2021 UTC

# Line 23 | Line 23 | public class AtomicReferenceTest extends
23       * constructor initializes to given value
24       */
25      public void testConstructor() {
26 <        AtomicReference ai = new AtomicReference(one);
26 >        AtomicReference<Item> ai = new AtomicReference<>(one);
27          assertSame(one, ai.get());
28      }
29  
# Line 31 | Line 31 | public class AtomicReferenceTest extends
31       * default constructed initializes to null
32       */
33      public void testConstructor2() {
34 <        AtomicReference ai = new AtomicReference();
34 >        AtomicReference<Item> ai = new AtomicReference<>();
35          assertNull(ai.get());
36      }
37  
# Line 39 | Line 39 | public class AtomicReferenceTest extends
39       * get returns the last value set
40       */
41      public void testGetSet() {
42 <        AtomicReference ai = new AtomicReference(one);
42 >        AtomicReference<Item> ai = new AtomicReference<>(one);
43          assertSame(one, ai.get());
44          ai.set(two);
45          assertSame(two, ai.get());
46 <        ai.set(m3);
47 <        assertSame(m3, 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);
54 >        AtomicReference<Item> ai = new AtomicReference<>(one);
55          assertSame(one, ai.get());
56          ai.lazySet(two);
57          assertSame(two, ai.get());
58 <        ai.lazySet(m3);
59 <        assertSame(m3, 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);
66 >        AtomicReference<Item> 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));
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  
# Line 78 | 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<>(one);
82          Thread t = new Thread(new CheckedRunnable() {
83              public void realRun() {
84                  while (!ai.compareAndSet(two, three))
# Line 96 | Line 96 | public class AtomicReferenceTest extends
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);
101 >        AtomicReference<Item> ai = new AtomicReference<>(one);
102          do {} while (!ai.weakCompareAndSet(one, two));
103 <        do {} while (!ai.weakCompareAndSet(two, m4));
104 <        assertSame(m4, ai.get());
105 <        do {} while (!ai.weakCompareAndSet(m4, seven));
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  
# Line 109 | Line 110 | public class AtomicReferenceTest extends
110       * getAndSet returns previous value and sets to given value
111       */
112      public void testGetAndSet() {
113 <        AtomicReference ai = new AtomicReference(one);
113 >        AtomicReference<Item> ai = new AtomicReference<>(one);
114          assertSame(one, ai.getAndSet(zero));
115 <        assertSame(zero, ai.getAndSet(m10));
116 <        assertSame(m10, ai.getAndSet(one));
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);
123 >        AtomicReference<Item> x = new AtomicReference<>();
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 134 | Line 135 | public class AtomicReferenceTest extends
135       * toString returns current value.
136       */
137      public void testToString() {
138 <        AtomicReference<Integer> ai = new AtomicReference<Integer>(one);
138 >        AtomicReference<Item> ai = new AtomicReference<>(one);
139          assertEquals(one.toString(), ai.toString());
140          ai.set(two);
141          assertEquals(two.toString(), ai.toString());
142      }
143  
143 –    // jdk9
144 –    
145 –    /**
146 –     * getPlain returns the last value set
147 –     */
148 –    public void testGetPlainSet() {
149 –        AtomicReference<Integer> ai = new AtomicReference<Integer>(one);
150 –        assertEquals(one, ai.getPlain());
151 –        ai.set(two);
152 –        assertEquals(two, ai.getPlain());
153 –        ai.set(m3);
154 –        assertEquals(m3, ai.getPlain());
155 –    }
156 –
157 –    /**
158 –     * getOpaque returns the last value set
159 –     */
160 –    public void testGetOpaqueSet() {
161 –        AtomicReference<Integer> ai = new AtomicReference<Integer>(one);
162 –        assertEquals(one, ai.getOpaque());
163 –        ai.set(two);
164 –        assertEquals(two, ai.getOpaque());
165 –        ai.set(m3);
166 –        assertEquals(m3, ai.getOpaque());
167 –    }
168 –
169 –    /**
170 –     * getAcquire returns the last value set
171 –     */
172 –    public void testGetAcquireSet() {
173 –        AtomicReference<Integer> ai = new AtomicReference<Integer>(one);
174 –        assertEquals(one, ai.getAcquire());
175 –        ai.set(two);
176 –        assertEquals(two, ai.getAcquire());
177 –        ai.set(m3);
178 –        assertEquals(m3, ai.getAcquire());
179 –    }
180 –    
181 –    /**
182 –     * get returns the last value setPlain
183 –     */
184 –    public void testGetSetPlain() {
185 –        AtomicReference<Integer> ai = new AtomicReference<Integer>(one);
186 –        assertEquals(one, ai.get());
187 –        ai.setPlain(two);
188 –        assertEquals(two, ai.get());
189 –        ai.setPlain(m3);
190 –        assertEquals(m3, ai.get());
191 –    }
192 –
193 –    /**
194 –     * get returns the last value setOpaque
195 –     */
196 –    public void testGetSetOpaque() {
197 –        AtomicReference<Integer> ai = new AtomicReference<Integer>(one);
198 –        assertEquals(one, ai.get());
199 –        ai.setOpaque(two);
200 –        assertEquals(two, ai.get());
201 –        ai.setOpaque(m3);
202 –        assertEquals(m3, ai.get());
203 –    }
204 –
205 –    /**
206 –     * get returns the last value setRelease
207 –     */
208 –    public void testGetSetRelease() {
209 –        AtomicReference<Integer> ai = new AtomicReference<Integer>(one);
210 –        assertEquals(one, ai.get());
211 –        ai.setRelease(two);
212 –        assertEquals(two, ai.get());
213 –        ai.setRelease(m3);
214 –        assertEquals(m3, ai.get());
215 –    }
216 –    
217 –    /**
218 –     * compareAndExchange succeeds in changing value if equal to
219 –     * expected else fails
220 –     */
221 –    public void testCompareAndExchange() {
222 –        AtomicReference<Integer> ai = new AtomicReference<Integer>(one);
223 –        assertEquals(one, ai.compareAndExchange(one, two));
224 –        assertEquals(two, ai.compareAndExchange(two, m4));
225 –        assertEquals(m4, ai.get());
226 –        assertEquals(m4, ai.compareAndExchange(m5, seven));
227 –        assertEquals(m4, ai.get());
228 –        assertEquals(m4, ai.compareAndExchange(m4, seven));
229 –        assertEquals(seven, ai.get());
230 –    }
231 –
232 –    /**
233 –     * compareAndExchangeAcquire succeeds in changing value if equal to
234 –     * expected else fails
235 –     */
236 –    public void testCompareAndExchangeAcquire() {
237 –        AtomicReference<Integer> ai = new AtomicReference<Integer>(one);
238 –        assertEquals(one, ai.compareAndExchangeAcquire(one, two));
239 –        assertEquals(two, ai.compareAndExchangeAcquire(two, m4));
240 –        assertEquals(m4, ai.get());
241 –        assertEquals(m4, ai.compareAndExchangeAcquire(m5, seven));
242 –        assertEquals(m4, ai.get());
243 –        assertEquals(m4, ai.compareAndExchangeAcquire(m4, seven));
244 –        assertEquals(seven, ai.get());
245 –    }
246 –
247 –    /**
248 –     * compareAndExchangeRelease succeeds in changing value if equal to
249 –     * expected else fails
250 –     */
251 –    public void testCompareAndExchangeRelease() {
252 –        AtomicReference<Integer> ai = new AtomicReference<Integer>(one);
253 –        assertEquals(one, ai.compareAndExchangeRelease(one, two));
254 –        assertEquals(two, ai.compareAndExchangeRelease(two, m4));
255 –        assertEquals(m4, ai.get());
256 –        assertEquals(m4, ai.compareAndExchangeRelease(m5, seven));
257 –        assertEquals(m4, ai.get());
258 –        assertEquals(m4, ai.compareAndExchangeRelease(m4, seven));
259 –        assertEquals(seven, ai.get());
260 –    }
261 –
262 –    /**
263 –     * repeated weakCompareAndSetVolatile succeeds in changing value when equal
264 –     * to expected
265 –     */
266 –    public void testWeakCompareAndSetVolatile() {
267 –        AtomicReference<Integer> ai = new AtomicReference<Integer>(one);
268 –        do {} while (!ai.weakCompareAndSetVolatile(one, two));
269 –        do {} while (!ai.weakCompareAndSetVolatile(two, m4));
270 –        assertEquals(m4, ai.get());
271 –        do {} while (!ai.weakCompareAndSetVolatile(m4, seven));
272 –        assertEquals(seven, ai.get());
273 –    }
274 –
275 –    /**
276 –     * repeated weakCompareAndSetAcquire succeeds in changing value when equal
277 –     * to expected
278 –     */
279 –    public void testWeakCompareAndSetAcquire() {
280 –        AtomicReference<Integer> ai = new AtomicReference<Integer>(one);
281 –        do {} while (!ai.weakCompareAndSetAcquire(one, two));
282 –        do {} while (!ai.weakCompareAndSetAcquire(two, m4));
283 –        assertEquals(m4, ai.get());
284 –        do {} while (!ai.weakCompareAndSetAcquire(m4, seven));
285 –        assertEquals(seven, ai.get());
286 –    }
287 –
288 –    /**
289 –     * repeated weakCompareAndSetRelease succeeds in changing value when equal
290 –     * to expected
291 –     */
292 –    public void testWeakCompareAndSetRelease() {
293 –        AtomicReference<Integer> ai = new AtomicReference<Integer>(one);
294 –        do {} while (!ai.weakCompareAndSetRelease(one, two));
295 –        do {} while (!ai.weakCompareAndSetRelease(two, m4));
296 –        assertEquals(m4, ai.get());
297 –        do {} while (!ai.weakCompareAndSetRelease(m4, seven));
298 –        assertEquals(seven, ai.get());
299 –    }
300 –    
301 –    
302 –    
144   }

Diff Legend

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