test/tck/AtomicReferenceFieldUpdaterTest.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 java.util.concurrent.atomic.*;
import junit.framework.*;
import java.util.*;

public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase{
    volatile Integer x = null;
    Object z;
    Integer w;

    public static void main(String[] args){
        junit.textui.TestRunner.run(suite());
    }
    public static Test suite() {
        return new TestSuite(AtomicReferenceFieldUpdaterTest.class);
    }

    /**
     * Construction with non-existent field throws RuntimeException
     */
    public void testConstructor(){
        try {
            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>
                a = AtomicReferenceFieldUpdater.newUpdater
                (AtomicReferenceFieldUpdaterTest.class, Integer.class, "y");
            shouldThrow();
        }
        catch (RuntimeException rt) {}
    }


    /**
     * construction with field not of given type throws RuntimeException
     */
    public void testConstructor2(){
        try {
            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>
                a = AtomicReferenceFieldUpdater.newUpdater
                (AtomicReferenceFieldUpdaterTest.class, Integer.class, "z");
            shouldThrow();
        }
        catch (RuntimeException rt) {}
    }

    /**
     * Constructor with non-volatile field throws exception
     */
    public void testConstructor3(){
        try {
            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>
                a = AtomicReferenceFieldUpdater.newUpdater
                (AtomicReferenceFieldUpdaterTest.class, Integer.class, "w");
            shouldThrow();
        }
        catch (RuntimeException rt) {}
    }

    /**
     *  get returns the last value set or assigned
     */
    public void testGetSet(){
        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
        try {
            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
        } catch (RuntimeException ok) {
            return;
        }
        x = one;
        assertEquals(one,a.get(this));
        a.set(this,two);
        assertEquals(two,a.get(this));
        a.set(this,m3);
        assertEquals(m3,a.get(this));
    }

    /**
     *  get returns the last value lazySet by same thread
     */
    public void testGetLazySet(){
        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
        try {
            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
        } catch (RuntimeException ok) {
            return;
        }
        x = one;
        assertEquals(one,a.get(this));
        a.lazySet(this,two);
        assertEquals(two,a.get(this));
        a.lazySet(this,m3);
        assertEquals(m3,a.get(this));
    }

    /**
     * compareAndSet succeeds in changing value if equal to expected else fails
     */
    public void testCompareAndSet(){
        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
        try {
            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
        } catch (RuntimeException ok) {
            return;
        }
        x = one;
        assertTrue(a.compareAndSet(this,one,two));
        assertTrue(a.compareAndSet(this,two,m4));
        assertEquals(m4,a.get(this));
        assertFalse(a.compareAndSet(this,m5,seven));
        assertFalse((seven == a.get(this)));
        assertTrue(a.compareAndSet(this,m4,seven));
        assertEquals(seven,a.get(this));
    }

    /**
     * compareAndSet in one thread enables another waiting for value
     * to succeed
     */
    public void testCompareAndSetInMultipleThreads() {
        x = one;
        final AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
        try {
            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
        } catch (RuntimeException ok) {
            return;
        }

        Thread t = new Thread(new Runnable() {
                public void run() {
                    while (!a.compareAndSet(AtomicReferenceFieldUpdaterTest.this, two, three)) Thread.yield();
                }});
        try {
            t.start();
            assertTrue(a.compareAndSet(this, one, two));
            t.join(LONG_DELAY_MS);
            assertFalse(t.isAlive());
            assertEquals(a.get(this), three);
        }
        catch (Exception e) {
            unexpectedException();
        }
    }

    /**
     * repeated weakCompareAndSet succeeds in changing value when equal
     * to expected
     */
    public void testWeakCompareAndSet(){
        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
        try {
            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
        } catch (RuntimeException ok) {
            return;
        }
        x = one;
        while (!a.weakCompareAndSet(this,one,two));
        while (!a.weakCompareAndSet(this,two,m4));
        assertEquals(m4,a.get(this));
        while (!a.weakCompareAndSet(this,m4,seven));
        assertEquals(seven,a.get(this));
    }

    /**
     * getAndSet returns previous value and sets to given value
     */
    public void testGetAndSet(){
        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
        try {
            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
        } catch (RuntimeException ok) {
            return;
        }
        x = one;
        assertEquals(one,a.getAndSet(this, zero));
        assertEquals(zero,a.getAndSet(this,m10));
        assertEquals(m10,a.getAndSet(this,1));
    }

}
Revision:	1.12
Committed:	Mon Nov 16 04:57:10 2009 UTC (14 years, 5 months ago) by jsr166
Branch:	MAIN
Changes since 1.11:	+8 -8 lines
Log Message:	whitespace
#	Content
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
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{
14	volatile Integer x = null;
15	Object z;
16	Integer w;
17
18	public static void main(String[] args){
19	junit.textui.TestRunner.run(suite());
20	}
21	public static Test suite() {
22	return new TestSuite(AtomicReferenceFieldUpdaterTest.class);
23	}
24
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	(AtomicReferenceFieldUpdaterTest.class, Integer.class, "y");
33	shouldThrow();
34	}
35	catch (RuntimeException rt) {}
36	}
37
38
39	/**
40	* construction with field not of given type throws RuntimeException
41	*/
42	public void testConstructor2(){
43	try {
44	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>
45	a = AtomicReferenceFieldUpdater.newUpdater
46	(AtomicReferenceFieldUpdaterTest.class, Integer.class, "z");
47	shouldThrow();
48	}
49	catch (RuntimeException rt) {}
50	}
51
52	/**
53	* Constructor with non-volatile field throws exception
54	*/
55	public void testConstructor3(){
56	try {
57	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>
58	a = AtomicReferenceFieldUpdater.newUpdater
59	(AtomicReferenceFieldUpdaterTest.class, Integer.class, "w");
60	shouldThrow();
61	}
62	catch (RuntimeException rt) {}
63	}
64
65	/**
66	* get returns the last value set or assigned
67	*/
68	public void testGetSet(){
69	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
70	try {
71	a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
72	} catch (RuntimeException ok) {
73	return;
74	}
75	x = one;
76	assertEquals(one,a.get(this));
77	a.set(this,two);
78	assertEquals(two,a.get(this));
79	a.set(this,m3);
80	assertEquals(m3,a.get(this));
81	}
82
83	/**
84	* get returns the last value lazySet by same thread
85	*/
86	public void testGetLazySet(){
87	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
88	try {
89	a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
90	} catch (RuntimeException ok) {
91	return;
92	}
93	x = one;
94	assertEquals(one,a.get(this));
95	a.lazySet(this,two);
96	assertEquals(two,a.get(this));
97	a.lazySet(this,m3);
98	assertEquals(m3,a.get(this));
99	}
100
101	/**
102	* compareAndSet succeeds in changing value if equal to expected else fails
103	*/
104	public void testCompareAndSet(){
105	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
106	try {
107	a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
108	} catch (RuntimeException ok) {
109	return;
110	}
111	x = one;
112	assertTrue(a.compareAndSet(this,one,two));
113	assertTrue(a.compareAndSet(this,two,m4));
114	assertEquals(m4,a.get(this));
115	assertFalse(a.compareAndSet(this,m5,seven));
116	assertFalse((seven == a.get(this)));
117	assertTrue(a.compareAndSet(this,m4,seven));
118	assertEquals(seven,a.get(this));
119	}
120
121	/**
122	* compareAndSet in one thread enables another waiting for value
123	* to succeed
124	*/
125	public void testCompareAndSetInMultipleThreads() {
126	x = one;
127	final AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
128	try {
129	a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
130	} catch (RuntimeException ok) {
131	return;
132	}
133
134	Thread t = new Thread(new Runnable() {
135	public void run() {
136	while (!a.compareAndSet(AtomicReferenceFieldUpdaterTest.this, two, three)) Thread.yield();
137	}});
138	try {
139	t.start();
140	assertTrue(a.compareAndSet(this, one, two));
141	t.join(LONG_DELAY_MS);
142	assertFalse(t.isAlive());
143	assertEquals(a.get(this), three);
144	}
145	catch (Exception e) {
146	unexpectedException();
147	}
148	}
149
150	/**
151	* repeated weakCompareAndSet succeeds in changing value when equal
152	* to expected
153	*/
154	public void testWeakCompareAndSet(){
155	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
156	try {
157	a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
158	} catch (RuntimeException ok) {
159	return;
160	}
161	x = one;
162	while (!a.weakCompareAndSet(this,one,two));
163	while (!a.weakCompareAndSet(this,two,m4));
164	assertEquals(m4,a.get(this));
165	while (!a.weakCompareAndSet(this,m4,seven));
166	assertEquals(seven,a.get(this));
167	}
168
169	/**
170	* getAndSet returns previous value and sets to given value
171	*/
172	public void testGetAndSet(){
173	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
174	try {
175	a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
176	} catch (RuntimeException ok) {
177	return;
178	}
179	x = one;
180	assertEquals(one,a.getAndSet(this, zero));
181	assertEquals(zero,a.getAndSet(this,m10));
182	assertEquals(m10,a.getAndSet(this,1));
183	}
184
185	}