ViewVC Help

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

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

Comparing jsr166/src/test/tck/AtomicReferenceFieldUpdaterTest.java (file contents):
Revision 1.2 by dl, Sun Sep 14 20:42:40 2003 UTC vs.
Revision 1.22 by jsr166, Fri May 27 19:39:07 2011 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
9		import java.util.concurrent.atomic.*;
10		import junit.framework.*;
11		import java.util.*;
12
13	<	public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase{
13	>	public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase {
14		volatile Integer x = null;
15		Object z;
16		Integer w;
17
18	<	public static void main(String[] args){
18	>	public static void main(String[] args) {
19		junit.textui.TestRunner.run(suite());
20		}
20	–
21	–
21		public static Test suite() {
22		return new TestSuite(AtomicReferenceFieldUpdaterTest.class);
23		}
24
25	<	public void testConstructor(){
26	<	try{
25	>	/**
26	>	* Construction with non-existent field throws RuntimeException
27	>	*/
28	>	public void testConstructor() {
29	>	try {
30		AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>
31		a = AtomicReferenceFieldUpdater.newUpdater
32	<	(getClass(), Integer.class, "y");
33	<	fail("Exception not thrown");
34	<	}
33	<
34	<	catch (RuntimeException rt) {}
32	>	(AtomicReferenceFieldUpdaterTest.class, Integer.class, "y");
33	>	shouldThrow();
34	>	} catch (RuntimeException success) {}
35		}
36
37	<
38	<	public void testConstructor2(){
39	<	try{
37	>	/**
38	>	* construction with field not of given type throws RuntimeException
39	>	*/
40	>	public void testConstructor2() {
41	>	try {
42		AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>
43		a = AtomicReferenceFieldUpdater.newUpdater
44	<	(getClass(), Integer.class, "z");
45	<	fail("Exception not thrown");
46	<	}
45	<
46	<	catch (RuntimeException rt) {}
44	>	(AtomicReferenceFieldUpdaterTest.class, Integer.class, "z");
45	>	shouldThrow();
46	>	} catch (RuntimeException success) {}
47		}
48
49	<	public void testConstructor3(){
50	<	try{
49	>	/**
50	>	* Constructor with non-volatile field throws exception
51	>	*/
52	>	public void testConstructor3() {
53	>	try {
54		AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>
55		a = AtomicReferenceFieldUpdater.newUpdater
56	<	(getClass(), Integer.class, "w");
57	<	fail("Exception not thrown");
58	<	}
56	<
57	<	catch (RuntimeException rt) {}
56	>	(AtomicReferenceFieldUpdaterTest.class, Integer.class, "w");
57	>	shouldThrow();
58	>	} catch (RuntimeException success) {}
59		}
60
61	<	public void testGetSet(){
62	<	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a = AtomicReferenceFieldUpdater.newUpdater(getClass(), Integer.class, "x");
61	>	/**
62	>	* get returns the last value set or assigned
63	>	*/
64	>	public void testGetSet() {
65	>	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
66	>	try {
67	>	a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
68	>	} catch (RuntimeException ok) {
69	>	return;
70	>	}
71		x = one;
72	<	assertEquals(one,a.get(this));
73	<	a.set(this,two);
74	<	assertEquals(two,a.get(this));
75	<	a.set(this,-3);
76	<	assertEquals(-3,a.get(this));
77	<
78	<	}
79	<	public void testCompareAndSet(){
80	<	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a = AtomicReferenceFieldUpdater.newUpdater(getClass(), Integer.class, "x");
72	>	assertSame(one,a.get(this));
73	>	a.set(this,two);
74	>	assertSame(two,a.get(this));
75	>	a.set(this,m3);
76	>	assertSame(m3,a.get(this));
77	>	}
78	>
79	>	/**
80	>	* get returns the last value lazySet by same thread
81	>	*/
82	>	public void testGetLazySet() {
83	>	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
84	>	try {
85	>	a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
86	>	} catch (RuntimeException ok) {
87	>	return;
88	>	}
89		x = one;
90	<	assertTrue(a.compareAndSet(this,one,two));
91	<	assertTrue(a.compareAndSet(this,two,m4));
92	<	assertEquals(m4,a.get(this));
93	<	assertFalse(a.compareAndSet(this,m5,seven));
94	<	assertFalse((seven == a.get(this)));
95	<	assertTrue(a.compareAndSet(this,m4,seven));
96	<	assertEquals(seven,a.get(this));
90	>	assertSame(one,a.get(this));
91	>	a.lazySet(this,two);
92	>	assertSame(two,a.get(this));
93	>	a.lazySet(this,m3);
94	>	assertSame(m3,a.get(this));
95	>	}
96	>
97	>	/**
98	>	* compareAndSet succeeds in changing value if equal to expected else fails
99	>	*/
100	>	public void testCompareAndSet() {
101	>	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
102	>	try {
103	>	a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
104	>	} catch (RuntimeException ok) {
105	>	return;
106	>	}
107	>	x = one;
108	>	assertTrue(a.compareAndSet(this, one, two));
109	>	assertTrue(a.compareAndSet(this, two, m4));
110	>	assertSame(m4, a.get(this));
111	>	assertFalse(a.compareAndSet(this, m5, seven));
112	>	assertFalse(seven == a.get(this));
113	>	assertTrue(a.compareAndSet(this, m4, seven));
114	>	assertSame(seven,a.get(this));
115		}
116
117	<	public void testWeakCompareAndSet(){
118	<	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a = AtomicReferenceFieldUpdater.newUpdater(getClass(), Integer.class, "x");
117	>	/**
118	>	* compareAndSet in one thread enables another waiting for value
119	>	* to succeed
120	>	*/
121	>	public void testCompareAndSetInMultipleThreads() throws Exception {
122		x = one;
123	<	while(!a.weakCompareAndSet(this,one,two));
124	<	while(!a.weakCompareAndSet(this,two,m4));
125	<	assertEquals(m4,a.get(this));
126	<	while(!a.weakCompareAndSet(this,m4,seven));
127	<	assertEquals(seven,a.get(this));
128	<	}
123	>	final AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
124	>	try {
125	>	a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
126	>	} catch (RuntimeException ok) {
127	>	return;
128	>	}
129
130	<	public void testGetAndSet(){
131	<	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a = AtomicReferenceFieldUpdater.newUpdater(getClass(), Integer.class, "x");
130	>	Thread t = new Thread(new CheckedRunnable() {
131	>	public void realRun() {
132	>	while (!a.compareAndSet(AtomicReferenceFieldUpdaterTest.this, two, three))
133	>	Thread.yield();
134	>	}});
135	>
136	>	t.start();
137	>	assertTrue(a.compareAndSet(this, one, two));
138	>	t.join(LONG_DELAY_MS);
139	>	assertFalse(t.isAlive());
140	>	assertSame(a.get(this), three);
141	>	}
142	>
143	>	/**
144	>	* repeated weakCompareAndSet succeeds in changing value when equal
145	>	* to expected
146	>	*/
147	>	public void testWeakCompareAndSet() {
148	>	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
149	>	try {
150	>	a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
151	>	} catch (RuntimeException ok) {
152	>	return;
153	>	}
154	>	x = one;
155	>	while (!a.weakCompareAndSet(this,one,two));
156	>	while (!a.weakCompareAndSet(this,two,m4));
157	>	assertSame(m4,a.get(this));
158	>	while (!a.weakCompareAndSet(this,m4,seven));
159	>	assertSame(seven,a.get(this));
160	>	}
161	>
162	>	/**
163	>	* getAndSet returns previous value and sets to given value
164	>	*/
165	>	public void testGetAndSet() {
166	>	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
167	>	try {
168	>	a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
169	>	} catch (RuntimeException ok) {
170	>	return;
171	>	}
172		x = one;
173	<	assertEquals(one,a.getAndSet(this, zero));
174	<	assertEquals(zero,a.getAndSet(this,m10));
175	<	assertEquals(m10,a.getAndSet(this,1));
173	>	assertSame(one,a.getAndSet(this, zero));
174	>	assertSame(zero,a.getAndSet(this,m10));
175	>	assertSame(m10,a.getAndSet(this,1));
176		}
177
178		}

Diff Legend

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