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.6 by dl, Sat Dec 27 19:26:43 2003 UTC vs.
Revision 1.20 by jsr166, Tue Mar 15 19:47:06 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
5 < * Other contributors include Andrew Wright, Jeffrey Hayes,
6 < * Pat Fisher, Mike Judd.
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.*;
13  
14   public class AtomicIntegerArrayTest extends JSR166TestCase {
15  
16 <    public static void main (String[] args) {
17 <        junit.textui.TestRunner.run (suite());
16 >    public static void main(String[] args) {
17 >        junit.textui.TestRunner.run(suite());
18      }
19      public static Test suite() {
20          return new TestSuite(AtomicIntegerArrayTest.class);
# Line 25 | Line 26 | public class AtomicIntegerArrayTest exte
26       */
27      public void testConstructor() {
28          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
29 <        for (int i = 0; i < SIZE; ++i)
29 >        for (int i = 0; i < SIZE; ++i)
30              assertEquals(0,ai.get(i));
31      }
32  
33      /**
34 +     * constructor with null array throws NPE
35 +     */
36 +    public void testConstructor2NPE() {
37 +        try {
38 +            int[] a = null;
39 +            AtomicIntegerArray ai = new AtomicIntegerArray(a);
40 +            shouldThrow();
41 +        } catch (NullPointerException success) {}
42 +    }
43 +
44 +    /**
45 +     * constructor with array is of same size and has all elements
46 +     */
47 +    public void testConstructor2() {
48 +        int[] a = { 17, 3, -42, 99, -7};
49 +        AtomicIntegerArray ai = new AtomicIntegerArray(a);
50 +        assertEquals(a.length, ai.length());
51 +        for (int i = 0; i < a.length; ++i)
52 +            assertEquals(a[i], ai.get(i));
53 +    }
54 +
55 +    /**
56       * get and set for out of bound indices throw IndexOutOfBoundsException
57       */
58 <    public void testIndexing(){
58 >    public void testIndexing() {
59          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
60          try {
61              ai.get(SIZE);
62 <        } catch(IndexOutOfBoundsException success){
62 >            shouldThrow();
63 >        } catch (IndexOutOfBoundsException success) {
64          }
65          try {
66              ai.get(-1);
67 <        } catch(IndexOutOfBoundsException success){
67 >            shouldThrow();
68 >        } catch (IndexOutOfBoundsException success) {
69          }
70          try {
71              ai.set(SIZE, 0);
72 <        } catch(IndexOutOfBoundsException success){
72 >            shouldThrow();
73 >        } catch (IndexOutOfBoundsException success) {
74          }
75          try {
76              ai.set(-1, 0);
77 <        } catch(IndexOutOfBoundsException success){
77 >            shouldThrow();
78 >        } catch (IndexOutOfBoundsException success) {
79          }
80      }
81  
# Line 56 | Line 83 | public class AtomicIntegerArrayTest exte
83       * get returns the last value set at index
84       */
85      public void testGetSet() {
86 <        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
86 >        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
87          for (int i = 0; i < SIZE; ++i) {
88              ai.set(i, 1);
89              assertEquals(1,ai.get(i));
# Line 68 | Line 95 | public class AtomicIntegerArrayTest exte
95      }
96  
97      /**
98 +     * get returns the last value lazySet at index by same thread
99 +     */
100 +    public void testGetLazySet() {
101 +        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
102 +        for (int i = 0; i < SIZE; ++i) {
103 +            ai.lazySet(i, 1);
104 +            assertEquals(1,ai.get(i));
105 +            ai.lazySet(i, 2);
106 +            assertEquals(2,ai.get(i));
107 +            ai.lazySet(i, -3);
108 +            assertEquals(-3,ai.get(i));
109 +        }
110 +    }
111 +
112 +    /**
113       * compareAndSet succeeds in changing value if equal to expected else fails
114       */
115      public void testCompareAndSet() {
116 <        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
116 >        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
117          for (int i = 0; i < SIZE; ++i) {
118              ai.set(i, 1);
119              assertTrue(ai.compareAndSet(i, 1,2));
120              assertTrue(ai.compareAndSet(i, 2,-4));
121              assertEquals(-4,ai.get(i));
122              assertFalse(ai.compareAndSet(i, -5,7));
123 <            assertFalse((7 == ai.get(i)));
123 >            assertEquals(-4,ai.get(i));
124              assertTrue(ai.compareAndSet(i, -4,7));
125              assertEquals(7,ai.get(i));
126          }
# Line 88 | Line 130 | public class AtomicIntegerArrayTest exte
130       * compareAndSet in one thread enables another waiting for value
131       * to succeed
132       */
133 <    public void testCompareAndSetInMultipleThreads() {
133 >    public void testCompareAndSetInMultipleThreads() throws Exception {
134          final AtomicIntegerArray a = new AtomicIntegerArray(1);
135          a.set(0, 1);
136 <        Thread t = new Thread(new Runnable() {
137 <                public void run() {
138 <                    while(!a.compareAndSet(0, 2, 3)) Thread.yield();
139 <                }});
140 <        try {
141 <            t.start();
142 <            assertTrue(a.compareAndSet(0, 1, 2));
143 <            t.join(LONG_DELAY_MS);
144 <            assertFalse(t.isAlive());
145 <            assertEquals(a.get(0), 3);
146 <        }
105 <        catch(Exception e) {
106 <            unexpectedException();
107 <        }
136 >        Thread t = new Thread(new CheckedRunnable() {
137 >            public void realRun() {
138 >                while (!a.compareAndSet(0, 2, 3))
139 >                    Thread.yield();
140 >            }});
141 >
142 >        t.start();
143 >        assertTrue(a.compareAndSet(0, 1, 2));
144 >        t.join(LONG_DELAY_MS);
145 >        assertFalse(t.isAlive());
146 >        assertEquals(a.get(0), 3);
147      }
148  
149      /**
150       * repeated weakCompareAndSet succeeds in changing value when equal
151 <     * to expected
151 >     * to expected
152       */
153      public void testWeakCompareAndSet() {
154 <        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
154 >        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
155          for (int i = 0; i < SIZE; ++i) {
156              ai.set(i, 1);
157 <            while(!ai.weakCompareAndSet(i, 1,2));
158 <            while(!ai.weakCompareAndSet(i, 2,-4));
157 >            while (!ai.weakCompareAndSet(i, 1,2));
158 >            while (!ai.weakCompareAndSet(i, 2,-4));
159              assertEquals(-4,ai.get(i));
160 <            while(!ai.weakCompareAndSet(i, -4,7));
160 >            while (!ai.weakCompareAndSet(i, -4,7));
161              assertEquals(7,ai.get(i));
162          }
163      }
164  
165      /**
166 <     *  getAndSet returns previous value and sets to given value at given index
166 >     * getAndSet returns previous value and sets to given value at given index
167       */
168      public void testGetAndSet() {
169 <        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
169 >        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
170          for (int i = 0; i < SIZE; ++i) {
171              ai.set(i, 1);
172              assertEquals(1,ai.getAndSet(i,0));
# Line 137 | Line 176 | public class AtomicIntegerArrayTest exte
176      }
177  
178      /**
179 <     *  getAndAdd returns previous value and adds given value
179 >     * getAndAdd returns previous value and adds given value
180       */
181      public void testGetAndAdd() {
182 <        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
182 >        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
183          for (int i = 0; i < SIZE; ++i) {
184              ai.set(i, 1);
185              assertEquals(1,ai.getAndAdd(i,2));
# Line 154 | Line 193 | public class AtomicIntegerArrayTest exte
193       * getAndDecrement returns previous value and decrements
194       */
195      public void testGetAndDecrement() {
196 <        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
196 >        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
197          for (int i = 0; i < SIZE; ++i) {
198              ai.set(i, 1);
199              assertEquals(1,ai.getAndDecrement(i));
# Line 167 | Line 206 | public class AtomicIntegerArrayTest exte
206       * getAndIncrement returns previous value and increments
207       */
208      public void testGetAndIncrement() {
209 <        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
209 >        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
210          for (int i = 0; i < SIZE; ++i) {
211              ai.set(i, 1);
212              assertEquals(1,ai.getAndIncrement(i));
# Line 181 | Line 220 | public class AtomicIntegerArrayTest exte
220      }
221  
222      /**
223 <     *  addAndGet adds given value to current, and returns current value
223 >     * addAndGet adds given value to current, and returns current value
224       */
225      public void testAddAndGet() {
226 <        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
226 >        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
227          for (int i = 0; i < SIZE; ++i) {
228              ai.set(i, 1);
229              assertEquals(3,ai.addAndGet(i,2));
# Line 198 | Line 237 | public class AtomicIntegerArrayTest exte
237       * decrementAndGet decrements and returns current value
238       */
239      public void testDecrementAndGet() {
240 <        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
240 >        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
241          for (int i = 0; i < SIZE; ++i) {
242              ai.set(i, 1);
243              assertEquals(0,ai.decrementAndGet(i));
# Line 209 | Line 248 | public class AtomicIntegerArrayTest exte
248      }
249  
250      /**
251 <     *  incrementAndGet increments and returns current value
251 >     * incrementAndGet increments and returns current value
252       */
253      public void testIncrementAndGet() {
254 <        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
254 >        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
255          for (int i = 0; i < SIZE; ++i) {
256              ai.set(i, 1);
257              assertEquals(2,ai.incrementAndGet(i));
# Line 226 | Line 265 | public class AtomicIntegerArrayTest exte
265      }
266  
267      static final int COUNTDOWN = 100000;
268 <    
269 <    class Counter implements Runnable {
268 >
269 >    class Counter extends CheckedRunnable {
270          final AtomicIntegerArray ai;
271          volatile int counts;
272          Counter(AtomicIntegerArray a) { ai = a; }
273 <        public void run() {
273 >        public void realRun() {
274              for (;;) {
275                  boolean done = true;
276                  for (int i = 0; i < ai.length(); ++i) {
277                      int v = ai.get(i);
278 <                    threadAssertTrue(v >= 0);
278 >                    assertTrue(v >= 0);
279                      if (v != 0) {
280                          done = false;
281                          if (ai.compareAndSet(i, v, v-1))
# Line 253 | Line 292 | public class AtomicIntegerArrayTest exte
292       * Multiple threads using same array of counters successfully
293       * update a number of times equal to total count
294       */
295 <    public void testCountingInMultipleThreads() {
296 <        try {
297 <            final AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
298 <            for (int i = 0; i < SIZE; ++i)
299 <                ai.set(i, COUNTDOWN);
300 <            Counter c1 = new Counter(ai);
301 <            Counter c2 = new Counter(ai);
302 <            Thread t1 = new Thread(c1);
303 <            Thread t2 = new Thread(c2);
304 <            t1.start();
305 <            t2.start();
306 <            t1.join();
307 <            t2.join();
269 <            assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN);
270 <        }
271 <        catch(InterruptedException ie) {
272 <            unexpectedException();
273 <        }
295 >    public void testCountingInMultipleThreads() throws InterruptedException {
296 >        final AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
297 >        for (int i = 0; i < SIZE; ++i)
298 >            ai.set(i, COUNTDOWN);
299 >        Counter c1 = new Counter(ai);
300 >        Counter c2 = new Counter(ai);
301 >        Thread t1 = new Thread(c1);
302 >        Thread t2 = new Thread(c2);
303 >        t1.start();
304 >        t2.start();
305 >        t1.join();
306 >        t2.join();
307 >        assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN);
308      }
309  
310  
311      /**
312       * a deserialized serialized array holds same values
313       */
314 <    public void testSerialization() {
315 <        AtomicIntegerArray l = new AtomicIntegerArray(SIZE);
316 <        for (int i = 0; i < SIZE; ++i)
314 >    public void testSerialization() throws Exception {
315 >        AtomicIntegerArray l = new AtomicIntegerArray(SIZE);
316 >        for (int i = 0; i < SIZE; ++i)
317              l.set(i, -i);
318  
319 <        try {
320 <            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
321 <            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
322 <            out.writeObject(l);
323 <            out.close();
324 <
325 <            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
326 <            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
327 <            AtomicIntegerArray r = (AtomicIntegerArray) in.readObject();
328 <            for (int i = 0; i < SIZE; ++i) {
295 <                assertEquals(l.get(i), r.get(i));
296 <            }
297 <        } catch(Exception e){
298 <            e.printStackTrace();
299 <            unexpectedException();
319 >        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
320 >        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
321 >        out.writeObject(l);
322 >        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));
329          }
330      }
331  
332 +
333 +    /**
334 +     * toString returns current value.
335 +     */
336 +    public void testToString() {
337 +        int[] a = { 17, 3, -42, 99, -7};
338 +        AtomicIntegerArray ai = new AtomicIntegerArray(a);
339 +        assertEquals(Arrays.toString(a), ai.toString());
340 +    }
341 +
342   }

Diff Legend

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