test/tck/AtomicMarkableReferenceTest.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/publicdomain/zero/1.0/
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */

import java.util.concurrent.atomic.AtomicMarkableReference;

import junit.framework.Test;
import junit.framework.TestSuite;

public class AtomicMarkableReferenceTest extends JSR166TestCase {
    public static void main(String[] args) {
        main(suite(), args);
    }
    public static Test suite() {
        return new TestSuite(AtomicMarkableReferenceTest.class);
    }

    /**
     * constructor initializes to given reference and mark
     */
    public void testConstructor() {
        AtomicMarkableReference<Item> ai = new AtomicMarkableReference<Item>(one, false);
        assertSame(one, ai.getReference());
        assertFalse(ai.isMarked());
        AtomicMarkableReference<Item> a2 = new AtomicMarkableReference<Item>(null, true);
        assertNull(a2.getReference());
        assertTrue(a2.isMarked());
    }

    /**
     * get returns the last values of reference and mark set
     */
    public void testGetSet() {
        boolean[] mark = new boolean[1];
        AtomicMarkableReference<Item> ai = new AtomicMarkableReference<Item>(one, false);
        assertSame(one, ai.getReference());
        assertFalse(ai.isMarked());
        assertSame(one, ai.get(mark));
        assertFalse(mark[0]);
        ai.set(two, false);
        assertSame(two, ai.getReference());
        assertFalse(ai.isMarked());
        assertSame(two, ai.get(mark));
        assertFalse(mark[0]);
        ai.set(one, true);
        assertSame(one, ai.getReference());
        assertTrue(ai.isMarked());
        assertSame(one, ai.get(mark));
        assertTrue(mark[0]);
    }

    /**
     * attemptMark succeeds in single thread
     */
    public void testAttemptMark() {
        boolean[] mark = new boolean[1];
        AtomicMarkableReference<Item> ai = new AtomicMarkableReference<Item>(one, false);
        assertFalse(ai.isMarked());
        assertTrue(ai.attemptMark(one, true));
        assertTrue(ai.isMarked());
        assertSame(one, ai.get(mark));
        assertTrue(mark[0]);
    }

    /**
     * compareAndSet succeeds in changing values if equal to expected reference
     * and mark else fails
     */
    public void testCompareAndSet() {
        boolean[] mark = new boolean[1];
        AtomicMarkableReference<Item> ai = new AtomicMarkableReference<Item>(one, false);
        assertSame(one, ai.get(mark));
        assertFalse(ai.isMarked());
        assertFalse(mark[0]);

        assertTrue(ai.compareAndSet(one, two, false, false));
        assertSame(two, ai.get(mark));
        assertFalse(mark[0]);

        assertTrue(ai.compareAndSet(two, minusThree, false, true));
        assertSame(minusThree, ai.get(mark));
        assertTrue(mark[0]);

        assertFalse(ai.compareAndSet(two, minusThree, true, true));
        assertSame(minusThree, ai.get(mark));
        assertTrue(mark[0]);
    }

    /**
     * compareAndSet in one thread enables another waiting for reference value
     * to succeed
     */
    public void testCompareAndSetInMultipleThreads() throws Exception {
        final AtomicMarkableReference<Item> ai = new AtomicMarkableReference<Item>(one, false);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                while (!ai.compareAndSet(two, three, false, false))
                    Thread.yield();
            }});

        t.start();
        assertTrue(ai.compareAndSet(one, two, false, false));
        t.join(LONG_DELAY_MS);
        assertFalse(t.isAlive());
        assertSame(three, ai.getReference());
        assertFalse(ai.isMarked());
    }

    /**
     * compareAndSet in one thread enables another waiting for mark value
     * to succeed
     */
    public void testCompareAndSetInMultipleThreads2() throws Exception {
        final AtomicMarkableReference<Item> ai = new AtomicMarkableReference<Item>(one, false);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                while (!ai.compareAndSet(one, one, true, false))
                    Thread.yield();
            }});

        t.start();
        assertTrue(ai.compareAndSet(one, one, false, true));
        t.join(LONG_DELAY_MS);
        assertFalse(t.isAlive());
        assertSame(one, ai.getReference());
        assertFalse(ai.isMarked());
    }

    /**
     * repeated weakCompareAndSet succeeds in changing values when equal
     * to expected
     */
    public void testWeakCompareAndSet() {
        boolean[] mark = new boolean[1];
        AtomicMarkableReference<Item> ai = new AtomicMarkableReference<Item>(one, false);
        assertSame(one, ai.get(mark));
        assertFalse(ai.isMarked());
        assertFalse(mark[0]);

        do {} while (!ai.weakCompareAndSet(one, two, false, false));
        assertSame(two, ai.get(mark));
        assertFalse(mark[0]);

        do {} while (!ai.weakCompareAndSet(two, minusThree, false, true));
        assertSame(minusThree, ai.get(mark));
        assertTrue(mark[0]);
    }

}
Revision:	1.23
Committed:	Tue Jan 26 13:33:05 2021 UTC (3 years, 3 months ago) by dl
Branch:	MAIN
Changes since 1.22:	+14 -14 lines
Log Message:	Replace Integer with Item class
#	User	Rev	Content
1	dl	1.1	/*
2	dl	1.5	* 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	jsr166	1.16	* http://creativecommons.org/publicdomain/zero/1.0/
5	jsr166	1.7	* Other contributors include Andrew Wright, Jeffrey Hayes,
6			* Pat Fisher, Mike Judd.
7	dl	1.1	*/
8
9	jsr166	1.17	import java.util.concurrent.atomic.AtomicMarkableReference;
10	dl	1.1
11	jsr166	1.20	import junit.framework.Test;
12			import junit.framework.TestSuite;
13
14	jsr166	1.9	public class AtomicMarkableReferenceTest extends JSR166TestCase {
15	jsr166	1.14	public static void main(String[] args) {
16	jsr166	1.22	main(suite(), args);
17	dl	1.1	}
18			public static Test suite() {
19			return new TestSuite(AtomicMarkableReferenceTest.class);
20			}
21	jsr166	1.7
22	dl	1.3	/**
23	jsr166	1.15	* constructor initializes to given reference and mark
24	dl	1.3	*/
25	jsr166	1.9	public void testConstructor() {
26	dl	1.23	AtomicMarkableReference<Item> ai = new AtomicMarkableReference<Item>(one, false);
27	jsr166	1.18	assertSame(one, ai.getReference());
28	jsr166	1.12	assertFalse(ai.isMarked());
29	dl	1.23	AtomicMarkableReference<Item> a2 = new AtomicMarkableReference<Item>(null, true);
30	jsr166	1.12	assertNull(a2.getReference());
31			assertTrue(a2.isMarked());
32	dl	1.1	}
33
34	dl	1.3	/**
35	jsr166	1.15	* get returns the last values of reference and mark set
36	dl	1.3	*/
37	jsr166	1.9	public void testGetSet() {
38	dl	1.1	boolean[] mark = new boolean[1];
39	dl	1.23	AtomicMarkableReference<Item> ai = new AtomicMarkableReference<Item>(one, false);
40	jsr166	1.18	assertSame(one, ai.getReference());
41	jsr166	1.12	assertFalse(ai.isMarked());
42	jsr166	1.13	assertSame(one, ai.get(mark));
43	dl	1.1	assertFalse(mark[0]);
44	jsr166	1.12	ai.set(two, false);
45	jsr166	1.18	assertSame(two, ai.getReference());
46	jsr166	1.12	assertFalse(ai.isMarked());
47	jsr166	1.13	assertSame(two, ai.get(mark));
48	dl	1.1	assertFalse(mark[0]);
49	jsr166	1.12	ai.set(one, true);
50	jsr166	1.18	assertSame(one, ai.getReference());
51	jsr166	1.12	assertTrue(ai.isMarked());
52	jsr166	1.13	assertSame(one, ai.get(mark));
53	dl	1.1	assertTrue(mark[0]);
54			}
55
56	dl	1.3	/**
57	dl	1.4	* attemptMark succeeds in single thread
58	dl	1.3	*/
59	jsr166	1.9	public void testAttemptMark() {
60	dl	1.1	boolean[] mark = new boolean[1];
61	dl	1.23	AtomicMarkableReference<Item> ai = new AtomicMarkableReference<Item>(one, false);
62	dl	1.1	assertFalse(ai.isMarked());
63			assertTrue(ai.attemptMark(one, true));
64	jsr166	1.12	assertTrue(ai.isMarked());
65	jsr166	1.13	assertSame(one, ai.get(mark));
66	dl	1.1	assertTrue(mark[0]);
67			}
68
69	dl	1.3	/**
70	dl	1.4	* compareAndSet succeeds in changing values if equal to expected reference
71			* and mark else fails
72	dl	1.3	*/
73	jsr166	1.9	public void testCompareAndSet() {
74	dl	1.1	boolean[] mark = new boolean[1];
75	dl	1.23	AtomicMarkableReference<Item> ai = new AtomicMarkableReference<Item>(one, false);
76	jsr166	1.13	assertSame(one, ai.get(mark));
77	dl	1.1	assertFalse(ai.isMarked());
78	jsr166	1.12	assertFalse(mark[0]);
79	dl	1.1
80			assertTrue(ai.compareAndSet(one, two, false, false));
81	jsr166	1.13	assertSame(two, ai.get(mark));
82	jsr166	1.12	assertFalse(mark[0]);
83	dl	1.1
84	dl	1.23	assertTrue(ai.compareAndSet(two, minusThree, false, true));
85			assertSame(minusThree, ai.get(mark));
86	jsr166	1.12	assertTrue(mark[0]);
87	dl	1.1
88	dl	1.23	assertFalse(ai.compareAndSet(two, minusThree, true, true));
89			assertSame(minusThree, ai.get(mark));
90	jsr166	1.12	assertTrue(mark[0]);
91	dl	1.1	}
92
93	dl	1.3	/**
94	dl	1.4	* compareAndSet in one thread enables another waiting for reference value
95			* to succeed
96			*/
97	jsr166	1.10	public void testCompareAndSetInMultipleThreads() throws Exception {
98	dl	1.23	final AtomicMarkableReference<Item> ai = new AtomicMarkableReference<Item>(one, false);
99	jsr166	1.11	Thread t = new Thread(new CheckedRunnable() {
100			public void realRun() {
101			while (!ai.compareAndSet(two, three, false, false))
102			Thread.yield();
103			}});
104	jsr166	1.10
105			t.start();
106			assertTrue(ai.compareAndSet(one, two, false, false));
107			t.join(LONG_DELAY_MS);
108			assertFalse(t.isAlive());
109	jsr166	1.19	assertSame(three, ai.getReference());
110	jsr166	1.10	assertFalse(ai.isMarked());
111	dl	1.4	}
112
113			/**
114			* compareAndSet in one thread enables another waiting for mark value
115			* to succeed
116			*/
117	jsr166	1.10	public void testCompareAndSetInMultipleThreads2() throws Exception {
118	dl	1.23	final AtomicMarkableReference<Item> ai = new AtomicMarkableReference<Item>(one, false);
119	jsr166	1.11	Thread t = new Thread(new CheckedRunnable() {
120			public void realRun() {
121			while (!ai.compareAndSet(one, one, true, false))
122			Thread.yield();
123			}});
124	jsr166	1.10
125			t.start();
126			assertTrue(ai.compareAndSet(one, one, false, true));
127			t.join(LONG_DELAY_MS);
128			assertFalse(t.isAlive());
129	jsr166	1.19	assertSame(one, ai.getReference());
130	jsr166	1.10	assertFalse(ai.isMarked());
131	dl	1.4	}
132
133			/**
134			* repeated weakCompareAndSet succeeds in changing values when equal
135	jsr166	1.7	* to expected
136	dl	1.3	*/
137	jsr166	1.9	public void testWeakCompareAndSet() {
138	dl	1.1	boolean[] mark = new boolean[1];
139	dl	1.23	AtomicMarkableReference<Item> ai = new AtomicMarkableReference<Item>(one, false);
140	jsr166	1.13	assertSame(one, ai.get(mark));
141	dl	1.1	assertFalse(ai.isMarked());
142	jsr166	1.12	assertFalse(mark[0]);
143	dl	1.1
144	jsr166	1.21	do {} while (!ai.weakCompareAndSet(one, two, false, false));
145	jsr166	1.13	assertSame(two, ai.get(mark));
146	jsr166	1.12	assertFalse(mark[0]);
147	dl	1.1
148	dl	1.23	do {} while (!ai.weakCompareAndSet(two, minusThree, false, true));
149			assertSame(minusThree, ai.get(mark));
150	jsr166	1.12	assertTrue(mark[0]);
151	dl	1.1	}
152
153			}