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.22 by jsr166, Fri Jun 10 20:01:21 2011 UTC vs.
Revision 1.25 by jsr166, Tue Apr 2 04:11:28 2013 UTC

# Line 21 | Line 21 | public class AtomicLongFieldUpdaterTest
21          return new TestSuite(AtomicLongFieldUpdaterTest.class);
22      }
23  
24 +    AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> updaterFor(String fieldName) {
25 +        return AtomicLongFieldUpdater.newUpdater
26 +            (AtomicLongFieldUpdaterTest.class, fieldName);
27 +    }
28 +
29      /**
30       * Construction with non-existent field throws RuntimeException
31       */
32      public void testConstructor() {
33          try {
34 <            AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest>
30 <                a = AtomicLongFieldUpdater.newUpdater
31 <                (AtomicLongFieldUpdaterTest.class, "y");
34 >            updaterFor("y");
35              shouldThrow();
36 <        } catch (RuntimeException success) {}
36 >        } catch (RuntimeException success) {
37 >            assertTrue(success.getCause() != null);
38 >        }
39      }
40  
41      /**
42 <     * construction with field not of given type throws RuntimeException
42 >     * construction with field not of given type throws IllegalArgumentException
43       */
44      public void testConstructor2() {
45          try {
46 <            AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest>
42 <                a = AtomicLongFieldUpdater.newUpdater
43 <                (AtomicLongFieldUpdaterTest.class, "z");
46 >            updaterFor("z");
47              shouldThrow();
48 <        } catch (RuntimeException success) {}
48 >        } catch (IllegalArgumentException success) {}
49      }
50  
51      /**
52 <     * construction with non-volatile field throws RuntimeException
52 >     * construction with non-volatile field throws IllegalArgumentException
53       */
54      public void testConstructor3() {
55          try {
56 <            AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest>
54 <                a = AtomicLongFieldUpdater.newUpdater
55 <                (AtomicLongFieldUpdaterTest.class, "w");
56 >            updaterFor("w");
57              shouldThrow();
58 <        } catch (RuntimeException success) {}
58 >        } catch (IllegalArgumentException success) {}
59      }
60  
61      /**
# Line 62 | Line 63 | public class AtomicLongFieldUpdaterTest
63       */
64      public void testGetSet() {
65          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
66 <        try {
66 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
67 <        } catch (RuntimeException ok) {
68 <            return;
69 <        }
66 >        a = updaterFor("x");
67          x = 1;
68          assertEquals(1, a.get(this));
69          a.set(this, 2);
# Line 80 | Line 77 | public class AtomicLongFieldUpdaterTest
77       */
78      public void testGetLazySet() {
79          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
80 <        try {
84 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
85 <        } catch (RuntimeException ok) {
86 <            return;
87 <        }
80 >        a = updaterFor("x");
81          x = 1;
82          assertEquals(1, a.get(this));
83          a.lazySet(this, 2);
# Line 98 | Line 91 | public class AtomicLongFieldUpdaterTest
91       */
92      public void testCompareAndSet() {
93          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
94 <        try {
102 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
103 <        } catch (RuntimeException ok) {
104 <            return;
105 <        }
94 >        a = updaterFor("x");
95          x = 1;
96          assertTrue(a.compareAndSet(this, 1, 2));
97          assertTrue(a.compareAndSet(this, 2, -4));
# Line 119 | Line 108 | public class AtomicLongFieldUpdaterTest
108       */
109      public void testCompareAndSetInMultipleThreads() throws Exception {
110          x = 1;
111 <        final AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest>a;
112 <        try {
124 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
125 <        } catch (RuntimeException ok) {
126 <            return;
127 <        }
111 >        final AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
112 >        a = updaterFor("x");
113  
114          Thread t = new Thread(new CheckedRunnable() {
115              public void realRun() {
# Line 136 | Line 121 | public class AtomicLongFieldUpdaterTest
121          assertTrue(a.compareAndSet(this, 1, 2));
122          t.join(LONG_DELAY_MS);
123          assertFalse(t.isAlive());
124 <        assertEquals(a.get(this), 3);
124 >        assertEquals(3, a.get(this));
125      }
126  
127      /**
# Line 145 | Line 130 | public class AtomicLongFieldUpdaterTest
130       */
131      public void testWeakCompareAndSet() {
132          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
133 <        try {
149 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
150 <        } catch (RuntimeException ok) {
151 <            return;
152 <        }
133 >        a = updaterFor("x");
134          x = 1;
135          while (!a.weakCompareAndSet(this, 1, 2));
136          while (!a.weakCompareAndSet(this, 2, -4));
# Line 163 | Line 144 | public class AtomicLongFieldUpdaterTest
144       */
145      public void testGetAndSet() {
146          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
147 <        try {
167 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
168 <        } catch (RuntimeException ok) {
169 <            return;
170 <        }
147 >        a = updaterFor("x");
148          x = 1;
149          assertEquals(1, a.getAndSet(this, 0));
150          assertEquals(0, a.getAndSet(this, -10));
# Line 179 | Line 156 | public class AtomicLongFieldUpdaterTest
156       */
157      public void testGetAndAdd() {
158          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
159 <        try {
183 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
184 <        } catch (RuntimeException ok) {
185 <            return;
186 <        }
159 >        a = updaterFor("x");
160          x = 1;
161          assertEquals(1, a.getAndAdd(this, 2));
162          assertEquals(3, a.get(this));
# Line 196 | Line 169 | public class AtomicLongFieldUpdaterTest
169       */
170      public void testGetAndDecrement() {
171          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
172 <        try {
200 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
201 <        } catch (RuntimeException ok) {
202 <            return;
203 <        }
172 >        a = updaterFor("x");
173          x = 1;
174          assertEquals(1, a.getAndDecrement(this));
175          assertEquals(0, a.getAndDecrement(this));
# Line 212 | Line 181 | public class AtomicLongFieldUpdaterTest
181       */
182      public void testGetAndIncrement() {
183          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
184 <        try {
216 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
217 <        } catch (RuntimeException ok) {
218 <            return;
219 <        }
184 >        a = updaterFor("x");
185          x = 1;
186          assertEquals(1, a.getAndIncrement(this));
187          assertEquals(2, a.get(this));
# Line 232 | Line 197 | public class AtomicLongFieldUpdaterTest
197       */
198      public void testAddAndGet() {
199          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
200 <        try {
236 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
237 <        } catch (RuntimeException ok) {
238 <            return;
239 <        }
200 >        a = updaterFor("x");
201          x = 1;
202          assertEquals(3, a.addAndGet(this, 2));
203          assertEquals(3, a.get(this));
# Line 249 | Line 210 | public class AtomicLongFieldUpdaterTest
210       */
211      public void testDecrementAndGet() {
212          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
213 <        try {
253 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
254 <        } catch (RuntimeException ok) {
255 <            return;
256 <        }
213 >        a = updaterFor("x");
214          x = 1;
215          assertEquals(0, a.decrementAndGet(this));
216          assertEquals(-1, a.decrementAndGet(this));
# Line 266 | Line 223 | public class AtomicLongFieldUpdaterTest
223       */
224      public void testIncrementAndGet() {
225          AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
226 <        try {
270 <            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
271 <        } catch (RuntimeException ok) {
272 <            return;
273 <        }
226 >        a = updaterFor("x");
227          x = 1;
228          assertEquals(2, a.incrementAndGet(this));
229          assertEquals(2, a.get(this));

Diff Legend

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