test/tck/AtomicLongArrayTest.java

/*
 * Written by members of JCP JSR-166 Expert Group and released to the
 * public domain. Use, modify, and redistribute this code in any way
 * without acknowledgement. Other contributors include Andrew Wright,
 * Jeffrey Hayes, Pat Fischer, Mike Judd.
 */

import junit.framework.*;
import java.util.concurrent.atomic.*;
import java.io.*;

public class AtomicLongArrayTest extends JSR166TestCase {
    public static void main (String[] args) {
        junit.textui.TestRunner.run (suite());
    }
    public static Test suite() {
        return new TestSuite(AtomicLongArrayTest.class);
    }

    public void testConstructor(){
        AtomicLongArray ai = new AtomicLongArray(SIZE);
        for (int i = 0; i < SIZE; ++i) 
            assertEquals(0,ai.get(i));
    }

    public void testGetSet(){
        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);
            assertEquals(2,ai.get(i));
            ai.set(i, -3);
            assertEquals(-3,ai.get(i));
        }
    }

    public void testCompareAndSet(){
        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));
            assertEquals(-4,ai.get(i));
            assertFalse(ai.compareAndSet(i, -5,7));
            assertFalse((7 == ai.get(i)));
            assertTrue(ai.compareAndSet(i, -4,7));
            assertEquals(7,ai.get(i));
        }
    }

    public void testWeakCompareAndSet(){
        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));
            assertEquals(-4,ai.get(i));
            while(!ai.weakCompareAndSet(i, -4,7));
            assertEquals(7,ai.get(i));
        }
    }

    public void testGetAndSet(){
        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));
            assertEquals(-10,ai.getAndSet(i,1));
        }
    }

    public void testGetAndAdd(){
        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));
            assertEquals(3,ai.getAndAdd(i,-4));
            assertEquals(-1,ai.get(i));
        }
    }

    public void testGetAndDecrement(){
        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));
            assertEquals(-1,ai.getAndDecrement(i));
        }
    }

    public void testGetAndIncrement(){
        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));
            ai.set(i,-2);
            assertEquals(-2,ai.getAndIncrement(i));
            assertEquals(-1,ai.getAndIncrement(i));
            assertEquals(0,ai.getAndIncrement(i));
            assertEquals(1,ai.get(i));
        }
    }

    public void testAddAndGet() {
        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));
            assertEquals(-1,ai.addAndGet(i,-4));
            assertEquals(-1,ai.get(i));
        }
    }

    public void testDecrementAndGet(){
        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));
            assertEquals(-2,ai.decrementAndGet(i));
            assertEquals(-2,ai.get(i));
        }
    }

    public void testIncrementAndGet() {
        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));
            ai.set(i, -2);
            assertEquals(-1,ai.incrementAndGet(i));
            assertEquals(0,ai.incrementAndGet(i));
            assertEquals(1,ai.incrementAndGet(i));
            assertEquals(1,ai.get(i));
        }
    }

    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(SIZE); 
        for (int i = 0; i < SIZE; ++i) 
            l.set(i, -i);

        try {
            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
            out.writeObject(l);
            out.close();

            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
            AtomicLongArray r = (AtomicLongArray) in.readObject();
            for (int i = 0; i < SIZE; ++i) {
                assertEquals(l.get(i), r.get(i));
            }
        } catch(Exception e){
            e.printStackTrace();
            fail("unexpected exception");
        }
    }


}
Revision:	1.3
Committed:	Sun Sep 14 20:42:40 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Changes since 1.2:	+70 -29 lines
Log Message:	New base class JSR166TestCase
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by members of JCP JSR-166 Expert Group and released to the
3			* public domain. Use, modify, and redistribute this code in any way
4			* without acknowledgement. Other contributors include Andrew Wright,
5			* Jeffrey Hayes, Pat Fischer, Mike Judd.
6			*/
7
8			import junit.framework.*;
9			import java.util.concurrent.atomic.*;
10	dl	1.2	import java.io.*;
11	dl	1.1
12	dl	1.3	public class AtomicLongArrayTest extends JSR166TestCase {
13	dl	1.1	public static void main (String[] args) {
14			junit.textui.TestRunner.run (suite());
15			}
16			public static Test suite() {
17			return new TestSuite(AtomicLongArrayTest.class);
18			}
19
20			public void testConstructor(){
21	dl	1.3	AtomicLongArray ai = new AtomicLongArray(SIZE);
22			for (int i = 0; i < SIZE; ++i)
23	dl	1.1	assertEquals(0,ai.get(i));
24			}
25
26			public void testGetSet(){
27	dl	1.3	AtomicLongArray ai = new AtomicLongArray(SIZE);
28			for (int i = 0; i < SIZE; ++i) {
29	dl	1.1	ai.set(i, 1);
30			assertEquals(1,ai.get(i));
31			ai.set(i, 2);
32			assertEquals(2,ai.get(i));
33			ai.set(i, -3);
34			assertEquals(-3,ai.get(i));
35			}
36			}
37
38			public void testCompareAndSet(){
39	dl	1.3	AtomicLongArray ai = new AtomicLongArray(SIZE);
40			for (int i = 0; i < SIZE; ++i) {
41	dl	1.1	ai.set(i, 1);
42			assertTrue(ai.compareAndSet(i, 1,2));
43			assertTrue(ai.compareAndSet(i, 2,-4));
44			assertEquals(-4,ai.get(i));
45			assertFalse(ai.compareAndSet(i, -5,7));
46			assertFalse((7 == ai.get(i)));
47			assertTrue(ai.compareAndSet(i, -4,7));
48			assertEquals(7,ai.get(i));
49			}
50			}
51
52			public void testWeakCompareAndSet(){
53	dl	1.3	AtomicLongArray ai = new AtomicLongArray(SIZE);
54			for (int i = 0; i < SIZE; ++i) {
55	dl	1.1	ai.set(i, 1);
56			while(!ai.weakCompareAndSet(i, 1,2));
57			while(!ai.weakCompareAndSet(i, 2,-4));
58			assertEquals(-4,ai.get(i));
59			while(!ai.weakCompareAndSet(i, -4,7));
60			assertEquals(7,ai.get(i));
61			}
62			}
63
64			public void testGetAndSet(){
65	dl	1.3	AtomicLongArray ai = new AtomicLongArray(SIZE);
66			for (int i = 0; i < SIZE; ++i) {
67	dl	1.1	ai.set(i, 1);
68			assertEquals(1,ai.getAndSet(i,0));
69			assertEquals(0,ai.getAndSet(i,-10));
70			assertEquals(-10,ai.getAndSet(i,1));
71			}
72			}
73
74			public void testGetAndAdd(){
75	dl	1.3	AtomicLongArray ai = new AtomicLongArray(SIZE);
76			for (int i = 0; i < SIZE; ++i) {
77	dl	1.1	ai.set(i, 1);
78			assertEquals(1,ai.getAndAdd(i,2));
79			assertEquals(3,ai.get(i));
80			assertEquals(3,ai.getAndAdd(i,-4));
81			assertEquals(-1,ai.get(i));
82			}
83			}
84
85			public void testGetAndDecrement(){
86	dl	1.3	AtomicLongArray ai = new AtomicLongArray(SIZE);
87			for (int i = 0; i < SIZE; ++i) {
88	dl	1.1	ai.set(i, 1);
89			assertEquals(1,ai.getAndDecrement(i));
90			assertEquals(0,ai.getAndDecrement(i));
91			assertEquals(-1,ai.getAndDecrement(i));
92			}
93			}
94
95			public void testGetAndIncrement(){
96	dl	1.3	AtomicLongArray ai = new AtomicLongArray(SIZE);
97			for (int i = 0; i < SIZE; ++i) {
98	dl	1.1	ai.set(i, 1);
99			assertEquals(1,ai.getAndIncrement(i));
100			assertEquals(2,ai.get(i));
101			ai.set(i,-2);
102			assertEquals(-2,ai.getAndIncrement(i));
103			assertEquals(-1,ai.getAndIncrement(i));
104			assertEquals(0,ai.getAndIncrement(i));
105			assertEquals(1,ai.get(i));
106			}
107			}
108
109			public void testAddAndGet() {
110	dl	1.3	AtomicLongArray ai = new AtomicLongArray(SIZE);
111			for (int i = 0; i < SIZE; ++i) {
112	dl	1.1	ai.set(i, 1);
113			assertEquals(3,ai.addAndGet(i,2));
114			assertEquals(3,ai.get(i));
115			assertEquals(-1,ai.addAndGet(i,-4));
116			assertEquals(-1,ai.get(i));
117			}
118			}
119
120			public void testDecrementAndGet(){
121	dl	1.3	AtomicLongArray ai = new AtomicLongArray(SIZE);
122			for (int i = 0; i < SIZE; ++i) {
123	dl	1.1	ai.set(i, 1);
124			assertEquals(0,ai.decrementAndGet(i));
125			assertEquals(-1,ai.decrementAndGet(i));
126			assertEquals(-2,ai.decrementAndGet(i));
127			assertEquals(-2,ai.get(i));
128			}
129			}
130
131			public void testIncrementAndGet() {
132	dl	1.3	AtomicLongArray ai = new AtomicLongArray(SIZE);
133			for (int i = 0; i < SIZE; ++i) {
134	dl	1.1	ai.set(i, 1);
135			assertEquals(2,ai.incrementAndGet(i));
136			assertEquals(2,ai.get(i));
137			ai.set(i, -2);
138			assertEquals(-1,ai.incrementAndGet(i));
139			assertEquals(0,ai.incrementAndGet(i));
140			assertEquals(1,ai.incrementAndGet(i));
141			assertEquals(1,ai.get(i));
142			}
143			}
144	dl	1.2
145	dl	1.3	static final long COUNTDOWN = 100000;
146
147			class Counter implements Runnable {
148			final AtomicLongArray ai;
149			volatile long counts;
150			Counter(AtomicLongArray a) { ai = a; }
151			public void run() {
152			for (;;) {
153			boolean done = true;
154			for (int i = 0; i < ai.length(); ++i) {
155			long v = ai.get(i);
156			threadAssertTrue(v >= 0);
157			if (v != 0) {
158			done = false;
159			if (ai.compareAndSet(i, v, v-1))
160			++counts;
161			}
162			}
163			if (done)
164			break;
165			}
166			}
167			}
168
169			public void testCountingInMultipleThreads() {
170			try {
171			final AtomicLongArray ai = new AtomicLongArray(SIZE);
172			for (int i = 0; i < SIZE; ++i)
173			ai.set(i, COUNTDOWN);
174			Counter c1 = new Counter(ai);
175			Counter c2 = new Counter(ai);
176			Thread t1 = new Thread(c1);
177			Thread t2 = new Thread(c2);
178			t1.start();
179			t2.start();
180			t1.join();
181			t2.join();
182			assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN);
183			}
184			catch(InterruptedException ie) {
185			fail("unexpected exception");
186			}
187			}
188
189	dl	1.2	public void testSerialization() {
190	dl	1.3	AtomicLongArray l = new AtomicLongArray(SIZE);
191			for (int i = 0; i < SIZE; ++i)
192	dl	1.2	l.set(i, -i);
193
194			try {
195			ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
196			ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
197			out.writeObject(l);
198			out.close();
199
200			ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
201			ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
202			AtomicLongArray r = (AtomicLongArray) in.readObject();
203	dl	1.3	for (int i = 0; i < SIZE; ++i) {
204	dl	1.2	assertEquals(l.get(i), r.get(i));
205			}
206			} catch(Exception e){
207			e.printStackTrace();
208			fail("unexpected exception");
209			}
210			}
211
212	dl	1.1
213			}