ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/AtomicMarkableReferenceTest.java
(Generate patch)

Comparing jsr166/src/test/tck/AtomicMarkableReferenceTest.java (file contents):
Revision 1.7 by jsr166, Mon Nov 2 20:28:31 2009 UTC vs.
Revision 1.21 by jsr166, Wed Dec 31 19:21:20 2014 UTC

# Line 1 | Line 1
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
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 junit.framework.*;
10 < import java.util.concurrent.atomic.*;
9 > import java.util.concurrent.atomic.AtomicMarkableReference;
10  
11 < public class AtomicMarkableReferenceTest extends JSR166TestCase{
12 <    public static void main (String[] args) {
13 <        junit.textui.TestRunner.run (suite());
11 > import junit.framework.Test;
12 > import junit.framework.TestSuite;
13 >
14 > public class AtomicMarkableReferenceTest extends JSR166TestCase {
15 >    public static void main(String[] args) {
16 >        junit.textui.TestRunner.run(suite());
17      }
18      public static Test suite() {
19          return new TestSuite(AtomicMarkableReferenceTest.class);
20      }
21  
22      /**
23 <     *  constructor initializes to given reference and mark
23 >     * constructor initializes to given reference and mark
24       */
25 <    public void testConstructor(){
25 >    public void testConstructor() {
26          AtomicMarkableReference ai = new AtomicMarkableReference(one, false);
27 <        assertEquals(one,ai.getReference());
28 <        assertFalse(ai.isMarked());
27 >        assertSame(one, ai.getReference());
28 >        assertFalse(ai.isMarked());
29          AtomicMarkableReference a2 = new AtomicMarkableReference(null, true);
30 <        assertNull(a2.getReference());
31 <        assertTrue(a2.isMarked());
30 <
30 >        assertNull(a2.getReference());
31 >        assertTrue(a2.isMarked());
32      }
33  
34      /**
35 <     *  get returns the last values of reference and mark set
35 >     * get returns the last values of reference and mark set
36       */
37 <    public void testGetSet(){
37 >    public void testGetSet() {
38          boolean[] mark = new boolean[1];
39          AtomicMarkableReference ai = new AtomicMarkableReference(one, false);
40 <        assertEquals(one,ai.getReference());
41 <        assertFalse(ai.isMarked());
42 <        assertEquals(one, ai.get(mark));
43 <        assertFalse(mark[0]);
44 <        ai.set(two, false);
45 <        assertEquals(two,ai.getReference());
46 <        assertFalse(ai.isMarked());
47 <        assertEquals(two, ai.get(mark));
48 <        assertFalse(mark[0]);
49 <        ai.set(one, true);
50 <        assertEquals(one,ai.getReference());
51 <        assertTrue(ai.isMarked());
52 <        assertEquals(one, ai.get(mark));
40 >        assertSame(one, ai.getReference());
41 >        assertFalse(ai.isMarked());
42 >        assertSame(one, ai.get(mark));
43 >        assertFalse(mark[0]);
44 >        ai.set(two, false);
45 >        assertSame(two, ai.getReference());
46 >        assertFalse(ai.isMarked());
47 >        assertSame(two, ai.get(mark));
48 >        assertFalse(mark[0]);
49 >        ai.set(one, true);
50 >        assertSame(one, ai.getReference());
51 >        assertTrue(ai.isMarked());
52 >        assertSame(one, ai.get(mark));
53          assertTrue(mark[0]);
54      }
55  
56      /**
57       * attemptMark succeeds in single thread
58       */
59 <    public void testAttemptMark(){
59 >    public void testAttemptMark() {
60          boolean[] mark = new boolean[1];
61          AtomicMarkableReference ai = new AtomicMarkableReference(one, false);
62          assertFalse(ai.isMarked());
63          assertTrue(ai.attemptMark(one, true));
64 <        assertTrue(ai.isMarked());
65 <        assertEquals(one, ai.get(mark));
64 >        assertTrue(ai.isMarked());
65 >        assertSame(one, ai.get(mark));
66          assertTrue(mark[0]);
67      }
68  
# Line 69 | Line 70 | public class AtomicMarkableReferenceTest
70       * compareAndSet succeeds in changing values if equal to expected reference
71       * and mark else fails
72       */
73 <    public void testCompareAndSet(){
73 >    public void testCompareAndSet() {
74          boolean[] mark = new boolean[1];
75          AtomicMarkableReference ai = new AtomicMarkableReference(one, false);
76 <        assertEquals(one, ai.get(mark));
76 >        assertSame(one, ai.get(mark));
77          assertFalse(ai.isMarked());
78 <        assertFalse(mark[0]);
78 >        assertFalse(mark[0]);
79  
80          assertTrue(ai.compareAndSet(one, two, false, false));
81 <        assertEquals(two, ai.get(mark));
82 <        assertFalse(mark[0]);
81 >        assertSame(two, ai.get(mark));
82 >        assertFalse(mark[0]);
83  
84          assertTrue(ai.compareAndSet(two, m3, false, true));
85 <        assertEquals(m3, ai.get(mark));
86 <        assertTrue(mark[0]);
85 >        assertSame(m3, ai.get(mark));
86 >        assertTrue(mark[0]);
87  
88          assertFalse(ai.compareAndSet(two, m3, true, true));
89 <        assertEquals(m3, ai.get(mark));
90 <        assertTrue(mark[0]);
89 >        assertSame(m3, ai.get(mark));
90 >        assertTrue(mark[0]);
91      }
92  
93      /**
94       * compareAndSet in one thread enables another waiting for reference value
95       * to succeed
96       */
97 <    public void testCompareAndSetInMultipleThreads() {
97 >    public void testCompareAndSetInMultipleThreads() throws Exception {
98          final AtomicMarkableReference ai = new AtomicMarkableReference(one, false);
99 <        Thread t = new Thread(new Runnable() {
100 <                public void run() {
101 <                    while(!ai.compareAndSet(two, three, false, false)) Thread.yield();
102 <                }});
103 <        try {
104 <            t.start();
105 <            assertTrue(ai.compareAndSet(one, two, false, false));
106 <            t.join(LONG_DELAY_MS);
107 <            assertFalse(t.isAlive());
108 <            assertEquals(ai.getReference(), three);
109 <            assertFalse(ai.isMarked());
110 <        }
110 <        catch(Exception e) {
111 <            unexpectedException();
112 <        }
99 >        Thread t = new Thread(new CheckedRunnable() {
100 >            public void realRun() {
101 >                while (!ai.compareAndSet(two, three, false, false))
102 >                    Thread.yield();
103 >            }});
104 >
105 >        t.start();
106 >        assertTrue(ai.compareAndSet(one, two, false, false));
107 >        t.join(LONG_DELAY_MS);
108 >        assertFalse(t.isAlive());
109 >        assertSame(three, ai.getReference());
110 >        assertFalse(ai.isMarked());
111      }
112  
113      /**
114       * compareAndSet in one thread enables another waiting for mark value
115       * to succeed
116       */
117 <    public void testCompareAndSetInMultipleThreads2() {
117 >    public void testCompareAndSetInMultipleThreads2() throws Exception {
118          final AtomicMarkableReference ai = new AtomicMarkableReference(one, false);
119 <        Thread t = new Thread(new Runnable() {
120 <                public void run() {
121 <                    while(!ai.compareAndSet(one, one, true, false)) Thread.yield();
122 <                }});
123 <        try {
124 <            t.start();
125 <            assertTrue(ai.compareAndSet(one, one, false, true));
126 <            t.join(LONG_DELAY_MS);
127 <            assertFalse(t.isAlive());
128 <            assertEquals(ai.getReference(), one);
129 <            assertFalse(ai.isMarked());
130 <        }
133 <        catch(Exception e) {
134 <            unexpectedException();
135 <        }
119 >        Thread t = new Thread(new CheckedRunnable() {
120 >            public void realRun() {
121 >                while (!ai.compareAndSet(one, one, true, false))
122 >                    Thread.yield();
123 >            }});
124 >
125 >        t.start();
126 >        assertTrue(ai.compareAndSet(one, one, false, true));
127 >        t.join(LONG_DELAY_MS);
128 >        assertFalse(t.isAlive());
129 >        assertSame(one, ai.getReference());
130 >        assertFalse(ai.isMarked());
131      }
132  
133      /**
134       * repeated weakCompareAndSet succeeds in changing values when equal
135       * to expected
136       */
137 <    public void testWeakCompareAndSet(){
137 >    public void testWeakCompareAndSet() {
138          boolean[] mark = new boolean[1];
139          AtomicMarkableReference ai = new AtomicMarkableReference(one, false);
140 <        assertEquals(one, ai.get(mark));
140 >        assertSame(one, ai.get(mark));
141          assertFalse(ai.isMarked());
142 <        assertFalse(mark[0]);
142 >        assertFalse(mark[0]);
143  
144 <        while(!ai.weakCompareAndSet(one, two, false, false));
145 <        assertEquals(two, ai.get(mark));
146 <        assertFalse(mark[0]);
144 >        do {} while (!ai.weakCompareAndSet(one, two, false, false));
145 >        assertSame(two, ai.get(mark));
146 >        assertFalse(mark[0]);
147  
148 <        while(!ai.weakCompareAndSet(two, m3, false, true));
149 <        assertEquals(m3, ai.get(mark));
150 <        assertTrue(mark[0]);
148 >        do {} while (!ai.weakCompareAndSet(two, m3, false, true));
149 >        assertSame(m3, ai.get(mark));
150 >        assertTrue(mark[0]);
151      }
152  
153   }

Diff Legend

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