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

Comparing jsr166/src/test/tck/AtomicReference9Test.java (file contents):
Revision 1.2 by jsr166, Tue Oct 11 20:38:07 2016 UTC vs.
Revision 1.3 by dl, Tue Jan 26 13:33:05 2021 UTC

# Line 21 | Line 21 | public class AtomicReference9Test extend
21       * getPlain returns the last value set
22       */
23      public void testGetPlainSet() {
24 <        AtomicReference<Integer> ai = new AtomicReference<>(one);
25 <        assertEquals(one, ai.getPlain());
24 >        AtomicReference<Item> ai = new AtomicReference<>(one);
25 >        mustEqual(one, ai.getPlain());
26          ai.set(two);
27 <        assertEquals(two, ai.getPlain());
28 <        ai.set(m3);
29 <        assertEquals(m3, ai.getPlain());
27 >        mustEqual(two, ai.getPlain());
28 >        ai.set(minusThree);
29 >        mustEqual(minusThree, 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());
36 >        AtomicReference<Item> ai = new AtomicReference<>(one);
37 >        mustEqual(one, ai.getOpaque());
38          ai.set(two);
39 <        assertEquals(two, ai.getOpaque());
40 <        ai.set(m3);
41 <        assertEquals(m3, ai.getOpaque());
39 >        mustEqual(two, ai.getOpaque());
40 >        ai.set(minusThree);
41 >        mustEqual(minusThree, 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());
48 >        AtomicReference<Item> ai = new AtomicReference<>(one);
49 >        mustEqual(one, ai.getAcquire());
50          ai.set(two);
51 <        assertEquals(two, ai.getAcquire());
52 <        ai.set(m3);
53 <        assertEquals(m3, ai.getAcquire());
51 >        mustEqual(two, ai.getAcquire());
52 >        ai.set(minusThree);
53 >        mustEqual(minusThree, 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());
60 >        AtomicReference<Item> ai = new AtomicReference<>(one);
61 >        mustEqual(one, ai.get());
62          ai.setPlain(two);
63 <        assertEquals(two, ai.get());
64 <        ai.setPlain(m3);
65 <        assertEquals(m3, ai.get());
63 >        mustEqual(two, ai.get());
64 >        ai.setPlain(minusThree);
65 >        mustEqual(minusThree, 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());
72 >        AtomicReference<Item> ai = new AtomicReference<>(one);
73 >        mustEqual(one, ai.get());
74          ai.setOpaque(two);
75 <        assertEquals(two, ai.get());
76 <        ai.setOpaque(m3);
77 <        assertEquals(m3, ai.get());
75 >        mustEqual(two, ai.get());
76 >        ai.setOpaque(minusThree);
77 >        mustEqual(minusThree, 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());
84 >        AtomicReference<Item> ai = new AtomicReference<>(one);
85 >        mustEqual(one, ai.get());
86          ai.setRelease(two);
87 <        assertEquals(two, ai.get());
88 <        ai.setRelease(m3);
89 <        assertEquals(m3, ai.get());
87 >        mustEqual(two, ai.get());
88 >        ai.setRelease(minusThree);
89 >        mustEqual(minusThree, ai.get());
90      }
91  
92      /**
# Line 94 | Line 94 | public class AtomicReference9Test extend
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());
97 >        AtomicReference<Item> ai = new AtomicReference<>(one);
98 >        mustEqual(one, ai.compareAndExchange(one, two));
99 >        mustEqual(two, ai.compareAndExchange(two, minusFour));
100 >        mustEqual(minusFour, ai.get());
101 >        mustEqual(minusFour, ai.compareAndExchange(minusFive, seven));
102 >        mustEqual(minusFour, ai.get());
103 >        mustEqual(minusFour, ai.compareAndExchange(minusFour, seven));
104 >        mustEqual(seven, ai.get());
105      }
106  
107      /**
# Line 109 | Line 109 | public class AtomicReference9Test extend
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());
112 >        AtomicReference<Item> ai = new AtomicReference<>(one);
113 >        mustEqual(one, ai.compareAndExchangeAcquire(one, two));
114 >        mustEqual(two, ai.compareAndExchangeAcquire(two, minusFour));
115 >        mustEqual(minusFour, ai.get());
116 >        mustEqual(minusFour, ai.compareAndExchangeAcquire(minusFive, seven));
117 >        mustEqual(minusFour, ai.get());
118 >        mustEqual(minusFour, ai.compareAndExchangeAcquire(minusFour, seven));
119 >        mustEqual(seven, ai.get());
120      }
121  
122      /**
# Line 124 | Line 124 | public class AtomicReference9Test extend
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());
127 >        AtomicReference<Item> ai = new AtomicReference<>(one);
128 >        mustEqual(one, ai.compareAndExchangeRelease(one, two));
129 >        mustEqual(two, ai.compareAndExchangeRelease(two, minusFour));
130 >        mustEqual(minusFour, ai.get());
131 >        mustEqual(minusFour, ai.compareAndExchangeRelease(minusFive, seven));
132 >        mustEqual(minusFour, ai.get());
133 >        mustEqual(minusFour, ai.compareAndExchangeRelease(minusFour, seven));
134 >        mustEqual(seven, ai.get());
135      }
136  
137      /**
# Line 139 | Line 139 | public class AtomicReference9Test extend
139       * to expected
140       */
141      public void testWeakCompareAndSetPlain() {
142 <        AtomicReference<Integer> ai = new AtomicReference<>(one);
142 >        AtomicReference<Item> 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());
144 >        do {} while (!ai.weakCompareAndSetPlain(two, minusFour));
145 >        mustEqual(minusFour, ai.get());
146 >        do {} while (!ai.weakCompareAndSetPlain(minusFour, seven));
147 >        mustEqual(seven, ai.get());
148      }
149  
150      /**
# Line 152 | Line 152 | public class AtomicReference9Test extend
152       * to expected
153       */
154      public void testWeakCompareAndSetVolatile() {
155 <        AtomicReference<Integer> ai = new AtomicReference<>(one);
155 >        AtomicReference<Item> 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());
157 >        do {} while (!ai.weakCompareAndSetVolatile(two, minusFour));
158 >        mustEqual(minusFour, ai.get());
159 >        do {} while (!ai.weakCompareAndSetVolatile(minusFour, seven));
160 >        mustEqual(seven, ai.get());
161      }
162  
163      /**
# Line 165 | Line 165 | public class AtomicReference9Test extend
165       * to expected
166       */
167      public void testWeakCompareAndSetAcquire() {
168 <        AtomicReference<Integer> ai = new AtomicReference<>(one);
168 >        AtomicReference<Item> 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());
170 >        do {} while (!ai.weakCompareAndSetAcquire(two, minusFour));
171 >        mustEqual(minusFour, ai.get());
172 >        do {} while (!ai.weakCompareAndSetAcquire(minusFour, seven));
173 >        mustEqual(seven, ai.get());
174      }
175  
176      /**
# Line 178 | Line 178 | public class AtomicReference9Test extend
178       * to expected
179       */
180      public void testWeakCompareAndSetRelease() {
181 <        AtomicReference<Integer> ai = new AtomicReference<>(one);
181 >        AtomicReference<Item> 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());
183 >        do {} while (!ai.weakCompareAndSetRelease(two, minusFour));
184 >        mustEqual(minusFour, ai.get());
185 >        do {} while (!ai.weakCompareAndSetRelease(minusFour, seven));
186 >        mustEqual(seven, ai.get());
187      }
188  
189   }

Diff Legend

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