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.23 by jsr166, Fri Jun 10 20:17:11 2011 UTC vs.
Revision 1.33 by jsr166, Wed Sep 20 00:41:13 2017 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import junit.framework.*;
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>
30 <                a = AtomicLongFieldUpdater.newUpdater
31 <                (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>
42 <                a = AtomicLongFieldUpdater.newUpdater
43 <                (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>
54 <                a = AtomicLongFieldUpdater.newUpdater
55 <                (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 62 | Line 83 | public class AtomicLongFieldUpdaterTest
83       */
84      public void testGetSet() {
85          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
86 <        try {
66 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
67 <        } catch (RuntimeException ok) {
68 <            return;
69 <        }
86 >        a = updaterFor("x");
87          x = 1;
88          assertEquals(1, a.get(this));
89          a.set(this, 2);
# Line 80 | Line 97 | public class AtomicLongFieldUpdaterTest
97       */
98      public void testGetLazySet() {
99          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
100 <        try {
84 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
85 <        } catch (RuntimeException ok) {
86 <            return;
87 <        }
100 >        a = updaterFor("x");
101          x = 1;
102          assertEquals(1, a.get(this));
103          a.lazySet(this, 2);
# Line 98 | Line 111 | public class AtomicLongFieldUpdaterTest
111       */
112      public void testCompareAndSet() {
113          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
114 <        try {
102 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
103 <        } catch (RuntimeException ok) {
104 <            return;
105 <        }
114 >        a = updaterFor("x");
115          x = 1;
116          assertTrue(a.compareAndSet(this, 1, 2));
117          assertTrue(a.compareAndSet(this, 2, -4));
# Line 114 | Line 123 | public class AtomicLongFieldUpdaterTest
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 +        NonNestmates.AtomicLongFieldUpdaterTestSubclass s =
148 +            new NonNestmates.AtomicLongFieldUpdaterTestSubclass();
149 +        s.checkCompareAndSetProtectedSub();
150 +    }
151 +
152 +    /**
153       * compareAndSet in one thread enables another waiting for value
154       * to succeed
155       */
156      public void testCompareAndSetInMultipleThreads() throws Exception {
157          x = 1;
158 <        final AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest>a;
159 <        try {
124 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
125 <        } catch (RuntimeException ok) {
126 <            return;
127 <        }
158 >        final AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
159 >        a = updaterFor("x");
160  
161          Thread t = new Thread(new CheckedRunnable() {
162              public void realRun() {
# Line 145 | Line 177 | public class AtomicLongFieldUpdaterTest
177       */
178      public void testWeakCompareAndSet() {
179          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
180 <        try {
149 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
150 <        } catch (RuntimeException ok) {
151 <            return;
152 <        }
180 >        a = updaterFor("x");
181          x = 1;
182 <        while (!a.weakCompareAndSet(this, 1, 2));
183 <        while (!a.weakCompareAndSet(this, 2, -4));
182 >        do {} while (!a.weakCompareAndSet(this, 1, 2));
183 >        do {} while (!a.weakCompareAndSet(this, 2, -4));
184          assertEquals(-4, a.get(this));
185 <        while (!a.weakCompareAndSet(this, -4, 7));
185 >        do {} while (!a.weakCompareAndSet(this, -4, 7));
186          assertEquals(7, a.get(this));
187      }
188  
# Line 163 | Line 191 | public class AtomicLongFieldUpdaterTest
191       */
192      public void testGetAndSet() {
193          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
194 <        try {
167 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
168 <        } catch (RuntimeException ok) {
169 <            return;
170 <        }
194 >        a = updaterFor("x");
195          x = 1;
196          assertEquals(1, a.getAndSet(this, 0));
197          assertEquals(0, a.getAndSet(this, -10));
# Line 179 | Line 203 | public class AtomicLongFieldUpdaterTest
203       */
204      public void testGetAndAdd() {
205          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
206 <        try {
183 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
184 <        } catch (RuntimeException ok) {
185 <            return;
186 <        }
206 >        a = updaterFor("x");
207          x = 1;
208          assertEquals(1, a.getAndAdd(this, 2));
209          assertEquals(3, a.get(this));
# Line 196 | Line 216 | public class AtomicLongFieldUpdaterTest
216       */
217      public void testGetAndDecrement() {
218          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
219 <        try {
200 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
201 <        } catch (RuntimeException ok) {
202 <            return;
203 <        }
219 >        a = updaterFor("x");
220          x = 1;
221          assertEquals(1, a.getAndDecrement(this));
222          assertEquals(0, a.getAndDecrement(this));
# Line 212 | Line 228 | public class AtomicLongFieldUpdaterTest
228       */
229      public void testGetAndIncrement() {
230          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
231 <        try {
216 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
217 <        } catch (RuntimeException ok) {
218 <            return;
219 <        }
231 >        a = updaterFor("x");
232          x = 1;
233          assertEquals(1, a.getAndIncrement(this));
234          assertEquals(2, a.get(this));
# Line 232 | Line 244 | public class AtomicLongFieldUpdaterTest
244       */
245      public void testAddAndGet() {
246          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
247 <        try {
236 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
237 <        } catch (RuntimeException ok) {
238 <            return;
239 <        }
247 >        a = updaterFor("x");
248          x = 1;
249          assertEquals(3, a.addAndGet(this, 2));
250          assertEquals(3, a.get(this));
# Line 249 | Line 257 | public class AtomicLongFieldUpdaterTest
257       */
258      public void testDecrementAndGet() {
259          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
260 <        try {
253 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
254 <        } catch (RuntimeException ok) {
255 <            return;
256 <        }
260 >        a = updaterFor("x");
261          x = 1;
262          assertEquals(0, a.decrementAndGet(this));
263          assertEquals(-1, a.decrementAndGet(this));
# Line 266 | Line 270 | public class AtomicLongFieldUpdaterTest
270       */
271      public void testIncrementAndGet() {
272          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
273 <        try {
270 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
271 <        } catch (RuntimeException ok) {
272 <            return;
273 <        }
273 >        a = updaterFor("x");
274          x = 1;
275          assertEquals(2, a.incrementAndGet(this));
276          assertEquals(2, a.get(this));

Diff Legend

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