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,-3);
        assertEquals(-3,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.8
Committed:	Tue Jan 20 20:20:56 2004 UTC (20 years, 3 months ago) by dl
Branch:	MAIN
CVS Tags:	JSR166_PFD
Changes since 1.7:	+30 -5 lines
Log Message:	Don't fail if test harness doesn't have sufficient permissions
#	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,-3);
80	assertEquals(-3,a.get(this));
81
82	}
83	/**
84	* compareAndSet succeeds in changing value if equal to expected else fails
85	*/
86	public void testCompareAndSet(){
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	assertTrue(a.compareAndSet(this,one,two));
95	assertTrue(a.compareAndSet(this,two,m4));
96	assertEquals(m4,a.get(this));
97	assertFalse(a.compareAndSet(this,m5,seven));
98	assertFalse((seven == a.get(this)));
99	assertTrue(a.compareAndSet(this,m4,seven));
100	assertEquals(seven,a.get(this));
101	}
102
103	/**
104	* compareAndSet in one thread enables another waiting for value
105	* to succeed
106	*/
107	public void testCompareAndSetInMultipleThreads() {
108	x = one;
109	final AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
110	try {
111	a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
112	} catch (RuntimeException ok) {
113	return;
114	}
115
116	Thread t = new Thread(new Runnable() {
117	public void run() {
118	while(!a.compareAndSet(AtomicReferenceFieldUpdaterTest.this, two, three)) Thread.yield();
119	}});
120	try {
121	t.start();
122	assertTrue(a.compareAndSet(this, one, two));
123	t.join(LONG_DELAY_MS);
124	assertFalse(t.isAlive());
125	assertEquals(a.get(this), three);
126	}
127	catch(Exception e) {
128	unexpectedException();
129	}
130	}
131
132	/**
133	* repeated weakCompareAndSet succeeds in changing value when equal
134	* to expected
135	*/
136	public void testWeakCompareAndSet(){
137	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
138	try {
139	a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
140	} catch (RuntimeException ok) {
141	return;
142	}
143	x = one;
144	while(!a.weakCompareAndSet(this,one,two));
145	while(!a.weakCompareAndSet(this,two,m4));
146	assertEquals(m4,a.get(this));
147	while(!a.weakCompareAndSet(this,m4,seven));
148	assertEquals(seven,a.get(this));
149	}
150
151	/**
152	* getAndSet returns previous value and sets to given value
153	*/
154	public void testGetAndSet(){
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	assertEquals(one,a.getAndSet(this, zero));
163	assertEquals(zero,a.getAndSet(this,m10));
164	assertEquals(m10,a.getAndSet(this,1));
165	}
166
167	}