--- jsr166/src/test/tck/AtomicLongArrayTest.java	2003/09/07 20:39:11	1.2
+++ jsr166/src/test/tck/AtomicLongArrayTest.java	2003/09/14 20:42:40	1.3
@@ -9,10 +9,7 @@ import junit.framework.*;
 import java.util.concurrent.atomic.*;
 import java.io.*;
 
-public class AtomicLongArrayTest extends TestCase 
-{
-    static final int N = 10;
-
+public class AtomicLongArrayTest extends JSR166TestCase {
     public static void main (String[] args) {
         junit.textui.TestRunner.run (suite());
     }
@@ -21,14 +18,14 @@ public class AtomicLongArrayTest extends
     }
 
     public void testConstructor(){
-        AtomicLongArray ai = new AtomicLongArray(N);
-        for (int i = 0; i < N; ++i) 
+        AtomicLongArray ai = new AtomicLongArray(SIZE);
+        for (int i = 0; i < SIZE; ++i) 
             assertEquals(0,ai.get(i));
     }
 
     public void testGetSet(){
-        AtomicLongArray ai = new AtomicLongArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicLongArray ai = new AtomicLongArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             assertEquals(1,ai.get(i));
             ai.set(i, 2);
@@ -39,8 +36,8 @@ public class AtomicLongArrayTest extends
     }
 
     public void testCompareAndSet(){
-        AtomicLongArray ai = new AtomicLongArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicLongArray ai = new AtomicLongArray(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 +50,8 @@ public class AtomicLongArrayTest extends
     }
 
     public void testWeakCompareAndSet(){
-        AtomicLongArray ai = new AtomicLongArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicLongArray ai = new AtomicLongArray(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 +62,8 @@ public class AtomicLongArrayTest extends
     }
 
     public void testGetAndSet(){
-        AtomicLongArray ai = new AtomicLongArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicLongArray ai = new AtomicLongArray(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 +72,8 @@ public class AtomicLongArrayTest extends
     }
 
     public void testGetAndAdd(){
-        AtomicLongArray ai = new AtomicLongArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicLongArray ai = new AtomicLongArray(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 +83,8 @@ public class AtomicLongArrayTest extends
     }
 
     public void testGetAndDecrement(){
-        AtomicLongArray ai = new AtomicLongArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicLongArray ai = new AtomicLongArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             assertEquals(1,ai.getAndDecrement(i));
             assertEquals(0,ai.getAndDecrement(i));
@@ -96,8 +93,8 @@ public class AtomicLongArrayTest extends
     }
 
     public void testGetAndIncrement(){
-        AtomicLongArray ai = new AtomicLongArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicLongArray ai = new AtomicLongArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             assertEquals(1,ai.getAndIncrement(i));
             assertEquals(2,ai.get(i));
@@ -110,8 +107,8 @@ public class AtomicLongArrayTest extends
     }
 
     public void testAddAndGet() {
-        AtomicLongArray ai = new AtomicLongArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicLongArray ai = new AtomicLongArray(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 +118,8 @@ public class AtomicLongArrayTest extends
     }
 
     public void testDecrementAndGet(){
-        AtomicLongArray ai = new AtomicLongArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicLongArray ai = new AtomicLongArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             assertEquals(0,ai.decrementAndGet(i));
             assertEquals(-1,ai.decrementAndGet(i));
@@ -132,8 +129,8 @@ public class AtomicLongArrayTest extends
     }
 
     public void testIncrementAndGet() {
-        AtomicLongArray ai = new AtomicLongArray(N); 
-        for (int i = 0; i < N; ++i) {
+        AtomicLongArray ai = new AtomicLongArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) {
             ai.set(i, 1);
             assertEquals(2,ai.incrementAndGet(i));
             assertEquals(2,ai.get(i));
@@ -145,9 +142,53 @@ public class AtomicLongArrayTest extends
         }
     }
 
+    static final long COUNTDOWN = 100000;
+    
+    class Counter implements Runnable {
+        final AtomicLongArray ai;
+        volatile long counts;
+        Counter(AtomicLongArray a) { ai = a; }
+        public void run() {
+            for (;;) {
+                boolean done = true;
+                for (int i = 0; i < ai.length(); ++i) {
+                    long 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 AtomicLongArray ai = new AtomicLongArray(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() {
-        AtomicLongArray l = new AtomicLongArray(N); 
-        for (int i = 0; i < N; ++i) 
+        AtomicLongArray l = new AtomicLongArray(SIZE); 
+        for (int i = 0; i < SIZE; ++i) 
             l.set(i, -i);
 
         try {
@@ -159,7 +200,7 @@ public class AtomicLongArrayTest extends
             ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
             ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
             AtomicLongArray r = (AtomicLongArray) 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){