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 = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
        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 = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
        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 = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");

        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 = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
        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 = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
        x = one;
        assertEquals(one,a.getAndSet(this, zero));
        assertEquals(zero,a.getAndSet(this,m10));
        assertEquals(m10,a.getAndSet(this,1));
    }

}
Revision:	1.7
Committed:	Mon Dec 29 19:05:40 2003 UTC (20 years, 4 months ago) by dl
Branch:	MAIN
Changes since 1.6:	+1 -1 lines
Log Message:	spellcheck
#	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 = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
70	x = one;
71	assertEquals(one,a.get(this));
72	a.set(this,two);
73	assertEquals(two,a.get(this));
74	a.set(this,-3);
75	assertEquals(-3,a.get(this));
76
77	}
78	/**
79	* compareAndSet succeeds in changing value if equal to expected else fails
80	*/
81	public void testCompareAndSet(){
82	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
83	x = one;
84	assertTrue(a.compareAndSet(this,one,two));
85	assertTrue(a.compareAndSet(this,two,m4));
86	assertEquals(m4,a.get(this));
87	assertFalse(a.compareAndSet(this,m5,seven));
88	assertFalse((seven == a.get(this)));
89	assertTrue(a.compareAndSet(this,m4,seven));
90	assertEquals(seven,a.get(this));
91	}
92
93	/**
94	* compareAndSet in one thread enables another waiting for value
95	* to succeed
96	*/
97	public void testCompareAndSetInMultipleThreads() {
98	x = one;
99	final AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
100
101	Thread t = new Thread(new Runnable() {
102	public void run() {
103	while(!a.compareAndSet(AtomicReferenceFieldUpdaterTest.this, two, three)) Thread.yield();
104	}});
105	try {
106	t.start();
107	assertTrue(a.compareAndSet(this, one, two));
108	t.join(LONG_DELAY_MS);
109	assertFalse(t.isAlive());
110	assertEquals(a.get(this), three);
111	}
112	catch(Exception e) {
113	unexpectedException();
114	}
115	}
116
117	/**
118	* repeated weakCompareAndSet succeeds in changing value when equal
119	* to expected
120	*/
121	public void testWeakCompareAndSet(){
122	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
123	x = one;
124	while(!a.weakCompareAndSet(this,one,two));
125	while(!a.weakCompareAndSet(this,two,m4));
126	assertEquals(m4,a.get(this));
127	while(!a.weakCompareAndSet(this,m4,seven));
128	assertEquals(seven,a.get(this));
129	}
130
131	/**
132	* getAndSet returns previous value and sets to given value
133	*/
134	public void testGetAndSet(){
135	AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
136	x = one;
137	assertEquals(one,a.getAndSet(this, zero));
138	assertEquals(zero,a.getAndSet(this,m10));
139	assertEquals(m10,a.getAndSet(this,1));
140	}
141
142	}