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.35 by jsr166, Fri Jun 17 19:00:48 2016 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      public void testIndexing() {
58 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
59 <        try {
60 <            ai.get(SIZE);
61 <            shouldThrow();
62 <        } catch (IndexOutOfBoundsException success) {
63 <        }
64 <        try {
65 <            ai.get(-1);
66 <            shouldThrow();
67 <        } catch (IndexOutOfBoundsException success) {
68 <        }
69 <        try {
70 <            ai.set(SIZE, 0);
71 <            shouldThrow();
72 <        } catch (IndexOutOfBoundsException success) {
73 <        }
74 <        try {
75 <            ai.set(-1, 0);
76 <            shouldThrow();
77 <        } catch (IndexOutOfBoundsException success) {
58 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
59 >        for (int index : new int[] { -1, SIZE }) {
60 >            try {
61 >                aa.get(index);
62 >                shouldThrow();
63 >            } catch (IndexOutOfBoundsException success) {}
64 >            try {
65 >                aa.set(index, 1);
66 >                shouldThrow();
67 >            } catch (IndexOutOfBoundsException success) {}
68 >            try {
69 >                aa.lazySet(index, 1);
70 >                shouldThrow();
71 >            } catch (IndexOutOfBoundsException success) {}
72 >            try {
73 >                aa.compareAndSet(index, 1, 2);
74 >                shouldThrow();
75 >            } catch (IndexOutOfBoundsException success) {}
76 >            try {
77 >                aa.weakCompareAndSet(index, 1, 2);
78 >                shouldThrow();
79 >            } catch (IndexOutOfBoundsException success) {}
80 >            try {
81 >                aa.getAndAdd(index, 1);
82 >                shouldThrow();
83 >            } catch (IndexOutOfBoundsException success) {}
84 >            try {
85 >                aa.addAndGet(index, 1);
86 >                shouldThrow();
87 >            } catch (IndexOutOfBoundsException success) {}
88          }
89      }
90  
# Line 80 | Line 92 | public class AtomicLongArrayTest extends
92       * get returns the last value set at index
93       */
94      public void testGetSet() {
95 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
96 <        for (int i = 0; i < SIZE; ++i) {
97 <            ai.set(i, 1);
98 <            assertEquals(1, ai.get(i));
99 <            ai.set(i, 2);
100 <            assertEquals(2, ai.get(i));
101 <            ai.set(i, -3);
102 <            assertEquals(-3, ai.get(i));
95 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
96 >        for (int i = 0; i < SIZE; i++) {
97 >            aa.set(i, 1);
98 >            assertEquals(1, aa.get(i));
99 >            aa.set(i, 2);
100 >            assertEquals(2, aa.get(i));
101 >            aa.set(i, -3);
102 >            assertEquals(-3, aa.get(i));
103          }
104      }
105  
# Line 95 | Line 107 | public class AtomicLongArrayTest extends
107       * get returns the last value lazySet at index by same thread
108       */
109      public void testGetLazySet() {
110 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
111 <        for (int i = 0; i < SIZE; ++i) {
112 <            ai.lazySet(i, 1);
113 <            assertEquals(1, ai.get(i));
114 <            ai.lazySet(i, 2);
115 <            assertEquals(2, ai.get(i));
116 <            ai.lazySet(i, -3);
117 <            assertEquals(-3, ai.get(i));
110 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
111 >        for (int i = 0; i < SIZE; i++) {
112 >            aa.lazySet(i, 1);
113 >            assertEquals(1, aa.get(i));
114 >            aa.lazySet(i, 2);
115 >            assertEquals(2, aa.get(i));
116 >            aa.lazySet(i, -3);
117 >            assertEquals(-3, aa.get(i));
118          }
119      }
120  
# Line 110 | Line 122 | public class AtomicLongArrayTest extends
122       * compareAndSet succeeds in changing value if equal to expected else fails
123       */
124      public void testCompareAndSet() {
125 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
126 <        for (int i = 0; i < SIZE; ++i) {
127 <            ai.set(i, 1);
128 <            assertTrue(ai.compareAndSet(i, 1, 2));
129 <            assertTrue(ai.compareAndSet(i, 2, -4));
130 <            assertEquals(-4, ai.get(i));
131 <            assertFalse(ai.compareAndSet(i, -5, 7));
132 <            assertEquals(-4, ai.get(i));
133 <            assertTrue(ai.compareAndSet(i, -4, 7));
134 <            assertEquals(7, ai.get(i));
125 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
126 >        for (int i = 0; i < SIZE; i++) {
127 >            aa.set(i, 1);
128 >            assertTrue(aa.compareAndSet(i, 1, 2));
129 >            assertTrue(aa.compareAndSet(i, 2, -4));
130 >            assertEquals(-4, aa.get(i));
131 >            assertFalse(aa.compareAndSet(i, -5, 7));
132 >            assertEquals(-4, aa.get(i));
133 >            assertTrue(aa.compareAndSet(i, -4, 7));
134 >            assertEquals(7, aa.get(i));
135          }
136      }
137  
# Line 140 | Line 152 | public class AtomicLongArrayTest extends
152          assertTrue(a.compareAndSet(0, 1, 2));
153          t.join(LONG_DELAY_MS);
154          assertFalse(t.isAlive());
155 <        assertEquals(a.get(0), 3);
155 >        assertEquals(3, a.get(0));
156      }
157  
158      /**
# Line 148 | Line 160 | public class AtomicLongArrayTest extends
160       * to expected
161       */
162      public void testWeakCompareAndSet() {
163 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
164 <        for (int i = 0; i < SIZE; ++i) {
165 <            ai.set(i, 1);
166 <            while (!ai.weakCompareAndSet(i, 1, 2));
167 <            while (!ai.weakCompareAndSet(i, 2, -4));
168 <            assertEquals(-4, ai.get(i));
169 <            while (!ai.weakCompareAndSet(i, -4, 7));
170 <            assertEquals(7, ai.get(i));
163 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
164 >        for (int i = 0; i < SIZE; i++) {
165 >            aa.set(i, 1);
166 >            do {} while (!aa.weakCompareAndSet(i, 1, 2));
167 >            do {} while (!aa.weakCompareAndSet(i, 2, -4));
168 >            assertEquals(-4, aa.get(i));
169 >            do {} while (!aa.weakCompareAndSet(i, -4, 7));
170 >            assertEquals(7, aa.get(i));
171          }
172      }
173  
# Line 163 | Line 175 | public class AtomicLongArrayTest extends
175       * getAndSet returns previous value and sets to given value at given index
176       */
177      public void testGetAndSet() {
178 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
179 <        for (int i = 0; i < SIZE; ++i) {
180 <            ai.set(i, 1);
181 <            assertEquals(1, ai.getAndSet(i, 0));
182 <            assertEquals(0, ai.getAndSet(i, -10));
183 <            assertEquals(-10, ai.getAndSet(i, 1));
178 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
179 >        for (int i = 0; i < SIZE; i++) {
180 >            aa.set(i, 1);
181 >            assertEquals(1, aa.getAndSet(i, 0));
182 >            assertEquals(0, aa.getAndSet(i, -10));
183 >            assertEquals(-10, aa.getAndSet(i, 1));
184          }
185      }
186  
# Line 176 | Line 188 | public class AtomicLongArrayTest extends
188       * getAndAdd returns previous value and adds given value
189       */
190      public void testGetAndAdd() {
191 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
192 <        for (int i = 0; i < SIZE; ++i) {
193 <            ai.set(i, 1);
194 <            assertEquals(1, ai.getAndAdd(i, 2));
195 <            assertEquals(3, ai.get(i));
196 <            assertEquals(3, ai.getAndAdd(i, -4));
197 <            assertEquals(-1, ai.get(i));
191 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
192 >        for (int i = 0; i < SIZE; i++) {
193 >            aa.set(i, 1);
194 >            assertEquals(1, aa.getAndAdd(i, 2));
195 >            assertEquals(3, aa.get(i));
196 >            assertEquals(3, aa.getAndAdd(i, -4));
197 >            assertEquals(-1, aa.get(i));
198          }
199      }
200  
# Line 190 | Line 202 | public class AtomicLongArrayTest extends
202       * getAndDecrement returns previous value and decrements
203       */
204      public void testGetAndDecrement() {
205 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
206 <        for (int i = 0; i < SIZE; ++i) {
207 <            ai.set(i, 1);
208 <            assertEquals(1, ai.getAndDecrement(i));
209 <            assertEquals(0, ai.getAndDecrement(i));
210 <            assertEquals(-1, ai.getAndDecrement(i));
205 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
206 >        for (int i = 0; i < SIZE; i++) {
207 >            aa.set(i, 1);
208 >            assertEquals(1, aa.getAndDecrement(i));
209 >            assertEquals(0, aa.getAndDecrement(i));
210 >            assertEquals(-1, aa.getAndDecrement(i));
211          }
212      }
213  
# Line 203 | Line 215 | public class AtomicLongArrayTest extends
215       * getAndIncrement returns previous value and increments
216       */
217      public void testGetAndIncrement() {
218 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
219 <        for (int i = 0; i < SIZE; ++i) {
220 <            ai.set(i, 1);
221 <            assertEquals(1, ai.getAndIncrement(i));
222 <            assertEquals(2, ai.get(i));
223 <            ai.set(i, -2);
224 <            assertEquals(-2, ai.getAndIncrement(i));
225 <            assertEquals(-1, ai.getAndIncrement(i));
226 <            assertEquals(0, ai.getAndIncrement(i));
227 <            assertEquals(1, ai.get(i));
218 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
219 >        for (int i = 0; i < SIZE; i++) {
220 >            aa.set(i, 1);
221 >            assertEquals(1, aa.getAndIncrement(i));
222 >            assertEquals(2, aa.get(i));
223 >            aa.set(i, -2);
224 >            assertEquals(-2, aa.getAndIncrement(i));
225 >            assertEquals(-1, aa.getAndIncrement(i));
226 >            assertEquals(0, aa.getAndIncrement(i));
227 >            assertEquals(1, aa.get(i));
228          }
229      }
230  
# Line 220 | Line 232 | public class AtomicLongArrayTest extends
232       * addAndGet adds given value to current, and returns current value
233       */
234      public void testAddAndGet() {
235 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
236 <        for (int i = 0; i < SIZE; ++i) {
237 <            ai.set(i, 1);
238 <            assertEquals(3, ai.addAndGet(i, 2));
239 <            assertEquals(3, ai.get(i));
240 <            assertEquals(-1, ai.addAndGet(i, -4));
241 <            assertEquals(-1, ai.get(i));
235 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
236 >        for (int i = 0; i < SIZE; i++) {
237 >            aa.set(i, 1);
238 >            assertEquals(3, aa.addAndGet(i, 2));
239 >            assertEquals(3, aa.get(i));
240 >            assertEquals(-1, aa.addAndGet(i, -4));
241 >            assertEquals(-1, aa.get(i));
242          }
243      }
244  
# Line 234 | Line 246 | public class AtomicLongArrayTest extends
246       * decrementAndGet decrements and returns current value
247       */
248      public void testDecrementAndGet() {
249 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
250 <        for (int i = 0; i < SIZE; ++i) {
251 <            ai.set(i, 1);
252 <            assertEquals(0, ai.decrementAndGet(i));
253 <            assertEquals(-1, ai.decrementAndGet(i));
254 <            assertEquals(-2, ai.decrementAndGet(i));
255 <            assertEquals(-2, ai.get(i));
249 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
250 >        for (int i = 0; i < SIZE; i++) {
251 >            aa.set(i, 1);
252 >            assertEquals(0, aa.decrementAndGet(i));
253 >            assertEquals(-1, aa.decrementAndGet(i));
254 >            assertEquals(-2, aa.decrementAndGet(i));
255 >            assertEquals(-2, aa.get(i));
256          }
257      }
258  
# Line 248 | Line 260 | public class AtomicLongArrayTest extends
260       * incrementAndGet increments and returns current value
261       */
262      public void testIncrementAndGet() {
263 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
264 <        for (int i = 0; i < SIZE; ++i) {
265 <            ai.set(i, 1);
266 <            assertEquals(2, ai.incrementAndGet(i));
267 <            assertEquals(2, ai.get(i));
268 <            ai.set(i, -2);
269 <            assertEquals(-1, ai.incrementAndGet(i));
270 <            assertEquals(0, ai.incrementAndGet(i));
271 <            assertEquals(1, ai.incrementAndGet(i));
272 <            assertEquals(1, ai.get(i));
263 >        AtomicLongArray aa = new AtomicLongArray(SIZE);
264 >        for (int i = 0; i < SIZE; i++) {
265 >            aa.set(i, 1);
266 >            assertEquals(2, aa.incrementAndGet(i));
267 >            assertEquals(2, aa.get(i));
268 >            aa.set(i, -2);
269 >            assertEquals(-1, aa.incrementAndGet(i));
270 >            assertEquals(0, aa.incrementAndGet(i));
271 >            assertEquals(1, aa.incrementAndGet(i));
272 >            assertEquals(1, aa.get(i));
273          }
274      }
275  
264 –    static final long COUNTDOWN = 100000;
265 –
276      class Counter extends CheckedRunnable {
277 <        final AtomicLongArray ai;
277 >        final AtomicLongArray aa;
278          volatile long counts;
279 <        Counter(AtomicLongArray a) { ai = a; }
279 >        Counter(AtomicLongArray a) { aa = a; }
280          public void realRun() {
281              for (;;) {
282                  boolean done = true;
283 <                for (int i = 0; i < ai.length(); ++i) {
284 <                    long v = ai.get(i);
283 >                for (int i = 0; i < aa.length(); i++) {
284 >                    long v = aa.get(i);
285                      assertTrue(v >= 0);
286                      if (v != 0) {
287                          done = false;
288 <                        if (ai.compareAndSet(i, v, v-1))
288 >                        if (aa.compareAndSet(i, v, v - 1))
289                              ++counts;
290                      }
291                  }
# Line 290 | Line 300 | public class AtomicLongArrayTest extends
300       * update a number of times equal to total count
301       */
302      public void testCountingInMultipleThreads() throws InterruptedException {
303 <        final AtomicLongArray ai = new AtomicLongArray(SIZE);
304 <        for (int i = 0; i < SIZE; ++i)
305 <            ai.set(i, COUNTDOWN);
306 <        Counter c1 = new Counter(ai);
307 <        Counter c2 = new Counter(ai);
303 >        final AtomicLongArray aa = new AtomicLongArray(SIZE);
304 >        long countdown = 10000;
305 >        for (int i = 0; i < SIZE; i++)
306 >            aa.set(i, countdown);
307 >        Counter c1 = new Counter(aa);
308 >        Counter c2 = new Counter(aa);
309          Thread t1 = new Thread(c1);
310          Thread t2 = new Thread(c2);
311          t1.start();
312          t2.start();
313          t1.join();
314          t2.join();
315 <        assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN);
315 >        assertEquals(c1.counts+c2.counts, SIZE * countdown);
316      }
317  
318      /**
# Line 309 | Line 320 | public class AtomicLongArrayTest extends
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