test/tck/AtomicLongTest.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 AtomicLongTest extends JSR166TestCase {
    public static void main(String[] args) {
        junit.textui.TestRunner.run(suite());
    }
    public static Test suite() {
        return new TestSuite(AtomicLongTest.class);
    }

    final long[] VALUES = {
        Long.MIN_VALUE,
        Integer.MIN_VALUE, -1, 0, 1, 42, Integer.MAX_VALUE,
        Long.MAX_VALUE,
    };

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

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

    /**
     * get returns the last value set
     */
    public void testGetSet() {
        AtomicLong ai = new AtomicLong(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() {
        AtomicLong ai = new AtomicLong(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() {
        AtomicLong ai = new AtomicLong(1);
        assertTrue(ai.compareAndSet(1,2));
        assertTrue(ai.compareAndSet(2,-4));
        assertEquals(-4,ai.get());
        assertFalse(ai.compareAndSet(-5,7));
        assertEquals(-4,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() throws Exception {
        final AtomicLong ai = new AtomicLong(1);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                while (!ai.compareAndSet(2, 3))
                    Thread.yield();
            }});

        t.start();
        assertTrue(ai.compareAndSet(1, 2));
        t.join(LONG_DELAY_MS);
        assertFalse(t.isAlive());
        assertEquals(ai.get(), 3);
    }

    /**
     * repeated weakCompareAndSet succeeds in changing value when equal
     * to expected
     */
    public void testWeakCompareAndSet() {
        AtomicLong ai = new AtomicLong(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() {
        AtomicLong ai = new AtomicLong(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() {
        AtomicLong ai = new AtomicLong(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() {
        AtomicLong ai = new AtomicLong(1);
        assertEquals(1,ai.getAndDecrement());
        assertEquals(0,ai.getAndDecrement());
        assertEquals(-1,ai.getAndDecrement());
    }

    /**
     * getAndIncrement returns previous value and increments
     */
    public void testGetAndIncrement() {
        AtomicLong ai = new AtomicLong(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() {
        AtomicLong ai = new AtomicLong(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() {
        AtomicLong ai = new AtomicLong(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() {
        AtomicLong ai = new AtomicLong(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() throws Exception {
        AtomicLong l = new AtomicLong();

        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));
        AtomicLong r = (AtomicLong) in.readObject();
        assertEquals(l.get(), r.get());
    }

    /**
     * toString returns current value.
     */
    public void testToString() {
        AtomicLong ai = new AtomicLong();
        assertEquals("0", ai.toString());
        for (long i : VALUES) {
            ai.set(i);
            assertEquals(ai.toString(), Long.toString(i));
        }
    }

    /**
     * intValue returns current value.
     */
    public void testIntValue() {
        AtomicLong ai = new AtomicLong();
        assertEquals(0, ai.intValue());
        for (long x : VALUES) {
            ai.set(x);
            assertEquals((int)x, ai.intValue());
        }
    }

    /**
     * longValue returns current value.
     */
    public void testLongValue() {
        AtomicLong ai = new AtomicLong();
        assertEquals(0L, ai.longValue());
        for (long x : VALUES) {
            ai.set(x);
            assertEquals((long)x, ai.longValue());
        }
    }

    /**
     * floatValue returns current value.
     */
    public void testFloatValue() {
        AtomicLong ai = new AtomicLong();
        assertEquals(0.0f, ai.floatValue());
        for (long x : VALUES) {
            ai.set(x);
            assertEquals((float)x, ai.floatValue());
        }
    }

    /**
     * doubleValue returns current value.
     */
    public void testDoubleValue() {
        AtomicLong ai = new AtomicLong();
        assertEquals(0.0d, ai.doubleValue());
        for (long x : VALUES) {
            ai.set(x);
            assertEquals((double)x, ai.doubleValue());
        }
    }

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