--- jsr166/src/test/tck/AtomicIntegerArrayTest.java	2003/09/07 20:39:11	1.2
+++ jsr166/src/test/tck/AtomicIntegerArrayTest.java	2003/09/14 20:42:40	1.3
@@ -9,9 +9,7 @@ import junit.framework.*;
 import java.util.concurrent.atomic.*;
 import java.io.*;
 
-public class AtomicIntegerArrayTest extends TestCase 
-{
-    static final int N = 10;
+public class AtomicIntegerArrayTest extends JSR166TestCase {
 
     public static void main (String[] args) {
         junit.textui.TestRunner.run (suite());
@@ -20,15 +18,16 @@ public class AtomicIntegerArrayTest exte
         return new TestSuite(AtomicIntegerArrayTest.class);
     }
 
+
     public void testConstructor(){
-        AtomicIntegerArray ai = new AtomicIntegerArray(N);
-        for (int i = 0; i < N; ++i) 
+        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
+        for (int i = 0; i < SIZE; ++i) 
             assertEquals(0,ai.get(i));
     }
 
     public void testGetSet(){
-        AtomicIntegerArray ai = new AtomicIntegerArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             assertEquals(1,ai.get(i));
             ai.set(i, 2);
@@ -39,8 +38,8 @@ public class AtomicIntegerArrayTest exte
     }
 
     public void testCompareAndSet(){
-        AtomicIntegerArray ai = new AtomicIntegerArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             assertTrue(ai.compareAndSet(i, 1,2));
             assertTrue(ai.compareAndSet(i, 2,-4));
@@ -53,8 +52,8 @@ public class AtomicIntegerArrayTest exte
     }
 
     public void testWeakCompareAndSet(){
-        AtomicIntegerArray ai = new AtomicIntegerArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             while(!ai.weakCompareAndSet(i, 1,2));
             while(!ai.weakCompareAndSet(i, 2,-4));
@@ -65,8 +64,8 @@ public class AtomicIntegerArrayTest exte
     }
 
     public void testGetAndSet(){
-        AtomicIntegerArray ai = new AtomicIntegerArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             assertEquals(1,ai.getAndSet(i,0));
             assertEquals(0,ai.getAndSet(i,-10));
@@ -75,8 +74,8 @@ public class AtomicIntegerArrayTest exte
     }
 
     public void testGetAndAdd(){
-        AtomicIntegerArray ai = new AtomicIntegerArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             assertEquals(1,ai.getAndAdd(i,2));
             assertEquals(3,ai.get(i));
@@ -86,8 +85,8 @@ public class AtomicIntegerArrayTest exte
     }
 
     public void testGetAndDecrement(){
-        AtomicIntegerArray ai = new AtomicIntegerArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             assertEquals(1,ai.getAndDecrement(i));
             assertEquals(0,ai.getAndDecrement(i));
@@ -96,8 +95,8 @@ public class AtomicIntegerArrayTest exte
     }
 
     public void testGetAndIncrement(){
-        AtomicIntegerArray ai = new AtomicIntegerArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             assertEquals(1,ai.getAndIncrement(i));
             assertEquals(2,ai.get(i));
@@ -110,8 +109,8 @@ public class AtomicIntegerArrayTest exte
     }
 
     public void testAddAndGet() {
-        AtomicIntegerArray ai = new AtomicIntegerArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             assertEquals(3,ai.addAndGet(i,2));
             assertEquals(3,ai.get(i));
@@ -121,8 +120,8 @@ public class AtomicIntegerArrayTest exte
     }
 
     public void testDecrementAndGet(){
-        AtomicIntegerArray ai = new AtomicIntegerArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             assertEquals(0,ai.decrementAndGet(i));
             assertEquals(-1,ai.decrementAndGet(i));
@@ -132,8 +131,8 @@ public class AtomicIntegerArrayTest exte
     }
 
     public void testIncrementAndGet() {
-        AtomicIntegerArray ai = new AtomicIntegerArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             assertEquals(2,ai.incrementAndGet(i));
             assertEquals(2,ai.get(i));
@@ -145,9 +144,54 @@ public class AtomicIntegerArrayTest exte
         }
     }
 
+    static final int COUNTDOWN = 100000;
+    
+    class Counter implements Runnable {
+        final AtomicIntegerArray ai;
+        volatile int counts;
+        Counter(AtomicIntegerArray a) { ai = a; }
+        public void run() {
+            for (;;) {
+                boolean done = true;
+                for (int i = 0; i < ai.length(); ++i) {
+                    int v = ai.get(i);
+                    threadAssertTrue(v >= 0);
+                    if (v != 0) {
+                        done = false;
+                        if (ai.compareAndSet(i, v, v-1))
+                            ++counts;
+                    }
+                }
+                if (done)
+                    break;
+            }
+        }
+    }
+
+    public void testCountingInMultipleThreads() {
+        try {
+            final AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); 
+            for (int i = 0; i < SIZE; ++i) 
+                ai.set(i, COUNTDOWN);
+            Counter c1 = new Counter(ai);
+            Counter c2 = new Counter(ai);
+            Thread t1 = new Thread(c1);
+            Thread t2 = new Thread(c2);
+            t1.start();
+            t2.start();
+            t1.join();
+            t2.join();
+            assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN);
+        }
+        catch(InterruptedException ie) {
+            fail("unexpected exception");
+        }
+    }
+
+
     public void testSerialization() {
-        AtomicIntegerArray l = new AtomicIntegerArray(N); 
-        for (int i = 0; i < N; ++i) 
+        AtomicIntegerArray l = new AtomicIntegerArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) 
             l.set(i, -i);
 
         try {
@@ -159,7 +203,7 @@ public class AtomicIntegerArrayTest exte
             ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
             ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
             AtomicIntegerArray r = (AtomicIntegerArray) in.readObject();
-            for (int i = 0; i < N; ++i) {
+            for (int i = 0; i < SIZE; ++i) {
                 assertEquals(l.get(i), r.get(i));
             }
         } catch(Exception e){