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

Comparing jsr166/src/test/tck/AtomicLongArrayTest.java (file contents):
Revision 1.23 by jsr166, Fri Jun 10 20:01:21 2011 UTC vs.
Revision 1.38 by dl, Tue Jan 26 13:33:05 2021 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import junit.framework.*;
9   import java.util.Arrays;
10   import java.util.concurrent.atomic.AtomicLongArray;
11  
12 + import junit.framework.Test;
13 + import junit.framework.TestSuite;
14 +
15   public class AtomicLongArrayTest extends JSR166TestCase {
16      public static void main(String[] args) {
17 <        junit.textui.TestRunner.run(suite());
17 >        main(suite(), args);
18      }
19      public static Test suite() {
20          return new TestSuite(AtomicLongArrayTest.class);
# Line 22 | Line 24 | public class AtomicLongArrayTest extends
24       * constructor creates array of given size with all elements zero
25       */
26      public void testConstructor() {
27 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
28 <        for (int i = 0; i < SIZE; ++i)
29 <            assertEquals(0, ai.get(i));
27 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
28 >        for (int i = 0; i < SIZE; i++)
29 >            assertEquals(0, aa.get(i));
30      }
31  
32      /**
# Line 33 | Line 35 | public class AtomicLongArrayTest extends
35      public void testConstructor2NPE() {
36          try {
37              long[] a = null;
38 <            AtomicLongArray ai = new AtomicLongArray(a);
38 >            new AtomicLongArray(a);
39              shouldThrow();
40          } catch (NullPointerException success) {}
41      }
# Line 43 | Line 45 | public class AtomicLongArrayTest extends
45       */
46      public void testConstructor2() {
47          long[] a = { 17L, 3L, -42L, 99L, -7L };
48 <        AtomicLongArray ai = new AtomicLongArray(a);
49 <        assertEquals(a.length, ai.length());
50 <        for (int i = 0; i < a.length; ++i)
51 <            assertEquals(a[i], ai.get(i));
48 >        AtomicLongArray aa = new AtomicLongArray(a);
49 >        assertEquals(a.length, aa.length());
50 >        for (int i = 0; i < a.length; i++)
51 >            assertEquals(a[i], aa.get(i));
52      }
53  
54      /**
55       * get and set for out of bound indices throw IndexOutOfBoundsException
56       */
57 +    @SuppressWarnings("deprecation")
58      public void testIndexing() {
59 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
60 <        try {
61 <            ai.get(SIZE);
62 <            shouldThrow();
63 <        } catch (IndexOutOfBoundsException success) {
64 <        }
65 <        try {
66 <            ai.get(-1);
67 <            shouldThrow();
68 <        } catch (IndexOutOfBoundsException success) {
69 <        }
70 <        try {
71 <            ai.set(SIZE, 0);
72 <            shouldThrow();
73 <        } catch (IndexOutOfBoundsException success) {
74 <        }
75 <        try {
76 <            ai.set(-1, 0);
77 <            shouldThrow();
78 <        } catch (IndexOutOfBoundsException success) {
59 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
60 >        for (int index : new int[] { -1, SIZE }) {
61 >            try {
62 >                aa.get(index);
63 >                shouldThrow();
64 >            } catch (IndexOutOfBoundsException success) {}
65 >            try {
66 >                aa.set(index, 1);
67 >                shouldThrow();
68 >            } catch (IndexOutOfBoundsException success) {}
69 >            try {
70 >                aa.lazySet(index, 1);
71 >                shouldThrow();
72 >            } catch (IndexOutOfBoundsException success) {}
73 >            try {
74 >                aa.compareAndSet(index, 1, 2);
75 >                shouldThrow();
76 >            } catch (IndexOutOfBoundsException success) {}
77 >            try {
78 >                aa.weakCompareAndSet(index, 1, 2);
79 >                shouldThrow();
80 >            } catch (IndexOutOfBoundsException success) {}
81 >            try {
82 >                aa.getAndAdd(index, 1);
83 >                shouldThrow();
84 >            } catch (IndexOutOfBoundsException success) {}
85 >            try {
86 >                aa.addAndGet(index, 1);
87 >                shouldThrow();
88 >            } catch (IndexOutOfBoundsException success) {}
89          }
90      }
91  
# Line 80 | Line 93 | public class AtomicLongArrayTest extends
93       * get returns the last value set at index
94       */
95      public void testGetSet() {
96 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
97 <        for (int i = 0; i < SIZE; ++i) {
98 <            ai.set(i, 1);
99 <            assertEquals(1, ai.get(i));
100 <            ai.set(i, 2);
101 <            assertEquals(2, ai.get(i));
102 <            ai.set(i, -3);
103 <            assertEquals(-3, ai.get(i));
96 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
97 >        for (int i = 0; i < SIZE; i++) {
98 >            aa.set(i, 1);
99 >            assertEquals(1, aa.get(i));
100 >            aa.set(i, 2);
101 >            assertEquals(2, aa.get(i));
102 >            aa.set(i, -3);
103 >            assertEquals(-3, aa.get(i));
104          }
105      }
106  
# Line 95 | Line 108 | public class AtomicLongArrayTest extends
108       * get returns the last value lazySet at index by same thread
109       */
110      public void testGetLazySet() {
111 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
112 <        for (int i = 0; i < SIZE; ++i) {
113 <            ai.lazySet(i, 1);
114 <            assertEquals(1, ai.get(i));
115 <            ai.lazySet(i, 2);
116 <            assertEquals(2, ai.get(i));
117 <            ai.lazySet(i, -3);
118 <            assertEquals(-3, ai.get(i));
111 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
112 >        for (int i = 0; i < SIZE; i++) {
113 >            aa.lazySet(i, 1);
114 >            assertEquals(1, aa.get(i));
115 >            aa.lazySet(i, 2);
116 >            assertEquals(2, aa.get(i));
117 >            aa.lazySet(i, -3);
118 >            assertEquals(-3, aa.get(i));
119          }
120      }
121  
# Line 110 | Line 123 | public class AtomicLongArrayTest extends
123       * compareAndSet succeeds in changing value if equal to expected else fails
124       */
125      public void testCompareAndSet() {
126 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
127 <        for (int i = 0; i < SIZE; ++i) {
128 <            ai.set(i, 1);
129 <            assertTrue(ai.compareAndSet(i, 1, 2));
130 <            assertTrue(ai.compareAndSet(i, 2, -4));
131 <            assertEquals(-4, ai.get(i));
132 <            assertFalse(ai.compareAndSet(i, -5, 7));
133 <            assertEquals(-4, ai.get(i));
134 <            assertTrue(ai.compareAndSet(i, -4, 7));
135 <            assertEquals(7, ai.get(i));
126 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
127 >        for (int i = 0; i < SIZE; i++) {
128 >            aa.set(i, 1);
129 >            assertTrue(aa.compareAndSet(i, 1, 2));
130 >            assertTrue(aa.compareAndSet(i, 2, -4));
131 >            assertEquals(-4, aa.get(i));
132 >            assertFalse(aa.compareAndSet(i, -5, 7));
133 >            assertEquals(-4, aa.get(i));
134 >            assertTrue(aa.compareAndSet(i, -4, 7));
135 >            assertEquals(7, aa.get(i));
136          }
137      }
138  
# Line 140 | Line 153 | public class AtomicLongArrayTest extends
153          assertTrue(a.compareAndSet(0, 1, 2));
154          t.join(LONG_DELAY_MS);
155          assertFalse(t.isAlive());
156 <        assertEquals(a.get(0), 3);
156 >        assertEquals(3, a.get(0));
157      }
158  
159      /**
160       * repeated weakCompareAndSet succeeds in changing value when equal
161       * to expected
162       */
163 +    @SuppressWarnings("deprecation")
164      public void testWeakCompareAndSet() {
165 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
166 <        for (int i = 0; i < SIZE; ++i) {
167 <            ai.set(i, 1);
168 <            while (!ai.weakCompareAndSet(i, 1, 2));
169 <            while (!ai.weakCompareAndSet(i, 2, -4));
170 <            assertEquals(-4, ai.get(i));
171 <            while (!ai.weakCompareAndSet(i, -4, 7));
172 <            assertEquals(7, ai.get(i));
165 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
166 >        for (int i = 0; i < SIZE; i++) {
167 >            aa.set(i, 1);
168 >            do {} while (!aa.weakCompareAndSet(i, 1, 2));
169 >            do {} while (!aa.weakCompareAndSet(i, 2, -4));
170 >            assertEquals(-4, aa.get(i));
171 >            do {} while (!aa.weakCompareAndSet(i, -4, 7));
172 >            assertEquals(7, aa.get(i));
173          }
174      }
175  
# Line 163 | Line 177 | public class AtomicLongArrayTest extends
177       * getAndSet returns previous value and sets to given value at given index
178       */
179      public void testGetAndSet() {
180 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
181 <        for (int i = 0; i < SIZE; ++i) {
182 <            ai.set(i, 1);
183 <            assertEquals(1, ai.getAndSet(i, 0));
184 <            assertEquals(0, ai.getAndSet(i, -10));
185 <            assertEquals(-10, ai.getAndSet(i, 1));
180 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
181 >        for (int i = 0; i < SIZE; i++) {
182 >            aa.set(i, 1);
183 >            assertEquals(1, aa.getAndSet(i, 0));
184 >            assertEquals(0, aa.getAndSet(i, -10));
185 >            assertEquals(-10, aa.getAndSet(i, 1));
186          }
187      }
188  
# Line 176 | Line 190 | public class AtomicLongArrayTest extends
190       * getAndAdd returns previous value and adds given value
191       */
192      public void testGetAndAdd() {
193 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
194 <        for (int i = 0; i < SIZE; ++i) {
195 <            ai.set(i, 1);
196 <            assertEquals(1, ai.getAndAdd(i, 2));
197 <            assertEquals(3, ai.get(i));
198 <            assertEquals(3, ai.getAndAdd(i, -4));
199 <            assertEquals(-1, ai.get(i));
193 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
194 >        for (int i = 0; i < SIZE; i++) {
195 >            aa.set(i, 1);
196 >            assertEquals(1, aa.getAndAdd(i, 2));
197 >            assertEquals(3, aa.get(i));
198 >            assertEquals(3, aa.getAndAdd(i, -4));
199 >            assertEquals(-1, aa.get(i));
200          }
201      }
202  
# Line 190 | Line 204 | public class AtomicLongArrayTest extends
204       * getAndDecrement returns previous value and decrements
205       */
206      public void testGetAndDecrement() {
207 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
208 <        for (int i = 0; i < SIZE; ++i) {
209 <            ai.set(i, 1);
210 <            assertEquals(1, ai.getAndDecrement(i));
211 <            assertEquals(0, ai.getAndDecrement(i));
212 <            assertEquals(-1, ai.getAndDecrement(i));
207 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
208 >        for (int i = 0; i < SIZE; i++) {
209 >            aa.set(i, 1);
210 >            assertEquals(1, aa.getAndDecrement(i));
211 >            assertEquals(0, aa.getAndDecrement(i));
212 >            assertEquals(-1, aa.getAndDecrement(i));
213          }
214      }
215  
# Line 203 | Line 217 | public class AtomicLongArrayTest extends
217       * getAndIncrement returns previous value and increments
218       */
219      public void testGetAndIncrement() {
220 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
221 <        for (int i = 0; i < SIZE; ++i) {
222 <            ai.set(i, 1);
223 <            assertEquals(1, ai.getAndIncrement(i));
224 <            assertEquals(2, ai.get(i));
225 <            ai.set(i, -2);
226 <            assertEquals(-2, ai.getAndIncrement(i));
227 <            assertEquals(-1, ai.getAndIncrement(i));
228 <            assertEquals(0, ai.getAndIncrement(i));
229 <            assertEquals(1, ai.get(i));
220 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
221 >        for (int i = 0; i < SIZE; i++) {
222 >            aa.set(i, 1);
223 >            assertEquals(1, aa.getAndIncrement(i));
224 >            assertEquals(2, aa.get(i));
225 >            aa.set(i, -2);
226 >            assertEquals(-2, aa.getAndIncrement(i));
227 >            assertEquals(-1, aa.getAndIncrement(i));
228 >            assertEquals(0, aa.getAndIncrement(i));
229 >            assertEquals(1, aa.get(i));
230          }
231      }
232  
# Line 220 | Line 234 | public class AtomicLongArrayTest extends
234       * addAndGet adds given value to current, and returns current value
235       */
236      public void testAddAndGet() {
237 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
238 <        for (int i = 0; i < SIZE; ++i) {
239 <            ai.set(i, 1);
240 <            assertEquals(3, ai.addAndGet(i, 2));
241 <            assertEquals(3, ai.get(i));
242 <            assertEquals(-1, ai.addAndGet(i, -4));
243 <            assertEquals(-1, ai.get(i));
237 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
238 >        for (int i = 0; i < SIZE; i++) {
239 >            aa.set(i, 1);
240 >            assertEquals(3, aa.addAndGet(i, 2));
241 >            assertEquals(3, aa.get(i));
242 >            assertEquals(-1, aa.addAndGet(i, -4));
243 >            assertEquals(-1, aa.get(i));
244          }
245      }
246  
# Line 234 | Line 248 | public class AtomicLongArrayTest extends
248       * decrementAndGet decrements and returns current value
249       */
250      public void testDecrementAndGet() {
251 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
252 <        for (int i = 0; i < SIZE; ++i) {
253 <            ai.set(i, 1);
254 <            assertEquals(0, ai.decrementAndGet(i));
255 <            assertEquals(-1, ai.decrementAndGet(i));
256 <            assertEquals(-2, ai.decrementAndGet(i));
257 <            assertEquals(-2, ai.get(i));
251 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
252 >        for (int i = 0; i < SIZE; i++) {
253 >            aa.set(i, 1);
254 >            assertEquals(0, aa.decrementAndGet(i));
255 >            assertEquals(-1, aa.decrementAndGet(i));
256 >            assertEquals(-2, aa.decrementAndGet(i));
257 >            assertEquals(-2, aa.get(i));
258          }
259      }
260  
# Line 248 | Line 262 | public class AtomicLongArrayTest extends
262       * incrementAndGet increments and returns current value
263       */
264      public void testIncrementAndGet() {
265 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
266 <        for (int i = 0; i < SIZE; ++i) {
267 <            ai.set(i, 1);
268 <            assertEquals(2, ai.incrementAndGet(i));
269 <            assertEquals(2, ai.get(i));
270 <            ai.set(i, -2);
271 <            assertEquals(-1, ai.incrementAndGet(i));
272 <            assertEquals(0, ai.incrementAndGet(i));
273 <            assertEquals(1, ai.incrementAndGet(i));
274 <            assertEquals(1, ai.get(i));
265 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
266 >        for (int i = 0; i < SIZE; i++) {
267 >            aa.set(i, 1);
268 >            assertEquals(2, aa.incrementAndGet(i));
269 >            assertEquals(2, aa.get(i));
270 >            aa.set(i, -2);
271 >            assertEquals(-1, aa.incrementAndGet(i));
272 >            assertEquals(0, aa.incrementAndGet(i));
273 >            assertEquals(1, aa.incrementAndGet(i));
274 >            assertEquals(1, aa.get(i));
275          }
276      }
277  
264 –    static final long COUNTDOWN = 100000;
265 –
278      class Counter extends CheckedRunnable {
279 <        final AtomicLongArray ai;
280 <        volatile long counts;
281 <        Counter(AtomicLongArray a) { ai = a; }
279 >        final AtomicLongArray aa;
280 >        int decs;
281 >        Counter(AtomicLongArray a) { aa = a; }
282          public void realRun() {
283              for (;;) {
284                  boolean done = true;
285 <                for (int i = 0; i < ai.length(); ++i) {
286 <                    long v = ai.get(i);
285 >                for (int i = 0; i < aa.length(); i++) {
286 >                    long v = aa.get(i);
287                      assertTrue(v >= 0);
288                      if (v != 0) {
289                          done = false;
290 <                        if (ai.compareAndSet(i, v, v-1))
291 <                            ++counts;
290 >                        if (aa.compareAndSet(i, v, v - 1))
291 >                            decs++;
292                      }
293                  }
294                  if (done)
# Line 290 | Line 302 | public class AtomicLongArrayTest extends
302       * update a number of times equal to total count
303       */
304      public void testCountingInMultipleThreads() throws InterruptedException {
305 <        final AtomicLongArray ai = new AtomicLongArray(SIZE);
306 <        for (int i = 0; i < SIZE; ++i)
307 <            ai.set(i, COUNTDOWN);
308 <        Counter c1 = new Counter(ai);
309 <        Counter c2 = new Counter(ai);
310 <        Thread t1 = new Thread(c1);
311 <        Thread t2 = new Thread(c2);
312 <        t1.start();
301 <        t2.start();
305 >        final AtomicLongArray aa = new AtomicLongArray(SIZE);
306 >        long countdown = 10000;
307 >        for (int i = 0; i < SIZE; i++)
308 >            aa.set(i, countdown);
309 >        Counter c1 = new Counter(aa);
310 >        Counter c2 = new Counter(aa);
311 >        Thread t1 = newStartedThread(c1);
312 >        Thread t2 = newStartedThread(c2);
313          t1.join();
314          t2.join();
315 <        assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN);
315 >        assertEquals(c1.decs + c2.decs, SIZE * countdown);
316      }
317  
318      /**
319 <     * a deserialized serialized array holds same values
319 >     * a deserialized/reserialized array holds same values in same order
320       */
321      public void testSerialization() throws Exception {
322          AtomicLongArray x = new AtomicLongArray(SIZE);
323 <        for (int i = 0; i < SIZE; ++i)
323 >        for (int i = 0; i < SIZE; i++)
324              x.set(i, -i);
325          AtomicLongArray y = serialClone(x);
326 <        assertTrue(x != y);
326 >        assertNotSame(x, y);
327          assertEquals(x.length(), y.length());
328 <        for (int i = 0; i < SIZE; ++i) {
328 >        for (int i = 0; i < SIZE; i++) {
329              assertEquals(x.get(i), y.get(i));
330          }
331      }
# Line 324 | Line 335 | public class AtomicLongArrayTest extends
335       */
336      public void testToString() {
337          long[] a = { 17, 3, -42, 99, -7 };
338 <        AtomicLongArray ai = new AtomicLongArray(a);
339 <        assertEquals(Arrays.toString(a), ai.toString());
338 >        AtomicLongArray aa = new AtomicLongArray(a);
339 >        assertEquals(Arrays.toString(a), aa.toString());
340      }
341  
342   }

Diff Legend

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