ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/AtomicLongTest.java

Comparing jsr166/src/test/tck/AtomicLongTest.java (file contents):
Revision 1.13 by jsr166, Mon Nov 16 05:30:07 2009 UTC vs.
Revision 1.26 by jsr166, Thu May 30 03:28:55 2013 UTC

#	Line 1 | Line 1
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
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
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.*;
10	>	import java.util.concurrent.atomic.AtomicLong;
11
12		public class AtomicLongTest extends JSR166TestCase {
13	<	public static void main (String[] args) {
14	<	junit.textui.TestRunner.run (suite());
13	>	public static void main(String[] args) {
14	>	junit.textui.TestRunner.run(suite());
15		}
16		public static Test suite() {
17		return new TestSuite(AtomicLongTest.class);
18		}
19
20	+	final long[] VALUES = {
21	+	Long.MIN_VALUE,
22	+	Integer.MIN_VALUE, -1, 0, 1, 42, Integer.MAX_VALUE,
23	+	Long.MAX_VALUE,
24	+	};
25	+
26		/**
27		* constructor initializes to given value
28		*/
29		public void testConstructor() {
30		AtomicLong ai = new AtomicLong(1);
31	<	assertEquals(1,ai.get());
31	>	assertEquals(1, ai.get());
32		}
33
34		/**
#	Line 31 | Line 36 | public class AtomicLongTest extends JSR1
36		*/
37		public void testConstructor2() {
38		AtomicLong ai = new AtomicLong();
39	<	assertEquals(0,ai.get());
39	>	assertEquals(0, ai.get());
40		}
41
42		/**
#	Line 39 | Line 44 | public class AtomicLongTest extends JSR1
44		*/
45		public void testGetSet() {
46		AtomicLong ai = new AtomicLong(1);
47	<	assertEquals(1,ai.get());
48	<	ai.set(2);
49	<	assertEquals(2,ai.get());
50	<	ai.set(-3);
51	<	assertEquals(-3,ai.get());
47	<
47	>	assertEquals(1, ai.get());
48	>	ai.set(2);
49	>	assertEquals(2, ai.get());
50	>	ai.set(-3);
51	>	assertEquals(-3, ai.get());
52		}
53
54		/**
#	Line 52 | Line 56 | public class AtomicLongTest extends JSR1
56		*/
57		public void testGetLazySet() {
58		AtomicLong ai = new AtomicLong(1);
59	<	assertEquals(1,ai.get());
60	<	ai.lazySet(2);
61	<	assertEquals(2,ai.get());
62	<	ai.lazySet(-3);
63	<	assertEquals(-3,ai.get());
60	<
59	>	assertEquals(1, ai.get());
60	>	ai.lazySet(2);
61	>	assertEquals(2, ai.get());
62	>	ai.lazySet(-3);
63	>	assertEquals(-3, ai.get());
64		}
65
66		/**
#	Line 65 | Line 68 | public class AtomicLongTest extends JSR1
68		*/
69		public void testCompareAndSet() {
70		AtomicLong ai = new AtomicLong(1);
71	<	assertTrue(ai.compareAndSet(1,2));
72	<	assertTrue(ai.compareAndSet(2,-4));
73	<	assertEquals(-4,ai.get());
74	<	assertFalse(ai.compareAndSet(-5,7));
75	<	assertFalse((7 == ai.get()));
76	<	assertTrue(ai.compareAndSet(-4,7));
77	<	assertEquals(7,ai.get());
71	>	assertTrue(ai.compareAndSet(1, 2));
72	>	assertTrue(ai.compareAndSet(2, -4));
73	>	assertEquals(-4, ai.get());
74	>	assertFalse(ai.compareAndSet(-5, 7));
75	>	assertEquals(-4, ai.get());
76	>	assertTrue(ai.compareAndSet(-4, 7));
77	>	assertEquals(7, ai.get());
78		}
79
80		/**
81		* compareAndSet in one thread enables another waiting for value
82		* to succeed
83		*/
84	<	public void testCompareAndSetInMultipleThreads() {
84	>	public void testCompareAndSetInMultipleThreads() throws Exception {
85		final AtomicLong ai = new AtomicLong(1);
86	<	Thread t = new Thread(new Runnable() {
87	<	public void run() {
88	<	while (!ai.compareAndSet(2, 3)) Thread.yield();
89	<	}});
90	<	try {
91	<	t.start();
92	<	assertTrue(ai.compareAndSet(1, 2));
93	<	t.join(LONG_DELAY_MS);
94	<	assertFalse(t.isAlive());
95	<	assertEquals(ai.get(), 3);
96	<	}
94	<	catch (Exception e) {
95	<	unexpectedException();
96	<	}
86	>	Thread t = new Thread(new CheckedRunnable() {
87	>	public void realRun() {
88	>	while (!ai.compareAndSet(2, 3))
89	>	Thread.yield();
90	>	}});
91	>
92	>	t.start();
93	>	assertTrue(ai.compareAndSet(1, 2));
94	>	t.join(LONG_DELAY_MS);
95	>	assertFalse(t.isAlive());
96	>	assertEquals(3, ai.get());
97		}
98
99		/**
#	Line 102 | Line 102 | public class AtomicLongTest extends JSR1
102		*/
103		public void testWeakCompareAndSet() {
104		AtomicLong ai = new AtomicLong(1);
105	<	while (!ai.weakCompareAndSet(1,2));
106	<	while (!ai.weakCompareAndSet(2,-4));
107	<	assertEquals(-4,ai.get());
108	<	while (!ai.weakCompareAndSet(-4,7));
109	<	assertEquals(7,ai.get());
105	>	while (!ai.weakCompareAndSet(1, 2));
106	>	while (!ai.weakCompareAndSet(2, -4));
107	>	assertEquals(-4, ai.get());
108	>	while (!ai.weakCompareAndSet(-4, 7));
109	>	assertEquals(7, ai.get());
110		}
111
112		/**
#	Line 114 | Line 114 | public class AtomicLongTest extends JSR1
114		*/
115		public void testGetAndSet() {
116		AtomicLong ai = new AtomicLong(1);
117	<	assertEquals(1,ai.getAndSet(0));
118	<	assertEquals(0,ai.getAndSet(-10));
119	<	assertEquals(-10,ai.getAndSet(1));
117	>	assertEquals(1, ai.getAndSet(0));
118	>	assertEquals(0, ai.getAndSet(-10));
119	>	assertEquals(-10, ai.getAndSet(1));
120		}
121
122		/**
#	Line 124 | Line 124 | public class AtomicLongTest extends JSR1
124		*/
125		public void testGetAndAdd() {
126		AtomicLong ai = new AtomicLong(1);
127	<	assertEquals(1,ai.getAndAdd(2));
128	<	assertEquals(3,ai.get());
129	<	assertEquals(3,ai.getAndAdd(-4));
130	<	assertEquals(-1,ai.get());
127	>	assertEquals(1, ai.getAndAdd(2));
128	>	assertEquals(3, ai.get());
129	>	assertEquals(3, ai.getAndAdd(-4));
130	>	assertEquals(-1, ai.get());
131		}
132
133		/**
#	Line 135 | Line 135 | public class AtomicLongTest extends JSR1
135		*/
136		public void testGetAndDecrement() {
137		AtomicLong ai = new AtomicLong(1);
138	<	assertEquals(1,ai.getAndDecrement());
139	<	assertEquals(0,ai.getAndDecrement());
140	<	assertEquals(-1,ai.getAndDecrement());
138	>	assertEquals(1, ai.getAndDecrement());
139	>	assertEquals(0, ai.getAndDecrement());
140	>	assertEquals(-1, ai.getAndDecrement());
141		}
142
143		/**
#	Line 145 | Line 145 | public class AtomicLongTest extends JSR1
145		*/
146		public void testGetAndIncrement() {
147		AtomicLong ai = new AtomicLong(1);
148	<	assertEquals(1,ai.getAndIncrement());
149	<	assertEquals(2,ai.get());
150	<	ai.set(-2);
151	<	assertEquals(-2,ai.getAndIncrement());
152	<	assertEquals(-1,ai.getAndIncrement());
153	<	assertEquals(0,ai.getAndIncrement());
154	<	assertEquals(1,ai.get());
148	>	assertEquals(1, ai.getAndIncrement());
149	>	assertEquals(2, ai.get());
150	>	ai.set(-2);
151	>	assertEquals(-2, ai.getAndIncrement());
152	>	assertEquals(-1, ai.getAndIncrement());
153	>	assertEquals(0, ai.getAndIncrement());
154	>	assertEquals(1, ai.get());
155		}
156
157		/**
#	Line 159 | Line 159 | public class AtomicLongTest extends JSR1
159		*/
160		public void testAddAndGet() {
161		AtomicLong ai = new AtomicLong(1);
162	<	assertEquals(3,ai.addAndGet(2));
163	<	assertEquals(3,ai.get());
164	<	assertEquals(-1,ai.addAndGet(-4));
165	<	assertEquals(-1,ai.get());
162	>	assertEquals(3, ai.addAndGet(2));
163	>	assertEquals(3, ai.get());
164	>	assertEquals(-1, ai.addAndGet(-4));
165	>	assertEquals(-1, ai.get());
166		}
167
168		/**
#	Line 170 | Line 170 | public class AtomicLongTest extends JSR1
170		*/
171		public void testDecrementAndGet() {
172		AtomicLong ai = new AtomicLong(1);
173	<	assertEquals(0,ai.decrementAndGet());
174	<	assertEquals(-1,ai.decrementAndGet());
175	<	assertEquals(-2,ai.decrementAndGet());
176	<	assertEquals(-2,ai.get());
173	>	assertEquals(0, ai.decrementAndGet());
174	>	assertEquals(-1, ai.decrementAndGet());
175	>	assertEquals(-2, ai.decrementAndGet());
176	>	assertEquals(-2, ai.get());
177		}
178
179		/**
#	Line 181 | Line 181 | public class AtomicLongTest extends JSR1
181		*/
182		public void testIncrementAndGet() {
183		AtomicLong ai = new AtomicLong(1);
184	<	assertEquals(2,ai.incrementAndGet());
185	<	assertEquals(2,ai.get());
186	<	ai.set(-2);
187	<	assertEquals(-1,ai.incrementAndGet());
188	<	assertEquals(0,ai.incrementAndGet());
189	<	assertEquals(1,ai.incrementAndGet());
190	<	assertEquals(1,ai.get());
184	>	assertEquals(2, ai.incrementAndGet());
185	>	assertEquals(2, ai.get());
186	>	ai.set(-2);
187	>	assertEquals(-1, ai.incrementAndGet());
188	>	assertEquals(0, ai.incrementAndGet());
189	>	assertEquals(1, ai.incrementAndGet());
190	>	assertEquals(1, ai.get());
191		}
192
193		/**
194		* a deserialized serialized atomic holds same value
195		*/
196	<	public void testSerialization() {
197	<	AtomicLong l = new AtomicLong();
198	<
199	<	try {
200	<	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	<	} catch (Exception e) {
211	<	unexpectedException();
212	<	}
196	>	public void testSerialization() throws Exception {
197	>	AtomicLong x = new AtomicLong();
198	>	AtomicLong y = serialClone(x);
199	>	assertNotSame(x, y);
200	>	x.set(-22);
201	>	AtomicLong z = serialClone(x);
202	>	assertNotSame(y, z);
203	>	assertEquals(-22, x.get());
204	>	assertEquals(0, y.get());
205	>	assertEquals(-22, z.get());
206		}
207
208		/**
#	Line 217 | Line 210 | public class AtomicLongTest extends JSR1
210		*/
211		public void testToString() {
212		AtomicLong ai = new AtomicLong();
213	<	for (long i = -12; i < 6; ++i) {
214	<	ai.set(i);
215	<	assertEquals(ai.toString(), Long.toString(i));
213	>	assertEquals("0", ai.toString());
214	>	for (long x : VALUES) {
215	>	ai.set(x);
216	>	assertEquals(Long.toString(x), ai.toString());
217	>	}
218	>	}
219	>
220	>	/**
221	>	* intValue returns current value.
222	>	*/
223	>	public void testIntValue() {
224	>	AtomicLong ai = new AtomicLong();
225	>	assertEquals(0, ai.intValue());
226	>	for (long x : VALUES) {
227	>	ai.set(x);
228	>	assertEquals((int)x, ai.intValue());
229		}
230		}
231
#	Line 228 | Line 234 | public class AtomicLongTest extends JSR1
234		*/
235		public void testLongValue() {
236		AtomicLong ai = new AtomicLong();
237	<	for (int i = -12; i < 6; ++i) {
238	<	ai.set(i);
239	<	assertEquals((long)i, ai.longValue());
237	>	assertEquals(0L, ai.longValue());
238	>	for (long x : VALUES) {
239	>	ai.set(x);
240	>	assertEquals(x, ai.longValue());
241		}
242		}
243
#	Line 239 | Line 246 | public class AtomicLongTest extends JSR1
246		*/
247		public void testFloatValue() {
248		AtomicLong ai = new AtomicLong();
249	<	for (int i = -12; i < 6; ++i) {
250	<	ai.set(i);
251	<	assertEquals((float)i, ai.floatValue());
249	>	assertEquals(0.0f, ai.floatValue());
250	>	for (long x : VALUES) {
251	>	ai.set(x);
252	>	assertEquals((float)x, ai.floatValue());
253		}
254		}
255
#	Line 250 | Line 258 | public class AtomicLongTest extends JSR1
258		*/
259		public void testDoubleValue() {
260		AtomicLong ai = new AtomicLong();
261	<	for (int i = -12; i < 6; ++i) {
262	<	ai.set(i);
263	<	assertEquals((double)i, ai.doubleValue());
261	>	assertEquals(0.0d, ai.doubleValue());
262	>	for (long x : VALUES) {
263	>	ai.set(x);
264	>	assertEquals((double)x, ai.doubleValue());
265		}
266		}
267
259	–
268		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines