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.7 by dl, Thu Jan 8 01:29:46 2004 UTC vs.
Revision 1.12 by jsr166, Mon Nov 16 05:30:07 2009 UTC

# Line 2 | Line 2
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.
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 AtomicLongArrayTest extends JSR166TestCase {
15      public static void main (String[] args) {
# Line 21 | Line 22 | public class AtomicLongArrayTest extends
22      /**
23       * constructor creates array of given size with all elements zero
24       */
25 <    public void testConstructor(){
25 >    public void testConstructor() {
26          AtomicLongArray ai = new AtomicLongArray(SIZE);
27 <        for (int i = 0; i < SIZE; ++i)
27 >        for (int i = 0; i < SIZE; ++i)
28              assertEquals(0,ai.get(i));
29      }
30  
# Line 47 | Line 48 | public class AtomicLongArrayTest extends
48          long[] a = { 17L, 3L, -42L, 99L, -7L};
49          AtomicLongArray ai = new AtomicLongArray(a);
50          assertEquals(a.length, ai.length());
51 <        for (int i = 0; i < a.length; ++i)
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          AtomicLongArray ai = new AtomicLongArray(SIZE);
60          try {
61              ai.get(SIZE);
62 <        } catch(IndexOutOfBoundsException success){
62 >        } catch (IndexOutOfBoundsException success) {
63          }
64          try {
65              ai.get(-1);
66 <        } catch(IndexOutOfBoundsException success){
66 >        } catch (IndexOutOfBoundsException success) {
67          }
68          try {
69              ai.set(SIZE, 0);
70 <        } catch(IndexOutOfBoundsException success){
70 >        } catch (IndexOutOfBoundsException success) {
71          }
72          try {
73              ai.set(-1, 0);
74 <        } catch(IndexOutOfBoundsException success){
74 >        } catch (IndexOutOfBoundsException success) {
75          }
76      }
77  
78      /**
79       * get returns the last value set at index
80       */
81 <    public void testGetSet(){
82 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
81 >    public void testGetSet() {
82 >        AtomicLongArray ai = new AtomicLongArray(SIZE);
83          for (int i = 0; i < SIZE; ++i) {
84              ai.set(i, 1);
85              assertEquals(1,ai.get(i));
# Line 90 | Line 91 | public class AtomicLongArrayTest extends
91      }
92  
93      /**
94 +     * get returns the last value lazySet at index by same thread
95 +     */
96 +    public void testGetLazySet() {
97 +        AtomicLongArray ai = new AtomicLongArray(SIZE);
98 +        for (int i = 0; i < SIZE; ++i) {
99 +            ai.lazySet(i, 1);
100 +            assertEquals(1,ai.get(i));
101 +            ai.lazySet(i, 2);
102 +            assertEquals(2,ai.get(i));
103 +            ai.lazySet(i, -3);
104 +            assertEquals(-3,ai.get(i));
105 +        }
106 +    }
107 +
108 +    /**
109       * compareAndSet succeeds in changing value if equal to expected else fails
110       */
111 <    public void testCompareAndSet(){
112 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
111 >    public void testCompareAndSet() {
112 >        AtomicLongArray ai = new AtomicLongArray(SIZE);
113          for (int i = 0; i < SIZE; ++i) {
114              ai.set(i, 1);
115              assertTrue(ai.compareAndSet(i, 1,2));
# Line 115 | Line 131 | public class AtomicLongArrayTest extends
131          a.set(0, 1);
132          Thread t = new Thread(new Runnable() {
133                  public void run() {
134 <                    while(!a.compareAndSet(0, 2, 3)) Thread.yield();
134 >                    while (!a.compareAndSet(0, 2, 3)) Thread.yield();
135                  }});
136          try {
137              t.start();
# Line 124 | Line 140 | public class AtomicLongArrayTest extends
140              assertFalse(t.isAlive());
141              assertEquals(a.get(0), 3);
142          }
143 <        catch(Exception e) {
143 >        catch (Exception e) {
144              unexpectedException();
145          }
146      }
147  
148      /**
149       * repeated weakCompareAndSet succeeds in changing value when equal
150 <     * to expected
150 >     * to expected
151       */
152 <    public void testWeakCompareAndSet(){
153 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
152 >    public void testWeakCompareAndSet() {
153 >        AtomicLongArray ai = new AtomicLongArray(SIZE);
154          for (int i = 0; i < SIZE; ++i) {
155              ai.set(i, 1);
156 <            while(!ai.weakCompareAndSet(i, 1,2));
157 <            while(!ai.weakCompareAndSet(i, 2,-4));
156 >            while (!ai.weakCompareAndSet(i, 1,2));
157 >            while (!ai.weakCompareAndSet(i, 2,-4));
158              assertEquals(-4,ai.get(i));
159 <            while(!ai.weakCompareAndSet(i, -4,7));
159 >            while (!ai.weakCompareAndSet(i, -4,7));
160              assertEquals(7,ai.get(i));
161          }
162      }
# Line 148 | Line 164 | public class AtomicLongArrayTest extends
164      /**
165       *  getAndSet returns previous value and sets to given value at given index
166       */
167 <    public void testGetAndSet(){
168 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
167 >    public void testGetAndSet() {
168 >        AtomicLongArray ai = new AtomicLongArray(SIZE);
169          for (int i = 0; i < SIZE; ++i) {
170              ai.set(i, 1);
171              assertEquals(1,ai.getAndSet(i,0));
# Line 161 | Line 177 | public class AtomicLongArrayTest extends
177      /**
178       *  getAndAdd returns previous value and adds given value
179       */
180 <    public void testGetAndAdd(){
181 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
180 >    public void testGetAndAdd() {
181 >        AtomicLongArray ai = new AtomicLongArray(SIZE);
182          for (int i = 0; i < SIZE; ++i) {
183              ai.set(i, 1);
184              assertEquals(1,ai.getAndAdd(i,2));
# Line 175 | Line 191 | public class AtomicLongArrayTest extends
191      /**
192       * getAndDecrement returns previous value and decrements
193       */
194 <    public void testGetAndDecrement(){
195 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
194 >    public void testGetAndDecrement() {
195 >        AtomicLongArray ai = new AtomicLongArray(SIZE);
196          for (int i = 0; i < SIZE; ++i) {
197              ai.set(i, 1);
198              assertEquals(1,ai.getAndDecrement(i));
# Line 188 | Line 204 | public class AtomicLongArrayTest extends
204      /**
205       * getAndIncrement returns previous value and increments
206       */
207 <    public void testGetAndIncrement(){
208 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
207 >    public void testGetAndIncrement() {
208 >        AtomicLongArray ai = new AtomicLongArray(SIZE);
209          for (int i = 0; i < SIZE; ++i) {
210              ai.set(i, 1);
211              assertEquals(1,ai.getAndIncrement(i));
# Line 206 | Line 222 | public class AtomicLongArrayTest extends
222       *  addAndGet adds given value to current, and returns current value
223       */
224      public void testAddAndGet() {
225 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
225 >        AtomicLongArray ai = new AtomicLongArray(SIZE);
226          for (int i = 0; i < SIZE; ++i) {
227              ai.set(i, 1);
228              assertEquals(3,ai.addAndGet(i,2));
# Line 219 | Line 235 | public class AtomicLongArrayTest extends
235      /**
236       * decrementAndGet decrements and returns current value
237       */
238 <    public void testDecrementAndGet(){
239 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
238 >    public void testDecrementAndGet() {
239 >        AtomicLongArray ai = new AtomicLongArray(SIZE);
240          for (int i = 0; i < SIZE; ++i) {
241              ai.set(i, 1);
242              assertEquals(0,ai.decrementAndGet(i));
# Line 234 | Line 250 | public class AtomicLongArrayTest extends
250       * incrementAndGet increments and returns current value
251       */
252      public void testIncrementAndGet() {
253 <        AtomicLongArray ai = new AtomicLongArray(SIZE);
253 >        AtomicLongArray ai = new AtomicLongArray(SIZE);
254          for (int i = 0; i < SIZE; ++i) {
255              ai.set(i, 1);
256              assertEquals(2,ai.incrementAndGet(i));
# Line 248 | Line 264 | public class AtomicLongArrayTest extends
264      }
265  
266      static final long COUNTDOWN = 100000;
267 <    
267 >
268      class Counter implements Runnable {
269          final AtomicLongArray ai;
270          volatile long counts;
# Line 277 | Line 293 | public class AtomicLongArrayTest extends
293       */
294      public void testCountingInMultipleThreads() {
295          try {
296 <            final AtomicLongArray ai = new AtomicLongArray(SIZE);
297 <            for (int i = 0; i < SIZE; ++i)
296 >            final AtomicLongArray ai = new AtomicLongArray(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);
# Line 290 | Line 306 | public class AtomicLongArrayTest extends
306              t2.join();
307              assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN);
308          }
309 <        catch(InterruptedException ie) {
309 >        catch (InterruptedException ie) {
310              unexpectedException();
311          }
312      }
# Line 299 | Line 315 | public class AtomicLongArrayTest extends
315       * a deserialized serialized array holds same values
316       */
317      public void testSerialization() {
318 <        AtomicLongArray l = new AtomicLongArray(SIZE);
319 <        for (int i = 0; i < SIZE; ++i)
318 >        AtomicLongArray l = new AtomicLongArray(SIZE);
319 >        for (int i = 0; i < SIZE; ++i)
320              l.set(i, -i);
321  
322          try {
# Line 315 | Line 331 | public class AtomicLongArrayTest extends
331              for (int i = 0; i < SIZE; ++i) {
332                  assertEquals(l.get(i), r.get(i));
333              }
334 <        } catch(Exception e){
334 >        } catch (Exception e) {
335              unexpectedException();
336          }
337      }
338  
339 +    /**
340 +     * toString returns current value.
341 +     */
342 +    public void testToString() {
343 +        long[] a = { 17, 3, -42, 99, -7};
344 +        AtomicLongArray ai = new AtomicLongArray(a);
345 +        assertEquals(Arrays.toString(a), ai.toString());
346 +    }
347 +
348  
349   }

Diff Legend

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