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.24 by jsr166, Sat Apr 25 04:55:30 2015 UTC vs.
Revision 1.25 by dl, Thu Jun 16 23:35:25 2016 UTC

# Line 140 | Line 140 | public class AtomicReferenceTest extends
140          assertEquals(two.toString(), ai.toString());
141      }
142  
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 +    
303   }

Diff Legend

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