ViewVC Help

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

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

Comparing jsr166/src/test/tck/AtomicIntegerFieldUpdaterTest.java (file contents):
Revision 1.2 by dl, Sun Sep 14 20:42:40 2003 UTC vs.
Revision 1.25 by jsr166, Tue Apr 2 04:11:28 2013 UTC

#	Line 1 | Line 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.
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/publicdomain/zero/1.0/
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
8	–	import java.util.concurrent.atomic.*;
9		import junit.framework.*;
10	<	import java.util.*;
10	>	import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
11
12		public class AtomicIntegerFieldUpdaterTest extends JSR166TestCase {
13		volatile int x = 0;
14	+	int w;
15		long z;
16	<
16	<	public static void main(String[] args){
16	>	public static void main(String[] args) {
17		junit.textui.TestRunner.run(suite());
18		}
19	–
20	–
19		public static Test suite() {
20		return new TestSuite(AtomicIntegerFieldUpdaterTest.class);
21		}
22
23	<	public void testConstructor(){
24	<	try{
25	<	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest>
28	<	a = AtomicIntegerFieldUpdater.newUpdater
29	<	(getClass(), "y");
30	<	fail("Exception not thrown");
31	<	}
32	<	catch (RuntimeException rt) {}
23	>	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> updaterFor(String fieldName) {
24	>	return AtomicIntegerFieldUpdater.newUpdater
25	>	(AtomicIntegerFieldUpdaterTest.class, fieldName);
26		}
27
28	<	public void testConstructor2(){
29	<	try{
30	<	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest>
31	<	a = AtomicIntegerFieldUpdater.newUpdater
32	<	(getClass(), "z");
33	<	fail("Exception not thrown");
28	>	/**
29	>	* Construction with non-existent field throws RuntimeException
30	>	*/
31	>	public void testConstructor() {
32	>	try {
33	>	updaterFor("y");
34	>	shouldThrow();
35	>	} catch (RuntimeException success) {
36	>	assertTrue(success.getCause() != null);
37		}
42	–	catch (RuntimeException rt) {}
43	–	}
44	–
45	–	public void testGetSet(){
46	–	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a = AtomicIntegerFieldUpdater.newUpdater(getClass(), "x");
47	–	x = 1;
48	–	assertEquals(1,a.get(this));
49	–	a.set(this,2);
50	–	assertEquals(2,a.get(this));
51	–	a.set(this,-3);
52	–	assertEquals(-3,a.get(this));
53	–
54	–	}
55	–	public void testCompareAndSet(){
56	–	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a = AtomicIntegerFieldUpdater.newUpdater(getClass(), "x");
57	–	x = 1;
58	–	assertTrue(a.compareAndSet(this,1,2));
59	–	assertTrue(a.compareAndSet(this,2,-4));
60	–	assertEquals(-4,a.get(this));
61	–	assertFalse(a.compareAndSet(this,-5,7));
62	–	assertFalse((7 == a.get(this)));
63	–	assertTrue(a.compareAndSet(this,-4,7));
64	–	assertEquals(7,a.get(this));
65	–	}
66	–
67	–	public void testWeakCompareAndSet(){
68	–	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a = AtomicIntegerFieldUpdater.newUpdater(getClass(), "x");
69	–	x = 1;
70	–	while(!a.weakCompareAndSet(this,1,2));
71	–	while(!a.weakCompareAndSet(this,2,-4));
72	–	assertEquals(-4,a.get(this));
73	–	while(!a.weakCompareAndSet(this,-4,7));
74	–	assertEquals(7,a.get(this));
75	–	}
76	–
77	–	public void testGetAndSet(){
78	–	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a = AtomicIntegerFieldUpdater.newUpdater(getClass(), "x");
79	–	x = 1;
80	–	assertEquals(1,a.getAndSet(this, 0));
81	–	assertEquals(0,a.getAndSet(this,-10));
82	–	assertEquals(-10,a.getAndSet(this,1));
83	–	}
84	–
85	–	public void testGetAndAdd(){
86	–	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a = AtomicIntegerFieldUpdater.newUpdater(getClass(), "x");
87	–	x = 1;
88	–	assertEquals(1,a.getAndAdd(this,2));
89	–	assertEquals(3,a.get(this));
90	–	assertEquals(3,a.getAndAdd(this,-4));
91	–	assertEquals(-1,a.get(this));
92	–	}
93	–
94	–	public void testGetAndDecrement(){
95	–	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a = AtomicIntegerFieldUpdater.newUpdater(getClass(), "x");
96	–	x = 1;
97	–	assertEquals(1,a.getAndDecrement(this));
98	–	assertEquals(0,a.getAndDecrement(this));
99	–	assertEquals(-1,a.getAndDecrement(this));
100	–	}
101	–
102	–	public void testGetAndIncrement(){
103	–	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a = AtomicIntegerFieldUpdater.newUpdater(getClass(), "x");
104	–	x = 1;
105	–	assertEquals(1,a.getAndIncrement(this));
106	–	assertEquals(2,a.get(this));
107	–	a.set(this,-2);
108	–	assertEquals(-2,a.getAndIncrement(this));
109	–	assertEquals(-1,a.getAndIncrement(this));
110	–	assertEquals(0,a.getAndIncrement(this));
111	–	assertEquals(1,a.get(this));
38		}
39
40	<	public void testAddAndGet(){
41	<	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a = AtomicIntegerFieldUpdater.newUpdater(getClass(), "x");
42	<	x = 1;
43	<	assertEquals(3,a.addAndGet(this,2));
44	<	assertEquals(3,a.get(this));
45	<	assertEquals(-1,a.addAndGet(this,-4));
46	<	assertEquals(-1,a.get(this));
47	<	}
48	<
49	<	public void testDecrementAndGet(){
50	<	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a = AtomicIntegerFieldUpdater.newUpdater(getClass(), "x");
51	<	x = 1;
52	<	assertEquals(0,a.decrementAndGet(this));
53	<	assertEquals(-1,a.decrementAndGet(this));
54	<	assertEquals(-2,a.decrementAndGet(this));
55	<	assertEquals(-2,a.get(this));
56	<	}
57	<
58	<	public void testIncrementAndGet(){
59	<	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a = AtomicIntegerFieldUpdater.newUpdater(getClass(), "x");
60	<	x = 1;
61	<	assertEquals(2,a.incrementAndGet(this));
62	<	assertEquals(2,a.get(this));
63	<	a.set(this,-2);
64	<	assertEquals(-1,a.incrementAndGet(this));
65	<	assertEquals(0,a.incrementAndGet(this));
66	<	assertEquals(1,a.incrementAndGet(this));
67	<	assertEquals(1,a.get(this));
40	>	/**
41	>	* construction with field not of given type throws IllegalArgumentException
42	>	*/
43	>	public void testConstructor2() {
44	>	try {
45	>	updaterFor("z");
46	>	shouldThrow();
47	>	} catch (IllegalArgumentException success) {}
48	>	}
49	>
50	>	/**
51	>	* construction with non-volatile field throws IllegalArgumentException
52	>	*/
53	>	public void testConstructor3() {
54	>	try {
55	>	updaterFor("w");
56	>	shouldThrow();
57	>	} catch (IllegalArgumentException success) {}
58	>	}
59	>
60	>	/**
61	>	* get returns the last value set or assigned
62	>	*/
63	>	public void testGetSet() {
64	>	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
65	>	a = updaterFor("x");
66	>	x = 1;
67	>	assertEquals(1, a.get(this));
68	>	a.set(this, 2);
69	>	assertEquals(2, a.get(this));
70	>	a.set(this, -3);
71	>	assertEquals(-3, a.get(this));
72	>	}
73	>
74	>	/**
75	>	* get returns the last value lazySet by same thread
76	>	*/
77	>	public void testGetLazySet() {
78	>	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
79	>	a = updaterFor("x");
80	>	x = 1;
81	>	assertEquals(1, a.get(this));
82	>	a.lazySet(this, 2);
83	>	assertEquals(2, a.get(this));
84	>	a.lazySet(this, -3);
85	>	assertEquals(-3, a.get(this));
86	>	}
87	>
88	>	/**
89	>	* compareAndSet succeeds in changing value if equal to expected else fails
90	>	*/
91	>	public void testCompareAndSet() {
92	>	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
93	>	a = updaterFor("x");
94	>	x = 1;
95	>	assertTrue(a.compareAndSet(this, 1, 2));
96	>	assertTrue(a.compareAndSet(this, 2, -4));
97	>	assertEquals(-4, a.get(this));
98	>	assertFalse(a.compareAndSet(this, -5, 7));
99	>	assertEquals(-4, a.get(this));
100	>	assertTrue(a.compareAndSet(this, -4, 7));
101	>	assertEquals(7, a.get(this));
102	>	}
103	>
104	>	/**
105	>	* compareAndSet in one thread enables another waiting for value
106	>	* to succeed
107	>	*/
108	>	public void testCompareAndSetInMultipleThreads() throws Exception {
109	>	x = 1;
110	>	final AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
111	>	a = updaterFor("x");
112	>
113	>	Thread t = new Thread(new CheckedRunnable() {
114	>	public void realRun() {
115	>	while (!a.compareAndSet(AtomicIntegerFieldUpdaterTest.this, 2, 3))
116	>	Thread.yield();
117	>	}});
118	>
119	>	t.start();
120	>	assertTrue(a.compareAndSet(this, 1, 2));
121	>	t.join(LONG_DELAY_MS);
122	>	assertFalse(t.isAlive());
123	>	assertEquals(3, a.get(this));
124	>	}
125	>
126	>	/**
127	>	* repeated weakCompareAndSet succeeds in changing value when equal
128	>	* to expected
129	>	*/
130	>	public void testWeakCompareAndSet() {
131	>	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
132	>	a = updaterFor("x");
133	>	x = 1;
134	>	while (!a.weakCompareAndSet(this, 1, 2));
135	>	while (!a.weakCompareAndSet(this, 2, -4));
136	>	assertEquals(-4, a.get(this));
137	>	while (!a.weakCompareAndSet(this, -4, 7));
138	>	assertEquals(7, a.get(this));
139	>	}
140	>
141	>	/**
142	>	* getAndSet returns previous value and sets to given value
143	>	*/
144	>	public void testGetAndSet() {
145	>	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
146	>	a = updaterFor("x");
147	>	x = 1;
148	>	assertEquals(1, a.getAndSet(this, 0));
149	>	assertEquals(0, a.getAndSet(this, -10));
150	>	assertEquals(-10, a.getAndSet(this, 1));
151	>	}
152	>
153	>	/**
154	>	* getAndAdd returns previous value and adds given value
155	>	*/
156	>	public void testGetAndAdd() {
157	>	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
158	>	a = updaterFor("x");
159	>	x = 1;
160	>	assertEquals(1, a.getAndAdd(this, 2));
161	>	assertEquals(3, a.get(this));
162	>	assertEquals(3, a.getAndAdd(this, -4));
163	>	assertEquals(-1, a.get(this));
164	>	}
165	>
166	>	/**
167	>	* getAndDecrement returns previous value and decrements
168	>	*/
169	>	public void testGetAndDecrement() {
170	>	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
171	>	a = updaterFor("x");
172	>	x = 1;
173	>	assertEquals(1, a.getAndDecrement(this));
174	>	assertEquals(0, a.getAndDecrement(this));
175	>	assertEquals(-1, a.getAndDecrement(this));
176	>	}
177	>
178	>	/**
179	>	* getAndIncrement returns previous value and increments
180	>	*/
181	>	public void testGetAndIncrement() {
182	>	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
183	>	a = updaterFor("x");
184	>	x = 1;
185	>	assertEquals(1, a.getAndIncrement(this));
186	>	assertEquals(2, a.get(this));
187	>	a.set(this, -2);
188	>	assertEquals(-2, a.getAndIncrement(this));
189	>	assertEquals(-1, a.getAndIncrement(this));
190	>	assertEquals(0, a.getAndIncrement(this));
191	>	assertEquals(1, a.get(this));
192	>	}
193	>
194	>	/**
195	>	* addAndGet adds given value to current, and returns current value
196	>	*/
197	>	public void testAddAndGet() {
198	>	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
199	>	a = updaterFor("x");
200	>	x = 1;
201	>	assertEquals(3, a.addAndGet(this, 2));
202	>	assertEquals(3, a.get(this));
203	>	assertEquals(-1, a.addAndGet(this, -4));
204	>	assertEquals(-1, a.get(this));
205	>	}
206	>
207	>	/**
208	>	* decrementAndGet decrements and returns current value
209	>	*/
210	>	public void testDecrementAndGet() {
211	>	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
212	>	a = updaterFor("x");
213	>	x = 1;
214	>	assertEquals(0, a.decrementAndGet(this));
215	>	assertEquals(-1, a.decrementAndGet(this));
216	>	assertEquals(-2, a.decrementAndGet(this));
217	>	assertEquals(-2, a.get(this));
218	>	}
219	>
220	>	/**
221	>	* incrementAndGet increments and returns current value
222	>	*/
223	>	public void testIncrementAndGet() {
224	>	AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
225	>	a = updaterFor("x");
226	>	x = 1;
227	>	assertEquals(2, a.incrementAndGet(this));
228	>	assertEquals(2, a.get(this));
229	>	a.set(this, -2);
230	>	assertEquals(-1, a.incrementAndGet(this));
231	>	assertEquals(0, a.incrementAndGet(this));
232	>	assertEquals(1, a.incrementAndGet(this));
233	>	assertEquals(1, a.get(this));
234		}
235
236		}

Diff Legend

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