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.11
Committed:	Fri Oct 7 14:58:35 2005 UTC (18 years, 7 months ago) by dl
Branch:	MAIN
Changes since 1.10:	+13 -0 lines
Log Message:	Re-insert accidentally deleted test case
#	User	Rev	Content
1	dl	1.1	/*
2	dl	1.6	* 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	dl	1.1	*/
8
9			import junit.framework.*;
10			import java.util.concurrent.atomic.*;
11	dl	1.2	import java.io.*;
12	dl	1.1
13	dl	1.3	public class AtomicIntegerTest extends JSR166TestCase {
14	dl	1.1	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	dl	1.4	/**
22	dl	1.5	* constructor initializes to given value
23	dl	1.4	*/
24	dl	1.1	public void testConstructor(){
25			AtomicInteger ai = new AtomicInteger(1);
26			assertEquals(1,ai.get());
27			}
28
29	dl	1.4	/**
30	dl	1.7	* default constructed initializes to zero
31	dl	1.4	*/
32	dl	1.1	public void testConstructor2(){
33			AtomicInteger ai = new AtomicInteger();
34			assertEquals(0,ai.get());
35			}
36
37	dl	1.4	/**
38	dl	1.11	* 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	dl	1.10	* get returns the last value lazySet in same thread
52	dl	1.4	*/
53	dl	1.10	public void testGetLazySet(){
54	dl	1.1	AtomicInteger ai = new AtomicInteger(1);
55			assertEquals(1,ai.get());
56	dl	1.10	ai.lazySet(2);
57	dl	1.1	assertEquals(2,ai.get());
58	dl	1.10	ai.lazySet(-3);
59	dl	1.1	assertEquals(-3,ai.get());
60
61			}
62	dl	1.4	/**
63	dl	1.5	* compareAndSet succeeds in changing value if equal to expected else fails
64	dl	1.4	*/
65	dl	1.1	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	dl	1.4	/**
77	dl	1.5	* 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	dl	1.4	*/
102	dl	1.1	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	dl	1.4	/**
112	dl	1.5	* getAndSet returns previous value and sets to given value
113	dl	1.4	*/
114	dl	1.1	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	dl	1.4	/**
122	dl	1.5	* getAndAdd returns previous value and adds given value
123	dl	1.4	*/
124	dl	1.1	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	dl	1.4	/**
133	dl	1.5	* getAndDecrement returns previous value and decrements
134	dl	1.4	*/
135	dl	1.1	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	dl	1.4	/**
143	dl	1.5	* getAndIncrement returns previous value and increments
144	dl	1.4	*/
145	dl	1.1	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	dl	1.4	/**
157	dl	1.5	* addAndGet adds given value to current, and returns current value
158	dl	1.4	*/
159	dl	1.1	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	dl	1.4	/**
168	dl	1.5	* decrementAndGet decrements and returns current value
169	dl	1.4	*/
170	dl	1.1	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	dl	1.4	/**
179	dl	1.5	* incrementAndGet increments and returns current value
180	dl	1.4	*/
181	dl	1.1	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	dl	1.2	}
191
192	dl	1.4	/**
193	dl	1.5	* a deserialized serialized atomic holds same value
194	dl	1.4	*/
195	dl	1.2	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	dl	1.4	unexpectedException();
211	dl	1.2	}
212	dl	1.1	}
213
214	dl	1.8	/**
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	dl	1.1
225	dl	1.9	/**
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	dl	1.1	}