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.14 by jsr166, Tue Nov 17 06:58:50 2009 UTC vs.
Revision 1.24 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.AtomicLongArray;
12  
13   public class AtomicLongArrayTest extends JSR166TestCase {
14 <    public static void main (String[] args) {
15 <        junit.textui.TestRunner.run (suite());
14 >    public static void main(String[] args) {
15 >        junit.textui.TestRunner.run(suite());
16      }
17      public static Test suite() {
18          return new TestSuite(AtomicLongArrayTest.class);
# Line 25 | Line 24 | public class AtomicLongArrayTest extends
24      public void testConstructor() {
25          AtomicLongArray ai = new AtomicLongArray(SIZE);
26          for (int i = 0; i < SIZE; ++i)
27 <            assertEquals(0,ai.get(i));
27 >            assertEquals(0, ai.get(i));
28      }
29  
30      /**
# Line 43 | Line 42 | public class AtomicLongArrayTest extends
42       * constructor with array is of same size and has all elements
43       */
44      public void testConstructor2() {
45 <        long[] a = { 17L, 3L, -42L, 99L, -7L};
45 >        long[] a = { 17L, 3L, -42L, 99L, -7L };
46          AtomicLongArray ai = new AtomicLongArray(a);
47          assertEquals(a.length, ai.length());
48          for (int i = 0; i < a.length; ++i)
# Line 84 | Line 83 | public class AtomicLongArrayTest extends
83          AtomicLongArray ai = new AtomicLongArray(SIZE);
84          for (int i = 0; i < SIZE; ++i) {
85              ai.set(i, 1);
86 <            assertEquals(1,ai.get(i));
86 >            assertEquals(1, ai.get(i));
87              ai.set(i, 2);
88 <            assertEquals(2,ai.get(i));
88 >            assertEquals(2, ai.get(i));
89              ai.set(i, -3);
90 <            assertEquals(-3,ai.get(i));
90 >            assertEquals(-3, ai.get(i));
91          }
92      }
93  
# Line 99 | Line 98 | public class AtomicLongArrayTest extends
98          AtomicLongArray ai = new AtomicLongArray(SIZE);
99          for (int i = 0; i < SIZE; ++i) {
100              ai.lazySet(i, 1);
101 <            assertEquals(1,ai.get(i));
101 >            assertEquals(1, ai.get(i));
102              ai.lazySet(i, 2);
103 <            assertEquals(2,ai.get(i));
103 >            assertEquals(2, ai.get(i));
104              ai.lazySet(i, -3);
105 <            assertEquals(-3,ai.get(i));
105 >            assertEquals(-3, ai.get(i));
106          }
107      }
108  
# Line 114 | Line 113 | public class AtomicLongArrayTest extends
113          AtomicLongArray ai = new AtomicLongArray(SIZE);
114          for (int i = 0; i < SIZE; ++i) {
115              ai.set(i, 1);
116 <            assertTrue(ai.compareAndSet(i, 1,2));
117 <            assertTrue(ai.compareAndSet(i, 2,-4));
118 <            assertEquals(-4,ai.get(i));
119 <            assertFalse(ai.compareAndSet(i, -5,7));
120 <            assertFalse((7 == ai.get(i)));
121 <            assertTrue(ai.compareAndSet(i, -4,7));
122 <            assertEquals(7,ai.get(i));
116 >            assertTrue(ai.compareAndSet(i, 1, 2));
117 >            assertTrue(ai.compareAndSet(i, 2, -4));
118 >            assertEquals(-4, ai.get(i));
119 >            assertFalse(ai.compareAndSet(i, -5, 7));
120 >            assertEquals(-4, ai.get(i));
121 >            assertTrue(ai.compareAndSet(i, -4, 7));
122 >            assertEquals(7, ai.get(i));
123          }
124      }
125  
# Line 141 | Line 140 | public class AtomicLongArrayTest extends
140          assertTrue(a.compareAndSet(0, 1, 2));
141          t.join(LONG_DELAY_MS);
142          assertFalse(t.isAlive());
143 <        assertEquals(a.get(0), 3);
143 >        assertEquals(3, a.get(0));
144      }
145  
146      /**
# Line 152 | Line 151 | public class AtomicLongArrayTest extends
151          AtomicLongArray ai = new AtomicLongArray(SIZE);
152          for (int i = 0; i < SIZE; ++i) {
153              ai.set(i, 1);
154 <            while (!ai.weakCompareAndSet(i, 1,2));
155 <            while (!ai.weakCompareAndSet(i, 2,-4));
156 <            assertEquals(-4,ai.get(i));
157 <            while (!ai.weakCompareAndSet(i, -4,7));
158 <            assertEquals(7,ai.get(i));
154 >            while (!ai.weakCompareAndSet(i, 1, 2));
155 >            while (!ai.weakCompareAndSet(i, 2, -4));
156 >            assertEquals(-4, ai.get(i));
157 >            while (!ai.weakCompareAndSet(i, -4, 7));
158 >            assertEquals(7, ai.get(i));
159          }
160      }
161  
162      /**
163 <     *  getAndSet returns previous value and sets to given value at given index
163 >     * getAndSet returns previous value and sets to given value at given index
164       */
165      public void testGetAndSet() {
166          AtomicLongArray ai = new AtomicLongArray(SIZE);
167          for (int i = 0; i < SIZE; ++i) {
168              ai.set(i, 1);
169 <            assertEquals(1,ai.getAndSet(i,0));
170 <            assertEquals(0,ai.getAndSet(i,-10));
171 <            assertEquals(-10,ai.getAndSet(i,1));
169 >            assertEquals(1, ai.getAndSet(i, 0));
170 >            assertEquals(0, ai.getAndSet(i, -10));
171 >            assertEquals(-10, ai.getAndSet(i, 1));
172          }
173      }
174  
175      /**
176 <     *  getAndAdd returns previous value and adds given value
176 >     * getAndAdd returns previous value and adds given value
177       */
178      public void testGetAndAdd() {
179          AtomicLongArray ai = new AtomicLongArray(SIZE);
180          for (int i = 0; i < SIZE; ++i) {
181              ai.set(i, 1);
182 <            assertEquals(1,ai.getAndAdd(i,2));
183 <            assertEquals(3,ai.get(i));
184 <            assertEquals(3,ai.getAndAdd(i,-4));
185 <            assertEquals(-1,ai.get(i));
182 >            assertEquals(1, ai.getAndAdd(i, 2));
183 >            assertEquals(3, ai.get(i));
184 >            assertEquals(3, ai.getAndAdd(i, -4));
185 >            assertEquals(-1, ai.get(i));
186          }
187      }
188  
# Line 194 | Line 193 | public class AtomicLongArrayTest extends
193          AtomicLongArray ai = new AtomicLongArray(SIZE);
194          for (int i = 0; i < SIZE; ++i) {
195              ai.set(i, 1);
196 <            assertEquals(1,ai.getAndDecrement(i));
197 <            assertEquals(0,ai.getAndDecrement(i));
198 <            assertEquals(-1,ai.getAndDecrement(i));
196 >            assertEquals(1, ai.getAndDecrement(i));
197 >            assertEquals(0, ai.getAndDecrement(i));
198 >            assertEquals(-1, ai.getAndDecrement(i));
199          }
200      }
201  
# Line 207 | Line 206 | public class AtomicLongArrayTest extends
206          AtomicLongArray ai = new AtomicLongArray(SIZE);
207          for (int i = 0; i < SIZE; ++i) {
208              ai.set(i, 1);
209 <            assertEquals(1,ai.getAndIncrement(i));
210 <            assertEquals(2,ai.get(i));
211 <            ai.set(i,-2);
212 <            assertEquals(-2,ai.getAndIncrement(i));
213 <            assertEquals(-1,ai.getAndIncrement(i));
214 <            assertEquals(0,ai.getAndIncrement(i));
215 <            assertEquals(1,ai.get(i));
209 >            assertEquals(1, ai.getAndIncrement(i));
210 >            assertEquals(2, ai.get(i));
211 >            ai.set(i, -2);
212 >            assertEquals(-2, ai.getAndIncrement(i));
213 >            assertEquals(-1, ai.getAndIncrement(i));
214 >            assertEquals(0, ai.getAndIncrement(i));
215 >            assertEquals(1, ai.get(i));
216          }
217      }
218  
219      /**
220 <     *  addAndGet adds given value to current, and returns current value
220 >     * addAndGet adds given value to current, and returns current value
221       */
222      public void testAddAndGet() {
223          AtomicLongArray ai = new AtomicLongArray(SIZE);
224          for (int i = 0; i < SIZE; ++i) {
225              ai.set(i, 1);
226 <            assertEquals(3,ai.addAndGet(i,2));
227 <            assertEquals(3,ai.get(i));
228 <            assertEquals(-1,ai.addAndGet(i,-4));
229 <            assertEquals(-1,ai.get(i));
226 >            assertEquals(3, ai.addAndGet(i, 2));
227 >            assertEquals(3, ai.get(i));
228 >            assertEquals(-1, ai.addAndGet(i, -4));
229 >            assertEquals(-1, ai.get(i));
230          }
231      }
232  
# Line 238 | Line 237 | public class AtomicLongArrayTest extends
237          AtomicLongArray ai = new AtomicLongArray(SIZE);
238          for (int i = 0; i < SIZE; ++i) {
239              ai.set(i, 1);
240 <            assertEquals(0,ai.decrementAndGet(i));
241 <            assertEquals(-1,ai.decrementAndGet(i));
242 <            assertEquals(-2,ai.decrementAndGet(i));
243 <            assertEquals(-2,ai.get(i));
240 >            assertEquals(0, ai.decrementAndGet(i));
241 >            assertEquals(-1, ai.decrementAndGet(i));
242 >            assertEquals(-2, ai.decrementAndGet(i));
243 >            assertEquals(-2, ai.get(i));
244          }
245      }
246  
# Line 252 | Line 251 | public class AtomicLongArrayTest extends
251          AtomicLongArray ai = new AtomicLongArray(SIZE);
252          for (int i = 0; i < SIZE; ++i) {
253              ai.set(i, 1);
254 <            assertEquals(2,ai.incrementAndGet(i));
255 <            assertEquals(2,ai.get(i));
254 >            assertEquals(2, ai.incrementAndGet(i));
255 >            assertEquals(2, ai.get(i));
256              ai.set(i, -2);
257 <            assertEquals(-1,ai.incrementAndGet(i));
258 <            assertEquals(0,ai.incrementAndGet(i));
259 <            assertEquals(1,ai.incrementAndGet(i));
260 <            assertEquals(1,ai.get(i));
257 >            assertEquals(-1, ai.incrementAndGet(i));
258 >            assertEquals(0, ai.incrementAndGet(i));
259 >            assertEquals(1, ai.incrementAndGet(i));
260 >            assertEquals(1, ai.get(i));
261          }
262      }
263  
264      static final long COUNTDOWN = 100000;
265  
266 <    class Counter implements Runnable {
266 >    class Counter extends CheckedRunnable {
267          final AtomicLongArray ai;
268          volatile long counts;
269          Counter(AtomicLongArray a) { ai = a; }
270 <        public void run() {
270 >        public void realRun() {
271              for (;;) {
272                  boolean done = true;
273                  for (int i = 0; i < ai.length(); ++i) {
274                      long v = ai.get(i);
275 <                    threadAssertTrue(v >= 0);
275 >                    assertTrue(v >= 0);
276                      if (v != 0) {
277                          done = false;
278                          if (ai.compareAndSet(i, v, v-1))
# Line 309 | Line 308 | public class AtomicLongArrayTest extends
308       * a deserialized serialized array holds same values
309       */
310      public void testSerialization() throws Exception {
311 <        AtomicLongArray l = new AtomicLongArray(SIZE);
311 >        AtomicLongArray x = new AtomicLongArray(SIZE);
312          for (int i = 0; i < SIZE; ++i)
313 <            l.set(i, -i);
314 <
315 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
316 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
318 <        out.writeObject(l);
319 <        out.close();
320 <
321 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
322 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
323 <        AtomicLongArray r = (AtomicLongArray) in.readObject();
313 >            x.set(i, -i);
314 >        AtomicLongArray y = serialClone(x);
315 >        assertTrue(x != y);
316 >        assertEquals(x.length(), y.length());
317          for (int i = 0; i < SIZE; ++i) {
318 <            assertEquals(l.get(i), r.get(i));
318 >            assertEquals(x.get(i), y.get(i));
319          }
320      }
321  
# Line 330 | Line 323 | public class AtomicLongArrayTest extends
323       * toString returns current value.
324       */
325      public void testToString() {
326 <        long[] a = { 17, 3, -42, 99, -7};
326 >        long[] a = { 17, 3, -42, 99, -7 };
327          AtomicLongArray ai = new AtomicLongArray(a);
328          assertEquals(Arrays.toString(a), ai.toString());
329      }
330  
338 –
331   }

Diff Legend

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