test/tck/AtomicReference9Test.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

import java.util.concurrent.atomic.AtomicReference;

import junit.framework.Test;
import junit.framework.TestSuite;

public class AtomicReference9Test extends JSR166TestCase {
    public static void main(String[] args) {
        main(suite(), args);
    }
    public static Test suite() {
        return new TestSuite(AtomicReference9Test.class);
    }

    /**
     * getPlain returns the last value set
     */
    public void testGetPlainSet() {
        AtomicReference<Integer> ai = new AtomicReference<>(one);
        assertEquals(one, ai.getPlain());
        ai.set(two);
        assertEquals(two, ai.getPlain());
        ai.set(m3);
        assertEquals(m3, ai.getPlain());
    }

    /**
     * getOpaque returns the last value set
     */
    public void testGetOpaqueSet() {
        AtomicReference<Integer> ai = new AtomicReference<>(one);
        assertEquals(one, ai.getOpaque());
        ai.set(two);
        assertEquals(two, ai.getOpaque());
        ai.set(m3);
        assertEquals(m3, ai.getOpaque());
    }

    /**
     * getAcquire returns the last value set
     */
    public void testGetAcquireSet() {
        AtomicReference<Integer> ai = new AtomicReference<>(one);
        assertEquals(one, ai.getAcquire());
        ai.set(two);
        assertEquals(two, ai.getAcquire());
        ai.set(m3);
        assertEquals(m3, ai.getAcquire());
    }

    /**
     * get returns the last value setPlain
     */
    public void testGetSetPlain() {
        AtomicReference<Integer> ai = new AtomicReference<>(one);
        assertEquals(one, ai.get());
        ai.setPlain(two);
        assertEquals(two, ai.get());
        ai.setPlain(m3);
        assertEquals(m3, ai.get());
    }

    /**
     * get returns the last value setOpaque
     */
    public void testGetSetOpaque() {
        AtomicReference<Integer> ai = new AtomicReference<>(one);
        assertEquals(one, ai.get());
        ai.setOpaque(two);
        assertEquals(two, ai.get());
        ai.setOpaque(m3);
        assertEquals(m3, ai.get());
    }

    /**
     * get returns the last value setRelease
     */
    public void testGetSetRelease() {
        AtomicReference<Integer> ai = new AtomicReference<>(one);
        assertEquals(one, ai.get());
        ai.setRelease(two);
        assertEquals(two, ai.get());
        ai.setRelease(m3);
        assertEquals(m3, ai.get());
    }

    /**
     * compareAndExchange succeeds in changing value if equal to
     * expected else fails
     */
    public void testCompareAndExchange() {
        AtomicReference<Integer> ai = new AtomicReference<>(one);
        assertEquals(one, ai.compareAndExchange(one, two));
        assertEquals(two, ai.compareAndExchange(two, m4));
        assertEquals(m4, ai.get());
        assertEquals(m4, ai.compareAndExchange(m5, seven));
        assertEquals(m4, ai.get());
        assertEquals(m4, ai.compareAndExchange(m4, seven));
        assertEquals(seven, ai.get());
    }

    /**
     * compareAndExchangeAcquire succeeds in changing value if equal to
     * expected else fails
     */
    public void testCompareAndExchangeAcquire() {
        AtomicReference<Integer> ai = new AtomicReference<>(one);
        assertEquals(one, ai.compareAndExchangeAcquire(one, two));
        assertEquals(two, ai.compareAndExchangeAcquire(two, m4));
        assertEquals(m4, ai.get());
        assertEquals(m4, ai.compareAndExchangeAcquire(m5, seven));
        assertEquals(m4, ai.get());
        assertEquals(m4, ai.compareAndExchangeAcquire(m4, seven));
        assertEquals(seven, ai.get());
    }

    /**
     * compareAndExchangeRelease succeeds in changing value if equal to
     * expected else fails
     */
    public void testCompareAndExchangeRelease() {
        AtomicReference<Integer> ai = new AtomicReference<>(one);
        assertEquals(one, ai.compareAndExchangeRelease(one, two));
        assertEquals(two, ai.compareAndExchangeRelease(two, m4));
        assertEquals(m4, ai.get());
        assertEquals(m4, ai.compareAndExchangeRelease(m5, seven));
        assertEquals(m4, ai.get());
        assertEquals(m4, ai.compareAndExchangeRelease(m4, seven));
        assertEquals(seven, ai.get());
    }

    /**
     * repeated weakCompareAndSetPlain succeeds in changing value when equal
     * to expected
     */
    public void testWeakCompareAndSetPlain() {
        AtomicReference<Integer> ai = new AtomicReference<>(one);
        do {} while (!ai.weakCompareAndSetPlain(one, two));
        do {} while (!ai.weakCompareAndSetPlain(two, m4));
        assertEquals(m4, ai.get());
        do {} while (!ai.weakCompareAndSetPlain(m4, seven));
        assertEquals(seven, ai.get());
    }

    /**
     * repeated weakCompareAndSetVolatile succeeds in changing value when equal
     * to expected
     */
    public void testWeakCompareAndSetVolatile() {
        AtomicReference<Integer> ai = new AtomicReference<>(one);
        do {} while (!ai.weakCompareAndSetVolatile(one, two));
        do {} while (!ai.weakCompareAndSetVolatile(two, m4));
        assertEquals(m4, ai.get());
        do {} while (!ai.weakCompareAndSetVolatile(m4, seven));
        assertEquals(seven, ai.get());
    }

    /**
     * repeated weakCompareAndSetAcquire succeeds in changing value when equal
     * to expected
     */
    public void testWeakCompareAndSetAcquire() {
        AtomicReference<Integer> ai = new AtomicReference<>(one);
        do {} while (!ai.weakCompareAndSetAcquire(one, two));
        do {} while (!ai.weakCompareAndSetAcquire(two, m4));
        assertEquals(m4, ai.get());
        do {} while (!ai.weakCompareAndSetAcquire(m4, seven));
        assertEquals(seven, ai.get());
    }

    /**
     * repeated weakCompareAndSetRelease succeeds in changing value when equal
     * to expected
     */
    public void testWeakCompareAndSetRelease() {
        AtomicReference<Integer> ai = new AtomicReference<>(one);
        do {} while (!ai.weakCompareAndSetRelease(one, two));
        do {} while (!ai.weakCompareAndSetRelease(two, m4));
        assertEquals(m4, ai.get());
        do {} while (!ai.weakCompareAndSetRelease(m4, seven));
        assertEquals(seven, ai.get());
    }

}
Revision:	1.2
Committed:	Tue Oct 11 20:38:07 2016 UTC (7 years, 7 months ago) by jsr166
Branch:	MAIN
Changes since 1.1:	+13 -0 lines
Log Message:	sync with openjdk9
#	User	Rev	Content
1	jsr166	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/publicdomain/zero/1.0/
5			*/
6
7			import java.util.concurrent.atomic.AtomicReference;
8
9			import junit.framework.Test;
10			import junit.framework.TestSuite;
11
12			public class AtomicReference9Test extends JSR166TestCase {
13			public static void main(String[] args) {
14			main(suite(), args);
15			}
16			public static Test suite() {
17			return new TestSuite(AtomicReference9Test.class);
18			}
19
20			/**
21			* getPlain returns the last value set
22			*/
23			public void testGetPlainSet() {
24			AtomicReference<Integer> ai = new AtomicReference<>(one);
25			assertEquals(one, ai.getPlain());
26			ai.set(two);
27			assertEquals(two, ai.getPlain());
28			ai.set(m3);
29			assertEquals(m3, ai.getPlain());
30			}
31
32			/**
33			* getOpaque returns the last value set
34			*/
35			public void testGetOpaqueSet() {
36			AtomicReference<Integer> ai = new AtomicReference<>(one);
37			assertEquals(one, ai.getOpaque());
38			ai.set(two);
39			assertEquals(two, ai.getOpaque());
40			ai.set(m3);
41			assertEquals(m3, ai.getOpaque());
42			}
43
44			/**
45			* getAcquire returns the last value set
46			*/
47			public void testGetAcquireSet() {
48			AtomicReference<Integer> ai = new AtomicReference<>(one);
49			assertEquals(one, ai.getAcquire());
50			ai.set(two);
51			assertEquals(two, ai.getAcquire());
52			ai.set(m3);
53			assertEquals(m3, ai.getAcquire());
54			}
55
56			/**
57			* get returns the last value setPlain
58			*/
59			public void testGetSetPlain() {
60			AtomicReference<Integer> ai = new AtomicReference<>(one);
61			assertEquals(one, ai.get());
62			ai.setPlain(two);
63			assertEquals(two, ai.get());
64			ai.setPlain(m3);
65			assertEquals(m3, ai.get());
66			}
67
68			/**
69			* get returns the last value setOpaque
70			*/
71			public void testGetSetOpaque() {
72			AtomicReference<Integer> ai = new AtomicReference<>(one);
73			assertEquals(one, ai.get());
74			ai.setOpaque(two);
75			assertEquals(two, ai.get());
76			ai.setOpaque(m3);
77			assertEquals(m3, ai.get());
78			}
79
80			/**
81			* get returns the last value setRelease
82			*/
83			public void testGetSetRelease() {
84			AtomicReference<Integer> ai = new AtomicReference<>(one);
85			assertEquals(one, ai.get());
86			ai.setRelease(two);
87			assertEquals(two, ai.get());
88			ai.setRelease(m3);
89			assertEquals(m3, ai.get());
90			}
91
92			/**
93			* compareAndExchange succeeds in changing value if equal to
94			* expected else fails
95			*/
96			public void testCompareAndExchange() {
97			AtomicReference<Integer> ai = new AtomicReference<>(one);
98			assertEquals(one, ai.compareAndExchange(one, two));
99			assertEquals(two, ai.compareAndExchange(two, m4));
100			assertEquals(m4, ai.get());
101			assertEquals(m4, ai.compareAndExchange(m5, seven));
102			assertEquals(m4, ai.get());
103			assertEquals(m4, ai.compareAndExchange(m4, seven));
104			assertEquals(seven, ai.get());
105			}
106
107			/**
108			* compareAndExchangeAcquire succeeds in changing value if equal to
109			* expected else fails
110			*/
111			public void testCompareAndExchangeAcquire() {
112			AtomicReference<Integer> ai = new AtomicReference<>(one);
113			assertEquals(one, ai.compareAndExchangeAcquire(one, two));
114			assertEquals(two, ai.compareAndExchangeAcquire(two, m4));
115			assertEquals(m4, ai.get());
116			assertEquals(m4, ai.compareAndExchangeAcquire(m5, seven));
117			assertEquals(m4, ai.get());
118			assertEquals(m4, ai.compareAndExchangeAcquire(m4, seven));
119			assertEquals(seven, ai.get());
120			}
121
122			/**
123			* compareAndExchangeRelease succeeds in changing value if equal to
124			* expected else fails
125			*/
126			public void testCompareAndExchangeRelease() {
127			AtomicReference<Integer> ai = new AtomicReference<>(one);
128			assertEquals(one, ai.compareAndExchangeRelease(one, two));
129			assertEquals(two, ai.compareAndExchangeRelease(two, m4));
130			assertEquals(m4, ai.get());
131			assertEquals(m4, ai.compareAndExchangeRelease(m5, seven));
132			assertEquals(m4, ai.get());
133			assertEquals(m4, ai.compareAndExchangeRelease(m4, seven));
134			assertEquals(seven, ai.get());
135			}
136
137			/**
138	jsr166	1.2	* repeated weakCompareAndSetPlain succeeds in changing value when equal
139			* to expected
140			*/
141			public void testWeakCompareAndSetPlain() {
142			AtomicReference<Integer> ai = new AtomicReference<>(one);
143			do {} while (!ai.weakCompareAndSetPlain(one, two));
144			do {} while (!ai.weakCompareAndSetPlain(two, m4));
145			assertEquals(m4, ai.get());
146			do {} while (!ai.weakCompareAndSetPlain(m4, seven));
147			assertEquals(seven, ai.get());
148			}
149
150			/**
151	jsr166	1.1	* repeated weakCompareAndSetVolatile succeeds in changing value when equal
152			* to expected
153			*/
154			public void testWeakCompareAndSetVolatile() {
155			AtomicReference<Integer> ai = new AtomicReference<>(one);
156			do {} while (!ai.weakCompareAndSetVolatile(one, two));
157			do {} while (!ai.weakCompareAndSetVolatile(two, m4));
158			assertEquals(m4, ai.get());
159			do {} while (!ai.weakCompareAndSetVolatile(m4, seven));
160			assertEquals(seven, ai.get());
161			}
162
163			/**
164			* repeated weakCompareAndSetAcquire succeeds in changing value when equal
165			* to expected
166			*/
167			public void testWeakCompareAndSetAcquire() {
168			AtomicReference<Integer> ai = new AtomicReference<>(one);
169			do {} while (!ai.weakCompareAndSetAcquire(one, two));
170			do {} while (!ai.weakCompareAndSetAcquire(two, m4));
171			assertEquals(m4, ai.get());
172			do {} while (!ai.weakCompareAndSetAcquire(m4, seven));
173			assertEquals(seven, ai.get());
174			}
175
176			/**
177			* repeated weakCompareAndSetRelease succeeds in changing value when equal
178			* to expected
179			*/
180			public void testWeakCompareAndSetRelease() {
181			AtomicReference<Integer> ai = new AtomicReference<>(one);
182			do {} while (!ai.weakCompareAndSetRelease(one, two));
183			do {} while (!ai.weakCompareAndSetRelease(two, m4));
184			assertEquals(m4, ai.get());
185			do {} while (!ai.weakCompareAndSetRelease(m4, seven));
186			assertEquals(seven, ai.get());
187			}
188
189			}