test/tck/AtomicIntegerTest.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/licenses/publicdomain
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */

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

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

    /**
     * constructor initializes to given value
     */
    public void testConstructor(){
        AtomicInteger ai = new AtomicInteger(1);
        assertEquals(1,ai.get());
    }

    /**
     * default constructed initializes to zero
     */
    public void testConstructor2(){
        AtomicInteger ai = new AtomicInteger();
        assertEquals(0,ai.get());
    }

    /**
     * get returns the last value set
     */
    public void testGetSet(){
        AtomicInteger ai = new AtomicInteger(1);
        assertEquals(1,ai.get());
        ai.set(2);
        assertEquals(2,ai.get());
        ai.set(-3);
        assertEquals(-3,ai.get());

    }

    /**
     * get returns the last value lazySet in same thread
     */
    public void testGetLazySet(){
        AtomicInteger ai = new AtomicInteger(1);
        assertEquals(1,ai.get());
        ai.lazySet(2);
        assertEquals(2,ai.get());
        ai.lazySet(-3);
        assertEquals(-3,ai.get());

    }
    /**
     * compareAndSet succeeds in changing value if equal to expected else fails
     */
    public void testCompareAndSet(){
        AtomicInteger ai = new AtomicInteger(1);
        assertTrue(ai.compareAndSet(1,2));
        assertTrue(ai.compareAndSet(2,-4));
        assertEquals(-4,ai.get());
        assertFalse(ai.compareAndSet(-5,7));
        assertFalse((7 == ai.get()));
        assertTrue(ai.compareAndSet(-4,7));
        assertEquals(7,ai.get());
    }

    /**
     * compareAndSet in one thread enables another waiting for value
     * to succeed
     */
    public void testCompareAndSetInMultipleThreads() {
        final AtomicInteger ai = new AtomicInteger(1);
        Thread t = new Thread(new Runnable() {
                public void run() {
                    while (!ai.compareAndSet(2, 3)) Thread.yield();
                }});
        try {
            t.start();
            assertTrue(ai.compareAndSet(1, 2));
            t.join(LONG_DELAY_MS);
            assertFalse(t.isAlive());
            assertEquals(ai.get(), 3);
        }
        catch (Exception e) {
            unexpectedException();
        }
    }

    /**
     * repeated weakCompareAndSet succeeds in changing value when equal
     * to expected
     */
    public void testWeakCompareAndSet(){
        AtomicInteger ai = new AtomicInteger(1);
        while (!ai.weakCompareAndSet(1,2));
        while (!ai.weakCompareAndSet(2,-4));
        assertEquals(-4,ai.get());
        while (!ai.weakCompareAndSet(-4,7));
        assertEquals(7,ai.get());
    }

    /**
     * getAndSet returns previous value and sets to given value
     */
    public void testGetAndSet(){
        AtomicInteger ai = new AtomicInteger(1);
        assertEquals(1,ai.getAndSet(0));
        assertEquals(0,ai.getAndSet(-10));
        assertEquals(-10,ai.getAndSet(1));
    }

    /**
     * getAndAdd returns previous value and adds given value
     */
    public void testGetAndAdd(){
        AtomicInteger ai = new AtomicInteger(1);
        assertEquals(1,ai.getAndAdd(2));
        assertEquals(3,ai.get());
        assertEquals(3,ai.getAndAdd(-4));
        assertEquals(-1,ai.get());
    }

    /**
     * getAndDecrement returns previous value and decrements
     */
    public void testGetAndDecrement(){
        AtomicInteger ai = new AtomicInteger(1);
        assertEquals(1,ai.getAndDecrement());
        assertEquals(0,ai.getAndDecrement());
        assertEquals(-1,ai.getAndDecrement());
    }

    /**
     * getAndIncrement returns previous value and increments
     */
    public void testGetAndIncrement(){
        AtomicInteger ai = new AtomicInteger(1);
        assertEquals(1,ai.getAndIncrement());
        assertEquals(2,ai.get());
        ai.set(-2);
        assertEquals(-2,ai.getAndIncrement());
        assertEquals(-1,ai.getAndIncrement());
        assertEquals(0,ai.getAndIncrement());
        assertEquals(1,ai.get());
    }

    /**
     * addAndGet adds given value to current, and returns current value
     */
    public void testAddAndGet(){
        AtomicInteger ai = new AtomicInteger(1);
        assertEquals(3,ai.addAndGet(2));
        assertEquals(3,ai.get());
        assertEquals(-1,ai.addAndGet(-4));
        assertEquals(-1,ai.get());
    }

    /**
     * decrementAndGet decrements and returns current value
     */
    public void testDecrementAndGet(){
        AtomicInteger ai = new AtomicInteger(1);
        assertEquals(0,ai.decrementAndGet());
        assertEquals(-1,ai.decrementAndGet());
        assertEquals(-2,ai.decrementAndGet());
        assertEquals(-2,ai.get());
    }

    /**
     * incrementAndGet increments and returns current value
     */
    public void testIncrementAndGet(){
        AtomicInteger ai = new AtomicInteger(1);
        assertEquals(2,ai.incrementAndGet());
        assertEquals(2,ai.get());
        ai.set(-2);
        assertEquals(-1,ai.incrementAndGet());
        assertEquals(0,ai.incrementAndGet());
        assertEquals(1,ai.incrementAndGet());
        assertEquals(1,ai.get());
    }

    /**
     * a deserialized serialized atomic holds same value
     */
    public void testSerialization() {
        AtomicInteger l = new AtomicInteger();

        try {
            l.set(22);
            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));
            AtomicInteger r = (AtomicInteger) in.readObject();
            assertEquals(l.get(), r.get());
        } catch (Exception e){
            unexpectedException();
        }
    }

    /**
     * toString returns current value.
     */
    public void testToString() {
        AtomicInteger ai = new AtomicInteger();
        for (int i = -12; i < 6; ++i) {
            ai.set(i);
            assertEquals(ai.toString(), Integer.toString(i));
        }
    }

    /**
     * intValue returns current value.
     */
    public void testIntValue() {
        AtomicInteger ai = new AtomicInteger();
        for (int i = -12; i < 6; ++i) {
            ai.set(i);
            assertEquals(i, ai.intValue());
        }
    }


    /**
     * longValue returns current value.
     */
    public void testLongValue() {
        AtomicInteger ai = new AtomicInteger();
        for (int i = -12; i < 6; ++i) {
            ai.set(i);
            assertEquals((long)i, ai.longValue());
        }
    }

    /**
     * floatValue returns current value.
     */
    public void testFloatValue() {
        AtomicInteger ai = new AtomicInteger();
        for (int i = -12; i < 6; ++i) {
            ai.set(i);
            assertEquals((float)i, ai.floatValue());
        }
    }

    /**
     * doubleValue returns current value.
     */
    public void testDoubleValue() {
        AtomicInteger ai = new AtomicInteger();
        for (int i = -12; i < 6; ++i) {
            ai.set(i);
            assertEquals((double)i, ai.doubleValue());
        }
    }


}
Revision:	1.13
Committed:	Mon Nov 16 04:57:10 2009 UTC (14 years, 5 months ago) by jsr166
Branch:	MAIN
Changes since 1.12:	+6 -6 lines
Log Message:	whitespace
#	Content
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.
7	*/
8
9	import junit.framework.*;
10	import java.util.concurrent.atomic.*;
11	import java.io.*;
12
13	public class AtomicIntegerTest extends JSR166TestCase {
14	public static void main (String[] args) {
15	junit.textui.TestRunner.run (suite());
16	}
17	public static Test suite() {
18	return new TestSuite(AtomicIntegerTest.class);
19	}
20
21	/**
22	* constructor initializes to given value
23	*/
24	public void testConstructor(){
25	AtomicInteger ai = new AtomicInteger(1);
26	assertEquals(1,ai.get());
27	}
28
29	/**
30	* default constructed initializes to zero
31	*/
32	public void testConstructor2(){
33	AtomicInteger ai = new AtomicInteger();
34	assertEquals(0,ai.get());
35	}
36
37	/**
38	* get returns the last value set
39	*/
40	public void testGetSet(){
41	AtomicInteger ai = new AtomicInteger(1);
42	assertEquals(1,ai.get());
43	ai.set(2);
44	assertEquals(2,ai.get());
45	ai.set(-3);
46	assertEquals(-3,ai.get());
47
48	}
49
50	/**
51	* get returns the last value lazySet in same thread
52	*/
53	public void testGetLazySet(){
54	AtomicInteger ai = new AtomicInteger(1);
55	assertEquals(1,ai.get());
56	ai.lazySet(2);
57	assertEquals(2,ai.get());
58	ai.lazySet(-3);
59	assertEquals(-3,ai.get());
60
61	}
62	/**
63	* compareAndSet succeeds in changing value if equal to expected else fails
64	*/
65	public void testCompareAndSet(){
66	AtomicInteger ai = new AtomicInteger(1);
67	assertTrue(ai.compareAndSet(1,2));
68	assertTrue(ai.compareAndSet(2,-4));
69	assertEquals(-4,ai.get());
70	assertFalse(ai.compareAndSet(-5,7));
71	assertFalse((7 == ai.get()));
72	assertTrue(ai.compareAndSet(-4,7));
73	assertEquals(7,ai.get());
74	}
75
76	/**
77	* compareAndSet in one thread enables another waiting for value
78	* to succeed
79	*/
80	public void testCompareAndSetInMultipleThreads() {
81	final AtomicInteger ai = new AtomicInteger(1);
82	Thread t = new Thread(new Runnable() {
83	public void run() {
84	while (!ai.compareAndSet(2, 3)) Thread.yield();
85	}});
86	try {
87	t.start();
88	assertTrue(ai.compareAndSet(1, 2));
89	t.join(LONG_DELAY_MS);
90	assertFalse(t.isAlive());
91	assertEquals(ai.get(), 3);
92	}
93	catch (Exception e) {
94	unexpectedException();
95	}
96	}
97
98	/**
99	* repeated weakCompareAndSet succeeds in changing value when equal
100	* to expected
101	*/
102	public void testWeakCompareAndSet(){
103	AtomicInteger ai = new AtomicInteger(1);
104	while (!ai.weakCompareAndSet(1,2));
105	while (!ai.weakCompareAndSet(2,-4));
106	assertEquals(-4,ai.get());
107	while (!ai.weakCompareAndSet(-4,7));
108	assertEquals(7,ai.get());
109	}
110
111	/**
112	* getAndSet returns previous value and sets to given value
113	*/
114	public void testGetAndSet(){
115	AtomicInteger ai = new AtomicInteger(1);
116	assertEquals(1,ai.getAndSet(0));
117	assertEquals(0,ai.getAndSet(-10));
118	assertEquals(-10,ai.getAndSet(1));
119	}
120
121	/**
122	* getAndAdd returns previous value and adds given value
123	*/
124	public void testGetAndAdd(){
125	AtomicInteger ai = new AtomicInteger(1);
126	assertEquals(1,ai.getAndAdd(2));
127	assertEquals(3,ai.get());
128	assertEquals(3,ai.getAndAdd(-4));
129	assertEquals(-1,ai.get());
130	}
131
132	/**
133	* getAndDecrement returns previous value and decrements
134	*/
135	public void testGetAndDecrement(){
136	AtomicInteger ai = new AtomicInteger(1);
137	assertEquals(1,ai.getAndDecrement());
138	assertEquals(0,ai.getAndDecrement());
139	assertEquals(-1,ai.getAndDecrement());
140	}
141
142	/**
143	* getAndIncrement returns previous value and increments
144	*/
145	public void testGetAndIncrement(){
146	AtomicInteger ai = new AtomicInteger(1);
147	assertEquals(1,ai.getAndIncrement());
148	assertEquals(2,ai.get());
149	ai.set(-2);
150	assertEquals(-2,ai.getAndIncrement());
151	assertEquals(-1,ai.getAndIncrement());
152	assertEquals(0,ai.getAndIncrement());
153	assertEquals(1,ai.get());
154	}
155
156	/**
157	* addAndGet adds given value to current, and returns current value
158	*/
159	public void testAddAndGet(){
160	AtomicInteger ai = new AtomicInteger(1);
161	assertEquals(3,ai.addAndGet(2));
162	assertEquals(3,ai.get());
163	assertEquals(-1,ai.addAndGet(-4));
164	assertEquals(-1,ai.get());
165	}
166
167	/**
168	* decrementAndGet decrements and returns current value
169	*/
170	public void testDecrementAndGet(){
171	AtomicInteger ai = new AtomicInteger(1);
172	assertEquals(0,ai.decrementAndGet());
173	assertEquals(-1,ai.decrementAndGet());
174	assertEquals(-2,ai.decrementAndGet());
175	assertEquals(-2,ai.get());
176	}
177
178	/**
179	* incrementAndGet increments and returns current value
180	*/
181	public void testIncrementAndGet(){
182	AtomicInteger ai = new AtomicInteger(1);
183	assertEquals(2,ai.incrementAndGet());
184	assertEquals(2,ai.get());
185	ai.set(-2);
186	assertEquals(-1,ai.incrementAndGet());
187	assertEquals(0,ai.incrementAndGet());
188	assertEquals(1,ai.incrementAndGet());
189	assertEquals(1,ai.get());
190	}
191
192	/**
193	* a deserialized serialized atomic holds same value
194	*/
195	public void testSerialization() {
196	AtomicInteger l = new AtomicInteger();
197
198	try {
199	l.set(22);
200	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
201	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
202	out.writeObject(l);
203	out.close();
204
205	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
206	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
207	AtomicInteger r = (AtomicInteger) in.readObject();
208	assertEquals(l.get(), r.get());
209	} catch (Exception e){
210	unexpectedException();
211	}
212	}
213
214	/**
215	* toString returns current value.
216	*/
217	public void testToString() {
218	AtomicInteger ai = new AtomicInteger();
219	for (int i = -12; i < 6; ++i) {
220	ai.set(i);
221	assertEquals(ai.toString(), Integer.toString(i));
222	}
223	}
224
225	/**
226	* intValue returns current value.
227	*/
228	public void testIntValue() {
229	AtomicInteger ai = new AtomicInteger();
230	for (int i = -12; i < 6; ++i) {
231	ai.set(i);
232	assertEquals(i, ai.intValue());
233	}
234	}
235
236
237	/**
238	* longValue returns current value.
239	*/
240	public void testLongValue() {
241	AtomicInteger ai = new AtomicInteger();
242	for (int i = -12; i < 6; ++i) {
243	ai.set(i);
244	assertEquals((long)i, ai.longValue());
245	}
246	}
247
248	/**
249	* floatValue returns current value.
250	*/
251	public void testFloatValue() {
252	AtomicInteger ai = new AtomicInteger();
253	for (int i = -12; i < 6; ++i) {
254	ai.set(i);
255	assertEquals((float)i, ai.floatValue());
256	}
257	}
258
259	/**
260	* doubleValue returns current value.
261	*/
262	public void testDoubleValue() {
263	AtomicInteger ai = new AtomicInteger();
264	for (int i = -12; i < 6; ++i) {
265	ai.set(i);
266	assertEquals((double)i, ai.doubleValue());
267	}
268	}
269
270
271
272	}