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

Comparing jsr166/src/test/tck/AtomicStampedReferenceTest.java (file contents):
Revision 1.10 by jsr166, Mon Nov 16 05:30:07 2009 UTC vs.
Revision 1.13 by jsr166, Sat Nov 21 02:07:26 2009 UTC

# Line 22 | Line 22 | public class AtomicStampedReferenceTest
22       */
23      public void testConstructor() {
24          AtomicStampedReference ai = new AtomicStampedReference(one, 0);
25 <        assertEquals(one,ai.getReference());
26 <        assertEquals(0, ai.getStamp());
25 >        assertEquals(one,ai.getReference());
26 >        assertEquals(0, ai.getStamp());
27          AtomicStampedReference a2 = new AtomicStampedReference(null, 1);
28 <        assertNull(a2.getReference());
29 <        assertEquals(1, a2.getStamp());
28 >        assertNull(a2.getReference());
29 >        assertEquals(1, a2.getStamp());
30  
31      }
32  
# Line 36 | Line 36 | public class AtomicStampedReferenceTest
36      public void testGetSet() {
37          int[] mark = new int[1];
38          AtomicStampedReference ai = new AtomicStampedReference(one, 0);
39 <        assertEquals(one,ai.getReference());
40 <        assertEquals(0, ai.getStamp());
39 >        assertEquals(one,ai.getReference());
40 >        assertEquals(0, ai.getStamp());
41          assertEquals(one, ai.get(mark));
42          assertEquals(0, mark[0]);
43 <        ai.set(two, 0);
44 <        assertEquals(two,ai.getReference());
45 <        assertEquals(0, ai.getStamp());
43 >        ai.set(two, 0);
44 >        assertEquals(two,ai.getReference());
45 >        assertEquals(0, ai.getStamp());
46          assertEquals(two, ai.get(mark));
47          assertEquals(0, mark[0]);
48 <        ai.set(one, 1);
49 <        assertEquals(one,ai.getReference());
50 <        assertEquals(1, ai.getStamp());
48 >        ai.set(one, 1);
49 >        assertEquals(one,ai.getReference());
50 >        assertEquals(1, ai.getStamp());
51          assertEquals(one, ai.get(mark));
52          assertEquals(1,mark[0]);
53      }
# Line 60 | Line 60 | public class AtomicStampedReferenceTest
60          AtomicStampedReference ai = new AtomicStampedReference(one, 0);
61          assertEquals(0, ai.getStamp());
62          assertTrue(ai.attemptStamp(one, 1));
63 <        assertEquals(1, ai.getStamp());
63 >        assertEquals(1, ai.getStamp());
64          assertEquals(one, ai.get(mark));
65          assertEquals(1, mark[0]);
66      }
# Line 72 | Line 72 | public class AtomicStampedReferenceTest
72      public void testCompareAndSet() {
73          int[] mark = new int[1];
74          AtomicStampedReference ai = new AtomicStampedReference(one, 0);
75 <        assertEquals(one, ai.get(mark));
75 >        assertEquals(one, ai.get(mark));
76          assertEquals(0, ai.getStamp());
77 <        assertEquals(0, mark[0]);
77 >        assertEquals(0, mark[0]);
78  
79          assertTrue(ai.compareAndSet(one, two, 0, 0));
80 <        assertEquals(two, ai.get(mark));
81 <        assertEquals(0, mark[0]);
80 >        assertEquals(two, ai.get(mark));
81 >        assertEquals(0, mark[0]);
82  
83          assertTrue(ai.compareAndSet(two, m3, 0, 1));
84 <        assertEquals(m3, ai.get(mark));
85 <        assertEquals(1, mark[0]);
84 >        assertEquals(m3, ai.get(mark));
85 >        assertEquals(1, mark[0]);
86  
87          assertFalse(ai.compareAndSet(two, m3, 1, 1));
88 <        assertEquals(m3, ai.get(mark));
89 <        assertEquals(1, mark[0]);
88 >        assertEquals(m3, ai.get(mark));
89 >        assertEquals(1, 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 AtomicStampedReference ai = new AtomicStampedReference(one, 0);
98 <        Thread t = new Thread(new Runnable() {
99 <                public void run() {
100 <                    while (!ai.compareAndSet(two, three, 0, 0)) Thread.yield();
101 <                }});
102 <        try {
103 <            t.start();
104 <            assertTrue(ai.compareAndSet(one, two, 0, 0));
105 <            t.join(LONG_DELAY_MS);
106 <            assertFalse(t.isAlive());
107 <            assertEquals(ai.getReference(), three);
108 <            assertEquals(ai.getStamp(), 0);
109 <        }
110 <        catch (Exception e) {
111 <            unexpectedException();
112 <        }
98 >        Thread t = new Thread(new CheckedRunnable() {
99 >            public void realRun() {
100 >                while (!ai.compareAndSet(two, three, 0, 0))
101 >                    Thread.yield();
102 >            }});
103 >
104 >        t.start();
105 >        assertTrue(ai.compareAndSet(one, two, 0, 0));
106 >        t.join(LONG_DELAY_MS);
107 >        assertFalse(t.isAlive());
108 >        assertEquals(ai.getReference(), three);
109 >        assertEquals(ai.getStamp(), 0);
110      }
111  
112      /**
113       * compareAndSet in one thread enables another waiting for stamp value
114       * to succeed
115       */
116 <    public void testCompareAndSetInMultipleThreads2() {
116 >    public void testCompareAndSetInMultipleThreads2() throws Exception {
117          final AtomicStampedReference ai = new AtomicStampedReference(one, 0);
118 <        Thread t = new Thread(new Runnable() {
119 <                public void run() {
120 <                    while (!ai.compareAndSet(one, one, 1, 2)) Thread.yield();
121 <                }});
122 <        try {
123 <            t.start();
124 <            assertTrue(ai.compareAndSet(one, one, 0, 1));
125 <            t.join(LONG_DELAY_MS);
126 <            assertFalse(t.isAlive());
127 <            assertEquals(ai.getReference(), one);
128 <            assertEquals(ai.getStamp(), 2);
129 <        }
133 <        catch (Exception e) {
134 <            unexpectedException();
135 <        }
118 >        Thread t = new Thread(new CheckedRunnable() {
119 >            public void realRun() {
120 >                while (!ai.compareAndSet(one, one, 1, 2))
121 >                    Thread.yield();
122 >            }});
123 >
124 >        t.start();
125 >        assertTrue(ai.compareAndSet(one, one, 0, 1));
126 >        t.join(LONG_DELAY_MS);
127 >        assertFalse(t.isAlive());
128 >        assertEquals(ai.getReference(), one);
129 >        assertEquals(ai.getStamp(), 2);
130      }
131  
132      /**
# Line 142 | Line 136 | public class AtomicStampedReferenceTest
136      public void testWeakCompareAndSet() {
137          int[] mark = new int[1];
138          AtomicStampedReference ai = new AtomicStampedReference(one, 0);
139 <        assertEquals(one, ai.get(mark));
139 >        assertEquals(one, ai.get(mark));
140          assertEquals(0, ai.getStamp ());
141 <        assertEquals(0, mark[0]);
141 >        assertEquals(0, mark[0]);
142  
143          while (!ai.weakCompareAndSet(one, two, 0, 0));
144 <        assertEquals(two, ai.get(mark));
145 <        assertEquals(0, mark[0]);
144 >        assertEquals(two, ai.get(mark));
145 >        assertEquals(0, mark[0]);
146  
147          while (!ai.weakCompareAndSet(two, m3, 0, 1));
148 <        assertEquals(m3, ai.get(mark));
149 <        assertEquals(1, mark[0]);
148 >        assertEquals(m3, ai.get(mark));
149 >        assertEquals(1, mark[0]);
150      }
151  
152   }

Diff Legend

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