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

Comparing jsr166/src/test/tck/AtomicIntegerArrayTest.java (file contents):
Revision 1.17 by jsr166, Wed Aug 25 00:07:03 2010 UTC vs.
Revision 1.25 by jsr166, Fri Jun 10 20:17:11 2011 UTC

# Line 1 | Line 1
1   /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.
7   */
8  
9   import junit.framework.*;
10 < import java.util.concurrent.atomic.*;
11 < import java.io.*;
12 < import java.util.*;
10 > import java.util.Arrays;
11 > import java.util.concurrent.atomic.AtomicIntegerArray;
12  
13   public class AtomicIntegerArrayTest extends JSR166TestCase {
14  
# Line 20 | Line 19 | public class AtomicIntegerArrayTest exte
19          return new TestSuite(AtomicIntegerArrayTest.class);
20      }
21  
23 –
22      /**
23       * constructor creates array of given size with all elements zero
24       */
25      public void testConstructor() {
26          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
27          for (int i = 0; i < SIZE; ++i)
28 <            assertEquals(0,ai.get(i));
28 >            assertEquals(0, ai.get(i));
29      }
30  
31      /**
# Line 45 | Line 43 | public class AtomicIntegerArrayTest exte
43       * constructor with array is of same size and has all elements
44       */
45      public void testConstructor2() {
46 <        int[] a = { 17, 3, -42, 99, -7};
46 >        int[] a = { 17, 3, -42, 99, -7 };
47          AtomicIntegerArray ai = new AtomicIntegerArray(a);
48          assertEquals(a.length, ai.length());
49          for (int i = 0; i < a.length; ++i)
# Line 86 | Line 84 | public class AtomicIntegerArrayTest exte
84          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
85          for (int i = 0; i < SIZE; ++i) {
86              ai.set(i, 1);
87 <            assertEquals(1,ai.get(i));
87 >            assertEquals(1, ai.get(i));
88              ai.set(i, 2);
89 <            assertEquals(2,ai.get(i));
89 >            assertEquals(2, ai.get(i));
90              ai.set(i, -3);
91 <            assertEquals(-3,ai.get(i));
91 >            assertEquals(-3, ai.get(i));
92          }
93      }
94  
# Line 101 | Line 99 | public class AtomicIntegerArrayTest exte
99          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
100          for (int i = 0; i < SIZE; ++i) {
101              ai.lazySet(i, 1);
102 <            assertEquals(1,ai.get(i));
102 >            assertEquals(1, ai.get(i));
103              ai.lazySet(i, 2);
104 <            assertEquals(2,ai.get(i));
104 >            assertEquals(2, ai.get(i));
105              ai.lazySet(i, -3);
106 <            assertEquals(-3,ai.get(i));
106 >            assertEquals(-3, ai.get(i));
107          }
108      }
109  
# Line 116 | Line 114 | public class AtomicIntegerArrayTest exte
114          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
115          for (int i = 0; i < SIZE; ++i) {
116              ai.set(i, 1);
117 <            assertTrue(ai.compareAndSet(i, 1,2));
118 <            assertTrue(ai.compareAndSet(i, 2,-4));
119 <            assertEquals(-4,ai.get(i));
120 <            assertFalse(ai.compareAndSet(i, -5,7));
121 <            assertEquals(-4,ai.get(i));
122 <            assertTrue(ai.compareAndSet(i, -4,7));
123 <            assertEquals(7,ai.get(i));
117 >            assertTrue(ai.compareAndSet(i, 1, 2));
118 >            assertTrue(ai.compareAndSet(i, 2, -4));
119 >            assertEquals(-4, ai.get(i));
120 >            assertFalse(ai.compareAndSet(i, -5, 7));
121 >            assertEquals(-4, ai.get(i));
122 >            assertTrue(ai.compareAndSet(i, -4, 7));
123 >            assertEquals(7, ai.get(i));
124          }
125      }
126  
# Line 143 | Line 141 | public class AtomicIntegerArrayTest exte
141          assertTrue(a.compareAndSet(0, 1, 2));
142          t.join(LONG_DELAY_MS);
143          assertFalse(t.isAlive());
144 <        assertEquals(a.get(0), 3);
144 >        assertEquals(3, a.get(0));
145      }
146  
147      /**
# Line 154 | Line 152 | public class AtomicIntegerArrayTest exte
152          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
153          for (int i = 0; i < SIZE; ++i) {
154              ai.set(i, 1);
155 <            while (!ai.weakCompareAndSet(i, 1,2));
156 <            while (!ai.weakCompareAndSet(i, 2,-4));
157 <            assertEquals(-4,ai.get(i));
158 <            while (!ai.weakCompareAndSet(i, -4,7));
159 <            assertEquals(7,ai.get(i));
155 >            while (!ai.weakCompareAndSet(i, 1, 2));
156 >            while (!ai.weakCompareAndSet(i, 2, -4));
157 >            assertEquals(-4, ai.get(i));
158 >            while (!ai.weakCompareAndSet(i, -4, 7));
159 >            assertEquals(7, ai.get(i));
160          }
161      }
162  
163      /**
164 <     *  getAndSet returns previous value and sets to given value at given index
164 >     * getAndSet returns previous value and sets to given value at given index
165       */
166      public void testGetAndSet() {
167          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
168          for (int i = 0; i < SIZE; ++i) {
169              ai.set(i, 1);
170 <            assertEquals(1,ai.getAndSet(i,0));
171 <            assertEquals(0,ai.getAndSet(i,-10));
172 <            assertEquals(-10,ai.getAndSet(i,1));
170 >            assertEquals(1, ai.getAndSet(i, 0));
171 >            assertEquals(0, ai.getAndSet(i, -10));
172 >            assertEquals(-10, ai.getAndSet(i, 1));
173          }
174      }
175  
176      /**
177 <     *  getAndAdd returns previous value and adds given value
177 >     * getAndAdd returns previous value and adds given value
178       */
179      public void testGetAndAdd() {
180          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
181          for (int i = 0; i < SIZE; ++i) {
182              ai.set(i, 1);
183 <            assertEquals(1,ai.getAndAdd(i,2));
184 <            assertEquals(3,ai.get(i));
185 <            assertEquals(3,ai.getAndAdd(i,-4));
186 <            assertEquals(-1,ai.get(i));
183 >            assertEquals(1, ai.getAndAdd(i, 2));
184 >            assertEquals(3, ai.get(i));
185 >            assertEquals(3, ai.getAndAdd(i, -4));
186 >            assertEquals(-1, ai.get(i));
187          }
188      }
189  
# Line 196 | Line 194 | public class AtomicIntegerArrayTest exte
194          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
195          for (int i = 0; i < SIZE; ++i) {
196              ai.set(i, 1);
197 <            assertEquals(1,ai.getAndDecrement(i));
198 <            assertEquals(0,ai.getAndDecrement(i));
199 <            assertEquals(-1,ai.getAndDecrement(i));
197 >            assertEquals(1, ai.getAndDecrement(i));
198 >            assertEquals(0, ai.getAndDecrement(i));
199 >            assertEquals(-1, ai.getAndDecrement(i));
200          }
201      }
202  
# Line 209 | Line 207 | public class AtomicIntegerArrayTest exte
207          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
208          for (int i = 0; i < SIZE; ++i) {
209              ai.set(i, 1);
210 <            assertEquals(1,ai.getAndIncrement(i));
211 <            assertEquals(2,ai.get(i));
212 <            ai.set(i,-2);
213 <            assertEquals(-2,ai.getAndIncrement(i));
214 <            assertEquals(-1,ai.getAndIncrement(i));
215 <            assertEquals(0,ai.getAndIncrement(i));
216 <            assertEquals(1,ai.get(i));
210 >            assertEquals(1, ai.getAndIncrement(i));
211 >            assertEquals(2, ai.get(i));
212 >            ai.set(i, -2);
213 >            assertEquals(-2, ai.getAndIncrement(i));
214 >            assertEquals(-1, ai.getAndIncrement(i));
215 >            assertEquals(0, ai.getAndIncrement(i));
216 >            assertEquals(1, ai.get(i));
217          }
218      }
219  
220      /**
221 <     *  addAndGet adds given value to current, and returns current value
221 >     * addAndGet adds given value to current, and returns current value
222       */
223      public void testAddAndGet() {
224          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
225          for (int i = 0; i < SIZE; ++i) {
226              ai.set(i, 1);
227 <            assertEquals(3,ai.addAndGet(i,2));
228 <            assertEquals(3,ai.get(i));
229 <            assertEquals(-1,ai.addAndGet(i,-4));
230 <            assertEquals(-1,ai.get(i));
227 >            assertEquals(3, ai.addAndGet(i, 2));
228 >            assertEquals(3, ai.get(i));
229 >            assertEquals(-1, ai.addAndGet(i, -4));
230 >            assertEquals(-1, ai.get(i));
231          }
232      }
233  
# Line 240 | Line 238 | public class AtomicIntegerArrayTest exte
238          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
239          for (int i = 0; i < SIZE; ++i) {
240              ai.set(i, 1);
241 <            assertEquals(0,ai.decrementAndGet(i));
242 <            assertEquals(-1,ai.decrementAndGet(i));
243 <            assertEquals(-2,ai.decrementAndGet(i));
244 <            assertEquals(-2,ai.get(i));
241 >            assertEquals(0, ai.decrementAndGet(i));
242 >            assertEquals(-1, ai.decrementAndGet(i));
243 >            assertEquals(-2, ai.decrementAndGet(i));
244 >            assertEquals(-2, ai.get(i));
245          }
246      }
247  
248      /**
249 <     *  incrementAndGet increments and returns current value
249 >     * incrementAndGet increments and returns current value
250       */
251      public void testIncrementAndGet() {
252          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
253          for (int i = 0; i < SIZE; ++i) {
254              ai.set(i, 1);
255 <            assertEquals(2,ai.incrementAndGet(i));
256 <            assertEquals(2,ai.get(i));
255 >            assertEquals(2, ai.incrementAndGet(i));
256 >            assertEquals(2, ai.get(i));
257              ai.set(i, -2);
258 <            assertEquals(-1,ai.incrementAndGet(i));
259 <            assertEquals(0,ai.incrementAndGet(i));
260 <            assertEquals(1,ai.incrementAndGet(i));
261 <            assertEquals(1,ai.get(i));
258 >            assertEquals(-1, ai.incrementAndGet(i));
259 >            assertEquals(0, ai.incrementAndGet(i));
260 >            assertEquals(1, ai.incrementAndGet(i));
261 >            assertEquals(1, ai.get(i));
262          }
263      }
264  
265      static final int COUNTDOWN = 100000;
266  
267 <    class Counter implements Runnable {
267 >    class Counter extends CheckedRunnable {
268          final AtomicIntegerArray ai;
269          volatile int counts;
270          Counter(AtomicIntegerArray a) { ai = a; }
271 <        public void run() {
271 >        public void realRun() {
272              for (;;) {
273                  boolean done = true;
274                  for (int i = 0; i < ai.length(); ++i) {
275                      int v = ai.get(i);
276 <                    threadAssertTrue(v >= 0);
276 >                    assertTrue(v >= 0);
277                      if (v != 0) {
278                          done = false;
279                          if (ai.compareAndSet(i, v, v-1))
# Line 307 | Line 305 | public class AtomicIntegerArrayTest exte
305          assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN);
306      }
307  
310 –
308      /**
309       * a deserialized serialized array holds same values
310       */
311      public void testSerialization() throws Exception {
312 <        AtomicIntegerArray l = new AtomicIntegerArray(SIZE);
313 <        for (int i = 0; i < SIZE; ++i)
314 <            l.set(i, -i);
315 <
316 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
317 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
318 <        out.writeObject(l);
319 <        out.close();
323 <
324 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
325 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
326 <        AtomicIntegerArray r = (AtomicIntegerArray) in.readObject();
327 <        for (int i = 0; i < SIZE; ++i) {
328 <            assertEquals(l.get(i), r.get(i));
312 >        AtomicIntegerArray x = new AtomicIntegerArray(SIZE);
313 >        for (int i = 0; i < SIZE; i++)
314 >            x.set(i, -i);
315 >        AtomicIntegerArray y = serialClone(x);
316 >        assertTrue(x != y);
317 >        assertEquals(x.length(), y.length());
318 >        for (int i = 0; i < SIZE; i++) {
319 >            assertEquals(x.get(i), y.get(i));
320          }
321      }
322  
332 –
323      /**
324       * toString returns current value.
325       */
326      public void testToString() {
327 <        int[] a = { 17, 3, -42, 99, -7};
327 >        int[] a = { 17, 3, -42, 99, -7 };
328          AtomicIntegerArray ai = new AtomicIntegerArray(a);
329          assertEquals(Arrays.toString(a), ai.toString());
330      }

Diff Legend

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