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.4 by dl, Thu Sep 25 11:02:41 2003 UTC vs.
Revision 1.12 by jsr166, Sat Nov 21 02:07:26 2009 UTC

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

Diff Legend

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