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

Comparing jsr166/src/test/tck/AtomicIntegerTest.java (file contents):
Revision 1.15 by jsr166, Tue Nov 17 03:12:51 2009 UTC vs.
Revision 1.20 by jsr166, Wed Aug 25 00:07:03 2010 UTC

# Line 11 | Line 11 | import java.util.concurrent.atomic.*;
11   import java.io.*;
12  
13   public class AtomicIntegerTest extends JSR166TestCase {
14 <    public static void main (String[] args) {
15 <        junit.textui.TestRunner.run (suite());
14 >    public static void main(String[] args) {
15 >        junit.textui.TestRunner.run(suite());
16      }
17      public static Test suite() {
18          return new TestSuite(AtomicIntegerTest.class);
19      }
20  
21 +    final int[] VALUES = {
22 +        Integer.MIN_VALUE, -1, 0, 1, 42, Integer.MAX_VALUE,
23 +    };
24 +
25      /**
26       * constructor initializes to given value
27       */
28      public void testConstructor() {
29          AtomicInteger ai = new AtomicInteger(1);
30 <        assertEquals(1,ai.get());
30 >        assertEquals(1,ai.get());
31      }
32  
33      /**
# Line 31 | Line 35 | public class AtomicIntegerTest extends J
35       */
36      public void testConstructor2() {
37          AtomicInteger ai = new AtomicInteger();
38 <        assertEquals(0,ai.get());
38 >        assertEquals(0,ai.get());
39      }
40  
41      /**
# Line 39 | Line 43 | public class AtomicIntegerTest extends J
43       */
44      public void testGetSet() {
45          AtomicInteger ai = new AtomicInteger(1);
46 <        assertEquals(1,ai.get());
47 <        ai.set(2);
48 <        assertEquals(2,ai.get());
49 <        ai.set(-3);
50 <        assertEquals(-3,ai.get());
47 <
46 >        assertEquals(1,ai.get());
47 >        ai.set(2);
48 >        assertEquals(2,ai.get());
49 >        ai.set(-3);
50 >        assertEquals(-3,ai.get());
51      }
52  
53      /**
# Line 52 | Line 55 | public class AtomicIntegerTest extends J
55       */
56      public void testGetLazySet() {
57          AtomicInteger ai = new AtomicInteger(1);
58 <        assertEquals(1,ai.get());
59 <        ai.lazySet(2);
60 <        assertEquals(2,ai.get());
61 <        ai.lazySet(-3);
62 <        assertEquals(-3,ai.get());
60 <
58 >        assertEquals(1,ai.get());
59 >        ai.lazySet(2);
60 >        assertEquals(2,ai.get());
61 >        ai.lazySet(-3);
62 >        assertEquals(-3,ai.get());
63      }
64 +
65      /**
66       * compareAndSet succeeds in changing value if equal to expected else fails
67       */
68      public void testCompareAndSet() {
69          AtomicInteger ai = new AtomicInteger(1);
70 <        assertTrue(ai.compareAndSet(1,2));
71 <        assertTrue(ai.compareAndSet(2,-4));
72 <        assertEquals(-4,ai.get());
73 <        assertFalse(ai.compareAndSet(-5,7));
74 <        assertFalse((7 == ai.get()));
75 <        assertTrue(ai.compareAndSet(-4,7));
76 <        assertEquals(7,ai.get());
70 >        assertTrue(ai.compareAndSet(1,2));
71 >        assertTrue(ai.compareAndSet(2,-4));
72 >        assertEquals(-4,ai.get());
73 >        assertFalse(ai.compareAndSet(-5,7));
74 >        assertEquals(-4,ai.get());
75 >        assertTrue(ai.compareAndSet(-4,7));
76 >        assertEquals(7,ai.get());
77      }
78  
79      /**
# Line 79 | Line 82 | public class AtomicIntegerTest extends J
82       */
83      public void testCompareAndSetInMultipleThreads() throws Exception {
84          final AtomicInteger ai = new AtomicInteger(1);
85 <        Thread t = new Thread(new Runnable() {
86 <                public void run() {
87 <                    while (!ai.compareAndSet(2, 3)) Thread.yield();
88 <                }});
85 >        Thread t = new Thread(new CheckedRunnable() {
86 >            public void realRun() {
87 >                while (!ai.compareAndSet(2, 3))
88 >                    Thread.yield();
89 >            }});
90  
91          t.start();
92          assertTrue(ai.compareAndSet(1, 2));
# Line 97 | Line 101 | public class AtomicIntegerTest extends J
101       */
102      public void testWeakCompareAndSet() {
103          AtomicInteger ai = new AtomicInteger(1);
104 <        while (!ai.weakCompareAndSet(1,2));
105 <        while (!ai.weakCompareAndSet(2,-4));
106 <        assertEquals(-4,ai.get());
104 >        while (!ai.weakCompareAndSet(1,2));
105 >        while (!ai.weakCompareAndSet(2,-4));
106 >        assertEquals(-4,ai.get());
107          while (!ai.weakCompareAndSet(-4,7));
108 <        assertEquals(7,ai.get());
108 >        assertEquals(7,ai.get());
109      }
110  
111      /**
# Line 109 | Line 113 | public class AtomicIntegerTest extends J
113       */
114      public void testGetAndSet() {
115          AtomicInteger ai = new AtomicInteger(1);
116 <        assertEquals(1,ai.getAndSet(0));
117 <        assertEquals(0,ai.getAndSet(-10));
118 <        assertEquals(-10,ai.getAndSet(1));
116 >        assertEquals(1,ai.getAndSet(0));
117 >        assertEquals(0,ai.getAndSet(-10));
118 >        assertEquals(-10,ai.getAndSet(1));
119      }
120  
121      /**
# Line 119 | Line 123 | public class AtomicIntegerTest extends J
123       */
124      public void testGetAndAdd() {
125          AtomicInteger ai = new AtomicInteger(1);
126 <        assertEquals(1,ai.getAndAdd(2));
127 <        assertEquals(3,ai.get());
128 <        assertEquals(3,ai.getAndAdd(-4));
129 <        assertEquals(-1,ai.get());
126 >        assertEquals(1,ai.getAndAdd(2));
127 >        assertEquals(3,ai.get());
128 >        assertEquals(3,ai.getAndAdd(-4));
129 >        assertEquals(-1,ai.get());
130      }
131  
132      /**
# Line 130 | Line 134 | public class AtomicIntegerTest extends J
134       */
135      public void testGetAndDecrement() {
136          AtomicInteger ai = new AtomicInteger(1);
137 <        assertEquals(1,ai.getAndDecrement());
138 <        assertEquals(0,ai.getAndDecrement());
139 <        assertEquals(-1,ai.getAndDecrement());
137 >        assertEquals(1,ai.getAndDecrement());
138 >        assertEquals(0,ai.getAndDecrement());
139 >        assertEquals(-1,ai.getAndDecrement());
140      }
141  
142      /**
# Line 140 | Line 144 | public class AtomicIntegerTest extends J
144       */
145      public void testGetAndIncrement() {
146          AtomicInteger ai = new AtomicInteger(1);
147 <        assertEquals(1,ai.getAndIncrement());
148 <        assertEquals(2,ai.get());
149 <        ai.set(-2);
150 <        assertEquals(-2,ai.getAndIncrement());
151 <        assertEquals(-1,ai.getAndIncrement());
152 <        assertEquals(0,ai.getAndIncrement());
153 <        assertEquals(1,ai.get());
147 >        assertEquals(1,ai.getAndIncrement());
148 >        assertEquals(2,ai.get());
149 >        ai.set(-2);
150 >        assertEquals(-2,ai.getAndIncrement());
151 >        assertEquals(-1,ai.getAndIncrement());
152 >        assertEquals(0,ai.getAndIncrement());
153 >        assertEquals(1,ai.get());
154      }
155  
156      /**
# Line 154 | Line 158 | public class AtomicIntegerTest extends J
158       */
159      public void testAddAndGet() {
160          AtomicInteger ai = new AtomicInteger(1);
161 <        assertEquals(3,ai.addAndGet(2));
162 <        assertEquals(3,ai.get());
163 <        assertEquals(-1,ai.addAndGet(-4));
164 <        assertEquals(-1,ai.get());
161 >        assertEquals(3,ai.addAndGet(2));
162 >        assertEquals(3,ai.get());
163 >        assertEquals(-1,ai.addAndGet(-4));
164 >        assertEquals(-1,ai.get());
165      }
166  
167      /**
# Line 165 | Line 169 | public class AtomicIntegerTest extends J
169       */
170      public void testDecrementAndGet() {
171          AtomicInteger ai = new AtomicInteger(1);
172 <        assertEquals(0,ai.decrementAndGet());
173 <        assertEquals(-1,ai.decrementAndGet());
174 <        assertEquals(-2,ai.decrementAndGet());
175 <        assertEquals(-2,ai.get());
172 >        assertEquals(0,ai.decrementAndGet());
173 >        assertEquals(-1,ai.decrementAndGet());
174 >        assertEquals(-2,ai.decrementAndGet());
175 >        assertEquals(-2,ai.get());
176      }
177  
178      /**
# Line 176 | Line 180 | public class AtomicIntegerTest extends J
180       */
181      public void testIncrementAndGet() {
182          AtomicInteger ai = new AtomicInteger(1);
183 <        assertEquals(2,ai.incrementAndGet());
184 <        assertEquals(2,ai.get());
185 <        ai.set(-2);
186 <        assertEquals(-1,ai.incrementAndGet());
187 <        assertEquals(0,ai.incrementAndGet());
188 <        assertEquals(1,ai.incrementAndGet());
189 <        assertEquals(1,ai.get());
183 >        assertEquals(2,ai.incrementAndGet());
184 >        assertEquals(2,ai.get());
185 >        ai.set(-2);
186 >        assertEquals(-1,ai.incrementAndGet());
187 >        assertEquals(0,ai.incrementAndGet());
188 >        assertEquals(1,ai.incrementAndGet());
189 >        assertEquals(1,ai.get());
190      }
191  
192      /**
# Line 208 | Line 212 | public class AtomicIntegerTest extends J
212       */
213      public void testToString() {
214          AtomicInteger ai = new AtomicInteger();
215 <        for (int i = -12; i < 6; ++i) {
216 <            ai.set(i);
217 <            assertEquals(ai.toString(), Integer.toString(i));
215 >        assertEquals("0", ai.toString());
216 >        for (int x : VALUES) {
217 >            ai.set(x);
218 >            assertEquals(ai.toString(), Integer.toString(x));
219          }
220      }
221  
# Line 219 | Line 224 | public class AtomicIntegerTest extends J
224       */
225      public void testIntValue() {
226          AtomicInteger ai = new AtomicInteger();
227 <        for (int i = -12; i < 6; ++i) {
228 <            ai.set(i);
229 <            assertEquals(i, ai.intValue());
227 >        assertEquals(0, ai.intValue());
228 >        for (int x : VALUES) {
229 >            ai.set(x);
230 >            assertEquals(x, ai.intValue());
231          }
232      }
233  
228 –
234      /**
235       * longValue returns current value.
236       */
237      public void testLongValue() {
238          AtomicInteger ai = new AtomicInteger();
239 <        for (int i = -12; i < 6; ++i) {
240 <            ai.set(i);
241 <            assertEquals((long)i, ai.longValue());
239 >        assertEquals(0L, ai.longValue());
240 >        for (int x : VALUES) {
241 >            ai.set(x);
242 >            assertEquals((long)x, ai.longValue());
243          }
244      }
245  
# Line 242 | Line 248 | public class AtomicIntegerTest extends J
248       */
249      public void testFloatValue() {
250          AtomicInteger ai = new AtomicInteger();
251 <        for (int i = -12; i < 6; ++i) {
252 <            ai.set(i);
253 <            assertEquals((float)i, ai.floatValue());
251 >        assertEquals(0.0f, ai.floatValue());
252 >        for (int x : VALUES) {
253 >            ai.set(x);
254 >            assertEquals((float)x, ai.floatValue());
255          }
256      }
257  
# Line 253 | Line 260 | public class AtomicIntegerTest extends J
260       */
261      public void testDoubleValue() {
262          AtomicInteger ai = new AtomicInteger();
263 <        for (int i = -12; i < 6; ++i) {
264 <            ai.set(i);
265 <            assertEquals((double)i, ai.doubleValue());
263 >        assertEquals(0.0d, ai.doubleValue());
264 >        for (int x : VALUES) {
265 >            ai.set(x);
266 >            assertEquals((double)x, ai.doubleValue());
267          }
268      }
269  
262 –
263 –
270   }

Diff Legend

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