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

Comparing jsr166/src/test/tck/AtomicIntegerFieldUpdaterTest.java (file contents):
Revision 1.22 by jsr166, Fri Jun 10 20:01:21 2011 UTC vs.
Revision 1.31 by jsr166, Mon Nov 9 18:42:41 2015 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import junit.framework.*;
9   import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
10  
11 + import junit.framework.Test;
12 + import junit.framework.TestSuite;
13 +
14   public class AtomicIntegerFieldUpdaterTest extends JSR166TestCase {
15      volatile int x = 0;
16 +    protected volatile int protectedField;
17 +    private volatile int privateField;
18      int w;
19 <    long z;
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(AtomicIntegerFieldUpdaterTest.class);
25      }
26  
27 +    // for testing subclass access
28 +    static class AtomicIntegerFieldUpdaterTestSubclass extends AtomicIntegerFieldUpdaterTest {
29 +        public void checkPrivateAccess() {
30 +            try {
31 +                AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a =
32 +                    AtomicIntegerFieldUpdater.newUpdater
33 +                    (AtomicIntegerFieldUpdaterTest.class, "privateField");
34 +                shouldThrow();
35 +            } catch (RuntimeException success) {
36 +                assertNotNull(success.getCause());
37 +            }
38 +        }
39 +
40 +        public void checkCompareAndSetProtectedSub() {
41 +            AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a =
42 +                AtomicIntegerFieldUpdater.newUpdater
43 +                (AtomicIntegerFieldUpdaterTest.class, "protectedField");
44 +            this.protectedField = 1;
45 +            assertTrue(a.compareAndSet(this, 1, 2));
46 +            assertTrue(a.compareAndSet(this, 2, -4));
47 +            assertEquals(-4, a.get(this));
48 +            assertFalse(a.compareAndSet(this, -5, 7));
49 +            assertEquals(-4, a.get(this));
50 +            assertTrue(a.compareAndSet(this, -4, 7));
51 +            assertEquals(7, a.get(this));
52 +        }
53 +    }
54 +
55 +    static class UnrelatedClass {
56 +        public void checkPackageAccess(AtomicIntegerFieldUpdaterTest obj) {
57 +            obj.x = 72;
58 +            AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a =
59 +                AtomicIntegerFieldUpdater.newUpdater
60 +                (AtomicIntegerFieldUpdaterTest.class, "x");
61 +            assertEquals(72, a.get(obj));
62 +            assertTrue(a.compareAndSet(obj, 72, 73));
63 +            assertEquals(73, a.get(obj));
64 +        }
65 +
66 +        public void checkPrivateAccess(AtomicIntegerFieldUpdaterTest obj) {
67 +            try {
68 +                AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a =
69 +                    AtomicIntegerFieldUpdater.newUpdater
70 +                    (AtomicIntegerFieldUpdaterTest.class, "privateField");
71 +                throw new AssertionError("should throw");
72 +            } catch (RuntimeException success) {
73 +                assertNotNull(success.getCause());
74 +            }
75 +        }
76 +    }
77 +
78 +    AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> updaterFor(String fieldName) {
79 +        return AtomicIntegerFieldUpdater.newUpdater
80 +            (AtomicIntegerFieldUpdaterTest.class, fieldName);
81 +    }
82 +
83      /**
84       * Construction with non-existent field throws RuntimeException
85       */
86      public void testConstructor() {
87          try {
88 <            AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest>
29 <                a = AtomicIntegerFieldUpdater.newUpdater
30 <                (AtomicIntegerFieldUpdaterTest.class, "y");
88 >            updaterFor("y");
89              shouldThrow();
90 <        } catch (RuntimeException success) {}
90 >        } catch (RuntimeException success) {
91 >            assertNotNull(success.getCause());
92 >        }
93      }
94  
95      /**
96 <     * construction with field not of given type throws RuntimeException
96 >     * construction with field not of given type throws IllegalArgumentException
97       */
98      public void testConstructor2() {
99          try {
100 <            AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest>
41 <                a = AtomicIntegerFieldUpdater.newUpdater
42 <                (AtomicIntegerFieldUpdaterTest.class, "z");
100 >            updaterFor("z");
101              shouldThrow();
102 <        } catch (RuntimeException success) {}
102 >        } catch (IllegalArgumentException success) {}
103      }
104  
105      /**
106 <     * construction with non-volatile field throws RuntimeException
106 >     * construction with non-volatile field throws IllegalArgumentException
107       */
108      public void testConstructor3() {
109          try {
110 <            AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest>
53 <                a = AtomicIntegerFieldUpdater.newUpdater
54 <                (AtomicIntegerFieldUpdaterTest.class, "w");
110 >            updaterFor("w");
111              shouldThrow();
112 <        } catch (RuntimeException success) {}
112 >        } catch (IllegalArgumentException success) {}
113 >    }
114 >
115 >    /**
116 >     * construction using private field from subclass throws RuntimeException
117 >     */
118 >    public void testPrivateFieldInSubclass() {
119 >        AtomicIntegerFieldUpdaterTestSubclass s =
120 >            new AtomicIntegerFieldUpdaterTestSubclass();
121 >        s.checkPrivateAccess();
122 >    }
123 >
124 >    /**
125 >     * construction from unrelated class; package access is allowed,
126 >     * private access is not
127 >     */
128 >    public void testUnrelatedClassAccess() {
129 >        new UnrelatedClass().checkPackageAccess(this);
130 >        new UnrelatedClass().checkPrivateAccess(this);
131      }
132  
133      /**
# Line 61 | Line 135 | public class AtomicIntegerFieldUpdaterTe
135       */
136      public void testGetSet() {
137          AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
138 <        try {
65 <            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
66 <        } catch (RuntimeException ok) {
67 <            return;
68 <        }
138 >        a = updaterFor("x");
139          x = 1;
140          assertEquals(1, a.get(this));
141          a.set(this, 2);
# Line 79 | Line 149 | public class AtomicIntegerFieldUpdaterTe
149       */
150      public void testGetLazySet() {
151          AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
152 <        try {
83 <            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
84 <        } catch (RuntimeException ok) {
85 <            return;
86 <        }
152 >        a = updaterFor("x");
153          x = 1;
154          assertEquals(1, a.get(this));
155          a.lazySet(this, 2);
# Line 97 | Line 163 | public class AtomicIntegerFieldUpdaterTe
163       */
164      public void testCompareAndSet() {
165          AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
166 <        try {
101 <            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
102 <        } catch (RuntimeException ok) {
103 <            return;
104 <        }
166 >        a = updaterFor("x");
167          x = 1;
168          assertTrue(a.compareAndSet(this, 1, 2));
169          assertTrue(a.compareAndSet(this, 2, -4));
# Line 113 | Line 175 | public class AtomicIntegerFieldUpdaterTe
175      }
176  
177      /**
178 +     * compareAndSet succeeds in changing protected field value if
179 +     * equal to expected else fails
180 +     */
181 +    public void testCompareAndSetProtected() {
182 +        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
183 +        a = updaterFor("protectedField");
184 +        protectedField = 1;
185 +        assertTrue(a.compareAndSet(this, 1, 2));
186 +        assertTrue(a.compareAndSet(this, 2, -4));
187 +        assertEquals(-4, a.get(this));
188 +        assertFalse(a.compareAndSet(this, -5, 7));
189 +        assertEquals(-4, a.get(this));
190 +        assertTrue(a.compareAndSet(this, -4, 7));
191 +        assertEquals(7, a.get(this));
192 +    }
193 +
194 +    /**
195 +     * compareAndSet succeeds in changing protected field value if
196 +     * equal to expected else fails
197 +     */
198 +    public void testCompareAndSetProtectedInSubclass() {
199 +        AtomicIntegerFieldUpdaterTestSubclass s =
200 +            new AtomicIntegerFieldUpdaterTestSubclass();
201 +        s.checkCompareAndSetProtectedSub();
202 +    }
203 +
204 +    /**
205       * compareAndSet in one thread enables another waiting for value
206       * to succeed
207       */
208      public void testCompareAndSetInMultipleThreads() throws Exception {
209          x = 1;
210 <        final AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest>a;
211 <        try {
123 <            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
124 <        } catch (RuntimeException ok) {
125 <            return;
126 <        }
210 >        final AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
211 >        a = updaterFor("x");
212  
213          Thread t = new Thread(new CheckedRunnable() {
214              public void realRun() {
# Line 135 | Line 220 | public class AtomicIntegerFieldUpdaterTe
220          assertTrue(a.compareAndSet(this, 1, 2));
221          t.join(LONG_DELAY_MS);
222          assertFalse(t.isAlive());
223 <        assertEquals(a.get(this), 3);
223 >        assertEquals(3, a.get(this));
224      }
225  
226      /**
# Line 144 | Line 229 | public class AtomicIntegerFieldUpdaterTe
229       */
230      public void testWeakCompareAndSet() {
231          AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
232 <        try {
148 <            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
149 <        } catch (RuntimeException ok) {
150 <            return;
151 <        }
232 >        a = updaterFor("x");
233          x = 1;
234 <        while (!a.weakCompareAndSet(this, 1, 2));
235 <        while (!a.weakCompareAndSet(this, 2, -4));
234 >        do {} while (!a.weakCompareAndSet(this, 1, 2));
235 >        do {} while (!a.weakCompareAndSet(this, 2, -4));
236          assertEquals(-4, a.get(this));
237 <        while (!a.weakCompareAndSet(this, -4, 7));
237 >        do {} while (!a.weakCompareAndSet(this, -4, 7));
238          assertEquals(7, a.get(this));
239      }
240  
# Line 162 | Line 243 | public class AtomicIntegerFieldUpdaterTe
243       */
244      public void testGetAndSet() {
245          AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
246 <        try {
166 <            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
167 <        } catch (RuntimeException ok) {
168 <            return;
169 <        }
246 >        a = updaterFor("x");
247          x = 1;
248          assertEquals(1, a.getAndSet(this, 0));
249          assertEquals(0, a.getAndSet(this, -10));
# Line 178 | Line 255 | public class AtomicIntegerFieldUpdaterTe
255       */
256      public void testGetAndAdd() {
257          AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
258 <        try {
182 <            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
183 <        } catch (RuntimeException ok) {
184 <            return;
185 <        }
258 >        a = updaterFor("x");
259          x = 1;
260          assertEquals(1, a.getAndAdd(this, 2));
261          assertEquals(3, a.get(this));
# Line 195 | Line 268 | public class AtomicIntegerFieldUpdaterTe
268       */
269      public void testGetAndDecrement() {
270          AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
271 <        try {
199 <            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
200 <        } catch (RuntimeException ok) {
201 <            return;
202 <        }
271 >        a = updaterFor("x");
272          x = 1;
273          assertEquals(1, a.getAndDecrement(this));
274          assertEquals(0, a.getAndDecrement(this));
# Line 211 | Line 280 | public class AtomicIntegerFieldUpdaterTe
280       */
281      public void testGetAndIncrement() {
282          AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
283 <        try {
215 <            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
216 <        } catch (RuntimeException ok) {
217 <            return;
218 <        }
283 >        a = updaterFor("x");
284          x = 1;
285          assertEquals(1, a.getAndIncrement(this));
286          assertEquals(2, a.get(this));
# Line 231 | Line 296 | public class AtomicIntegerFieldUpdaterTe
296       */
297      public void testAddAndGet() {
298          AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
299 <        try {
235 <            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
236 <        } catch (RuntimeException ok) {
237 <            return;
238 <        }
299 >        a = updaterFor("x");
300          x = 1;
301          assertEquals(3, a.addAndGet(this, 2));
302          assertEquals(3, a.get(this));
# Line 248 | Line 309 | public class AtomicIntegerFieldUpdaterTe
309       */
310      public void testDecrementAndGet() {
311          AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
312 <        try {
252 <            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
253 <        } catch (RuntimeException ok) {
254 <            return;
255 <        }
312 >        a = updaterFor("x");
313          x = 1;
314          assertEquals(0, a.decrementAndGet(this));
315          assertEquals(-1, a.decrementAndGet(this));
# Line 265 | Line 322 | public class AtomicIntegerFieldUpdaterTe
322       */
323      public void testIncrementAndGet() {
324          AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
325 <        try {
269 <            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
270 <        } catch (RuntimeException ok) {
271 <            return;
272 <        }
325 >        a = updaterFor("x");
326          x = 1;
327          assertEquals(2, a.incrementAndGet(this));
328          assertEquals(2, a.get(this));

Diff Legend

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