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

Comparing jsr166/src/test/tck/AtomicLongFieldUpdaterTest.java (file contents):
Revision 1.18 by jsr166, Sat Oct 9 19:30:34 2010 UTC vs.
Revision 1.34 by jsr166, Wed Sep 20 00:59:17 2017 UTC

# Line 1 | Line 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/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import java.util.concurrent.atomic.*;
10 < import junit.framework.*;
11 < import java.util.*;
9 > import java.util.concurrent.atomic.AtomicLongFieldUpdater;
10 >
11 > import junit.framework.Test;
12 > import junit.framework.TestSuite;
13  
14   public class AtomicLongFieldUpdaterTest extends JSR166TestCase {
15      volatile long x = 0;
16 <    int z;
16 >    protected volatile long protectedField;
17 >    private volatile long privateField;
18      long w;
19 <
19 >    float z;
20      public static void main(String[] args) {
21 <        junit.textui.TestRunner.run(suite());
21 >        main(suite(), args);
22      }
23      public static Test suite() {
24          return new TestSuite(AtomicLongFieldUpdaterTest.class);
25      }
26  
27 +    AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> updaterFor(String fieldName) {
28 +        return AtomicLongFieldUpdater.newUpdater
29 +            (AtomicLongFieldUpdaterTest.class, fieldName);
30 +    }
31 +
32      /**
33       * Construction with non-existent field throws RuntimeException
34       */
35      public void testConstructor() {
36          try {
37 <            AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest>
31 <                a = AtomicLongFieldUpdater.newUpdater
32 <                (AtomicLongFieldUpdaterTest.class, "y");
37 >            updaterFor("y");
38              shouldThrow();
39 <        } catch (RuntimeException success) {}
39 >        } catch (RuntimeException success) {
40 >            assertNotNull(success.getCause());
41 >        }
42      }
43  
44      /**
45 <     * construction with field not of given type throws RuntimeException
45 >     * construction with field not of given type throws IllegalArgumentException
46       */
47      public void testConstructor2() {
48          try {
49 <            AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest>
43 <                a = AtomicLongFieldUpdater.newUpdater
44 <                (AtomicLongFieldUpdaterTest.class, "z");
49 >            updaterFor("z");
50              shouldThrow();
51 <        } catch (RuntimeException success) {}
51 >        } catch (IllegalArgumentException success) {}
52      }
53  
54      /**
55 <     * construction with non-volatile field throws RuntimeException
55 >     * construction with non-volatile field throws IllegalArgumentException
56       */
57      public void testConstructor3() {
58          try {
59 <            AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest>
55 <                a = AtomicLongFieldUpdater.newUpdater
56 <                (AtomicLongFieldUpdaterTest.class, "w");
59 >            updaterFor("w");
60              shouldThrow();
61 <        } catch (RuntimeException success) {}
61 >        } catch (IllegalArgumentException success) {}
62 >    }
63 >
64 >    /**
65 >     * construction using private field from subclass throws RuntimeException
66 >     */
67 >    public void testPrivateFieldInSubclass() {
68 >        new NonNestmates.AtomicLongFieldUpdaterTestSubclass()
69 >            .checkPrivateAccess();
70 >    }
71 >
72 >    /**
73 >     * construction from unrelated class; package access is allowed,
74 >     * private access is not
75 >     */
76 >    public void testUnrelatedClassAccess() {
77 >        new NonNestmates().checkPackageAccess(this);
78 >        new NonNestmates().checkPrivateAccess(this);
79      }
80  
81      /**
# Line 63 | Line 83 | public class AtomicLongFieldUpdaterTest
83       */
84      public void testGetSet() {
85          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
86 <        try {
67 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
68 <        } catch (RuntimeException ok) {
69 <            return;
70 <        }
86 >        a = updaterFor("x");
87          x = 1;
88 <        assertEquals(1,a.get(this));
89 <        a.set(this,2);
90 <        assertEquals(2,a.get(this));
91 <        a.set(this,-3);
92 <        assertEquals(-3,a.get(this));
88 >        assertEquals(1, a.get(this));
89 >        a.set(this, 2);
90 >        assertEquals(2, a.get(this));
91 >        a.set(this, -3);
92 >        assertEquals(-3, a.get(this));
93      }
94  
95      /**
# Line 81 | Line 97 | public class AtomicLongFieldUpdaterTest
97       */
98      public void testGetLazySet() {
99          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
100 <        try {
85 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
86 <        } catch (RuntimeException ok) {
87 <            return;
88 <        }
100 >        a = updaterFor("x");
101          x = 1;
102 <        assertEquals(1,a.get(this));
103 <        a.lazySet(this,2);
104 <        assertEquals(2,a.get(this));
105 <        a.lazySet(this,-3);
106 <        assertEquals(-3,a.get(this));
102 >        assertEquals(1, a.get(this));
103 >        a.lazySet(this, 2);
104 >        assertEquals(2, a.get(this));
105 >        a.lazySet(this, -3);
106 >        assertEquals(-3, a.get(this));
107      }
108  
97 –
109      /**
110       * compareAndSet succeeds in changing value if equal to expected else fails
111       */
112      public void testCompareAndSet() {
113          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
114 <        try {
104 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
105 <        } catch (RuntimeException ok) {
106 <            return;
107 <        }
114 >        a = updaterFor("x");
115          x = 1;
116 <        assertTrue(a.compareAndSet(this,1,2));
117 <        assertTrue(a.compareAndSet(this,2,-4));
118 <        assertEquals(-4,a.get(this));
119 <        assertFalse(a.compareAndSet(this,-5,7));
120 <        assertEquals(-4,a.get(this));
121 <        assertTrue(a.compareAndSet(this,-4,7));
122 <        assertEquals(7,a.get(this));
116 >        assertTrue(a.compareAndSet(this, 1, 2));
117 >        assertTrue(a.compareAndSet(this, 2, -4));
118 >        assertEquals(-4, a.get(this));
119 >        assertFalse(a.compareAndSet(this, -5, 7));
120 >        assertEquals(-4, a.get(this));
121 >        assertTrue(a.compareAndSet(this, -4, 7));
122 >        assertEquals(7, a.get(this));
123 >    }
124 >
125 >    /**
126 >     * compareAndSet succeeds in changing protected field value if
127 >     * equal to expected else fails
128 >     */
129 >    public void testCompareAndSetProtected() {
130 >        AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
131 >        a = updaterFor("protectedField");
132 >        protectedField = 1;
133 >        assertTrue(a.compareAndSet(this, 1, 2));
134 >        assertTrue(a.compareAndSet(this, 2, -4));
135 >        assertEquals(-4, a.get(this));
136 >        assertFalse(a.compareAndSet(this, -5, 7));
137 >        assertEquals(-4, a.get(this));
138 >        assertTrue(a.compareAndSet(this, -4, 7));
139 >        assertEquals(7, a.get(this));
140      }
141  
142 +    /**
143 +     * compareAndSet succeeds in changing protected field value if
144 +     * equal to expected else fails
145 +     */
146 +    public void testCompareAndSetProtectedInSubclass() {
147 +        new NonNestmates.AtomicLongFieldUpdaterTestSubclass()
148 +            .checkCompareAndSetProtectedSub();
149 +    }
150  
151      /**
152       * compareAndSet in one thread enables another waiting for value
# Line 122 | Line 154 | public class AtomicLongFieldUpdaterTest
154       */
155      public void testCompareAndSetInMultipleThreads() throws Exception {
156          x = 1;
157 <        final AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest>a;
158 <        try {
127 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
128 <        } catch (RuntimeException ok) {
129 <            return;
130 <        }
157 >        final AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
158 >        a = updaterFor("x");
159  
160          Thread t = new Thread(new CheckedRunnable() {
161              public void realRun() {
# Line 139 | Line 167 | public class AtomicLongFieldUpdaterTest
167          assertTrue(a.compareAndSet(this, 1, 2));
168          t.join(LONG_DELAY_MS);
169          assertFalse(t.isAlive());
170 <        assertEquals(a.get(this), 3);
170 >        assertEquals(3, a.get(this));
171      }
172  
173      /**
# Line 148 | Line 176 | public class AtomicLongFieldUpdaterTest
176       */
177      public void testWeakCompareAndSet() {
178          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
179 <        try {
152 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
153 <        } catch (RuntimeException ok) {
154 <            return;
155 <        }
179 >        a = updaterFor("x");
180          x = 1;
181 <        while (!a.weakCompareAndSet(this,1,2));
182 <        while (!a.weakCompareAndSet(this,2,-4));
183 <        assertEquals(-4,a.get(this));
184 <        while (!a.weakCompareAndSet(this,-4,7));
185 <        assertEquals(7,a.get(this));
181 >        do {} while (!a.weakCompareAndSet(this, 1, 2));
182 >        do {} while (!a.weakCompareAndSet(this, 2, -4));
183 >        assertEquals(-4, a.get(this));
184 >        do {} while (!a.weakCompareAndSet(this, -4, 7));
185 >        assertEquals(7, a.get(this));
186      }
187  
188      /**
# Line 166 | Line 190 | public class AtomicLongFieldUpdaterTest
190       */
191      public void testGetAndSet() {
192          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
193 <        try {
170 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
171 <        } catch (RuntimeException ok) {
172 <            return;
173 <        }
193 >        a = updaterFor("x");
194          x = 1;
195 <        assertEquals(1,a.getAndSet(this, 0));
196 <        assertEquals(0,a.getAndSet(this,-10));
197 <        assertEquals(-10,a.getAndSet(this,1));
195 >        assertEquals(1, a.getAndSet(this, 0));
196 >        assertEquals(0, a.getAndSet(this, -10));
197 >        assertEquals(-10, a.getAndSet(this, 1));
198      }
199  
200      /**
# Line 182 | Line 202 | public class AtomicLongFieldUpdaterTest
202       */
203      public void testGetAndAdd() {
204          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
205 <        try {
186 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
187 <        } catch (RuntimeException ok) {
188 <            return;
189 <        }
205 >        a = updaterFor("x");
206          x = 1;
207 <        assertEquals(1,a.getAndAdd(this,2));
208 <        assertEquals(3,a.get(this));
209 <        assertEquals(3,a.getAndAdd(this,-4));
210 <        assertEquals(-1,a.get(this));
207 >        assertEquals(1, a.getAndAdd(this, 2));
208 >        assertEquals(3, a.get(this));
209 >        assertEquals(3, a.getAndAdd(this, -4));
210 >        assertEquals(-1, a.get(this));
211      }
212  
213      /**
# Line 199 | Line 215 | public class AtomicLongFieldUpdaterTest
215       */
216      public void testGetAndDecrement() {
217          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
218 <        try {
203 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
204 <        } catch (RuntimeException ok) {
205 <            return;
206 <        }
218 >        a = updaterFor("x");
219          x = 1;
220 <        assertEquals(1,a.getAndDecrement(this));
221 <        assertEquals(0,a.getAndDecrement(this));
222 <        assertEquals(-1,a.getAndDecrement(this));
220 >        assertEquals(1, a.getAndDecrement(this));
221 >        assertEquals(0, a.getAndDecrement(this));
222 >        assertEquals(-1, a.getAndDecrement(this));
223      }
224  
225      /**
# Line 215 | Line 227 | public class AtomicLongFieldUpdaterTest
227       */
228      public void testGetAndIncrement() {
229          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
230 <        try {
219 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
220 <        } catch (RuntimeException ok) {
221 <            return;
222 <        }
230 >        a = updaterFor("x");
231          x = 1;
232 <        assertEquals(1,a.getAndIncrement(this));
233 <        assertEquals(2,a.get(this));
234 <        a.set(this,-2);
235 <        assertEquals(-2,a.getAndIncrement(this));
236 <        assertEquals(-1,a.getAndIncrement(this));
237 <        assertEquals(0,a.getAndIncrement(this));
238 <        assertEquals(1,a.get(this));
232 >        assertEquals(1, a.getAndIncrement(this));
233 >        assertEquals(2, a.get(this));
234 >        a.set(this, -2);
235 >        assertEquals(-2, a.getAndIncrement(this));
236 >        assertEquals(-1, a.getAndIncrement(this));
237 >        assertEquals(0, a.getAndIncrement(this));
238 >        assertEquals(1, a.get(this));
239      }
240  
241      /**
# Line 235 | Line 243 | public class AtomicLongFieldUpdaterTest
243       */
244      public void testAddAndGet() {
245          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
246 <        try {
239 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
240 <        } catch (RuntimeException ok) {
241 <            return;
242 <        }
246 >        a = updaterFor("x");
247          x = 1;
248 <        assertEquals(3,a.addAndGet(this,2));
249 <        assertEquals(3,a.get(this));
250 <        assertEquals(-1,a.addAndGet(this,-4));
251 <        assertEquals(-1,a.get(this));
248 >        assertEquals(3, a.addAndGet(this, 2));
249 >        assertEquals(3, a.get(this));
250 >        assertEquals(-1, a.addAndGet(this, -4));
251 >        assertEquals(-1, a.get(this));
252      }
253  
254      /**
# Line 252 | Line 256 | public class AtomicLongFieldUpdaterTest
256       */
257      public void testDecrementAndGet() {
258          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
259 <        try {
256 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
257 <        } catch (RuntimeException ok) {
258 <            return;
259 <        }
259 >        a = updaterFor("x");
260          x = 1;
261 <        assertEquals(0,a.decrementAndGet(this));
262 <        assertEquals(-1,a.decrementAndGet(this));
263 <        assertEquals(-2,a.decrementAndGet(this));
264 <        assertEquals(-2,a.get(this));
261 >        assertEquals(0, a.decrementAndGet(this));
262 >        assertEquals(-1, a.decrementAndGet(this));
263 >        assertEquals(-2, a.decrementAndGet(this));
264 >        assertEquals(-2, a.get(this));
265      }
266  
267      /**
# Line 269 | Line 269 | public class AtomicLongFieldUpdaterTest
269       */
270      public void testIncrementAndGet() {
271          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
272 <        try {
273 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
274 <        } catch (RuntimeException ok) {
275 <            return;
276 <        }
272 >        a = updaterFor("x");
273          x = 1;
274 <        assertEquals(2,a.incrementAndGet(this));
275 <        assertEquals(2,a.get(this));
276 <        a.set(this,-2);
277 <        assertEquals(-1,a.incrementAndGet(this));
278 <        assertEquals(0,a.incrementAndGet(this));
279 <        assertEquals(1,a.incrementAndGet(this));
280 <        assertEquals(1,a.get(this));
274 >        assertEquals(2, a.incrementAndGet(this));
275 >        assertEquals(2, a.get(this));
276 >        a.set(this, -2);
277 >        assertEquals(-1, a.incrementAndGet(this));
278 >        assertEquals(0, a.incrementAndGet(this));
279 >        assertEquals(1, a.incrementAndGet(this));
280 >        assertEquals(1, a.get(this));
281      }
282  
283   }

Diff Legend

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