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.16 by jsr166, Tue Nov 17 06:58:50 2009 UTC vs.
Revision 1.18 by jsr166, Sun Nov 22 18:55:56 2009 UTC

# Line 18 | Line 18 | public class AtomicIntegerTest extends J
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());
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 56 | public class AtomicIntegerTest extends J
56       */
57      public void testGetLazySet() {
58          AtomicInteger ai = new AtomicInteger(1);
59 <        assertEquals(1,ai.get());
60 <        ai.lazySet(2);
61 <        assertEquals(2,ai.get());
62 <        ai.lazySet(-3);
63 <        assertEquals(-3,ai.get());
59 >        assertEquals(1,ai.get());
60 >        ai.lazySet(2);
61 >        assertEquals(2,ai.get());
62 >        ai.lazySet(-3);
63 >        assertEquals(-3,ai.get());
64  
65      }
66      /**
# Line 64 | Line 68 | public class AtomicIntegerTest extends J
68       */
69      public void testCompareAndSet() {
70          AtomicInteger ai = new AtomicInteger(1);
71 <        assertTrue(ai.compareAndSet(1,2));
72 <        assertTrue(ai.compareAndSet(2,-4));
73 <        assertEquals(-4,ai.get());
74 <        assertFalse(ai.compareAndSet(-5,7));
75 <        assertFalse((7 == ai.get()));
76 <        assertTrue(ai.compareAndSet(-4,7));
77 <        assertEquals(7,ai.get());
71 >        assertTrue(ai.compareAndSet(1,2));
72 >        assertTrue(ai.compareAndSet(2,-4));
73 >        assertEquals(-4,ai.get());
74 >        assertFalse(ai.compareAndSet(-5,7));
75 >        assertFalse((7 == ai.get()));
76 >        assertTrue(ai.compareAndSet(-4,7));
77 >        assertEquals(7,ai.get());
78      }
79  
80      /**
# Line 98 | Line 102 | public class AtomicIntegerTest extends J
102       */
103      public void testWeakCompareAndSet() {
104          AtomicInteger ai = new AtomicInteger(1);
105 <        while (!ai.weakCompareAndSet(1,2));
106 <        while (!ai.weakCompareAndSet(2,-4));
107 <        assertEquals(-4,ai.get());
105 >        while (!ai.weakCompareAndSet(1,2));
106 >        while (!ai.weakCompareAndSet(2,-4));
107 >        assertEquals(-4,ai.get());
108          while (!ai.weakCompareAndSet(-4,7));
109 <        assertEquals(7,ai.get());
109 >        assertEquals(7,ai.get());
110      }
111  
112      /**
# Line 110 | Line 114 | public class AtomicIntegerTest extends J
114       */
115      public void testGetAndSet() {
116          AtomicInteger ai = new AtomicInteger(1);
117 <        assertEquals(1,ai.getAndSet(0));
118 <        assertEquals(0,ai.getAndSet(-10));
119 <        assertEquals(-10,ai.getAndSet(1));
117 >        assertEquals(1,ai.getAndSet(0));
118 >        assertEquals(0,ai.getAndSet(-10));
119 >        assertEquals(-10,ai.getAndSet(1));
120      }
121  
122      /**
# Line 120 | Line 124 | public class AtomicIntegerTest extends J
124       */
125      public void testGetAndAdd() {
126          AtomicInteger ai = new AtomicInteger(1);
127 <        assertEquals(1,ai.getAndAdd(2));
128 <        assertEquals(3,ai.get());
129 <        assertEquals(3,ai.getAndAdd(-4));
130 <        assertEquals(-1,ai.get());
127 >        assertEquals(1,ai.getAndAdd(2));
128 >        assertEquals(3,ai.get());
129 >        assertEquals(3,ai.getAndAdd(-4));
130 >        assertEquals(-1,ai.get());
131      }
132  
133      /**
# Line 131 | Line 135 | public class AtomicIntegerTest extends J
135       */
136      public void testGetAndDecrement() {
137          AtomicInteger ai = new AtomicInteger(1);
138 <        assertEquals(1,ai.getAndDecrement());
139 <        assertEquals(0,ai.getAndDecrement());
140 <        assertEquals(-1,ai.getAndDecrement());
138 >        assertEquals(1,ai.getAndDecrement());
139 >        assertEquals(0,ai.getAndDecrement());
140 >        assertEquals(-1,ai.getAndDecrement());
141      }
142  
143      /**
# Line 141 | Line 145 | public class AtomicIntegerTest extends J
145       */
146      public void testGetAndIncrement() {
147          AtomicInteger ai = new AtomicInteger(1);
148 <        assertEquals(1,ai.getAndIncrement());
149 <        assertEquals(2,ai.get());
150 <        ai.set(-2);
151 <        assertEquals(-2,ai.getAndIncrement());
152 <        assertEquals(-1,ai.getAndIncrement());
153 <        assertEquals(0,ai.getAndIncrement());
154 <        assertEquals(1,ai.get());
148 >        assertEquals(1,ai.getAndIncrement());
149 >        assertEquals(2,ai.get());
150 >        ai.set(-2);
151 >        assertEquals(-2,ai.getAndIncrement());
152 >        assertEquals(-1,ai.getAndIncrement());
153 >        assertEquals(0,ai.getAndIncrement());
154 >        assertEquals(1,ai.get());
155      }
156  
157      /**
# Line 155 | Line 159 | public class AtomicIntegerTest extends J
159       */
160      public void testAddAndGet() {
161          AtomicInteger ai = new AtomicInteger(1);
162 <        assertEquals(3,ai.addAndGet(2));
163 <        assertEquals(3,ai.get());
164 <        assertEquals(-1,ai.addAndGet(-4));
165 <        assertEquals(-1,ai.get());
162 >        assertEquals(3,ai.addAndGet(2));
163 >        assertEquals(3,ai.get());
164 >        assertEquals(-1,ai.addAndGet(-4));
165 >        assertEquals(-1,ai.get());
166      }
167  
168      /**
# Line 166 | Line 170 | public class AtomicIntegerTest extends J
170       */
171      public void testDecrementAndGet() {
172          AtomicInteger ai = new AtomicInteger(1);
173 <        assertEquals(0,ai.decrementAndGet());
174 <        assertEquals(-1,ai.decrementAndGet());
175 <        assertEquals(-2,ai.decrementAndGet());
176 <        assertEquals(-2,ai.get());
173 >        assertEquals(0,ai.decrementAndGet());
174 >        assertEquals(-1,ai.decrementAndGet());
175 >        assertEquals(-2,ai.decrementAndGet());
176 >        assertEquals(-2,ai.get());
177      }
178  
179      /**
# Line 177 | Line 181 | public class AtomicIntegerTest extends J
181       */
182      public void testIncrementAndGet() {
183          AtomicInteger ai = new AtomicInteger(1);
184 <        assertEquals(2,ai.incrementAndGet());
185 <        assertEquals(2,ai.get());
186 <        ai.set(-2);
187 <        assertEquals(-1,ai.incrementAndGet());
188 <        assertEquals(0,ai.incrementAndGet());
189 <        assertEquals(1,ai.incrementAndGet());
190 <        assertEquals(1,ai.get());
184 >        assertEquals(2,ai.incrementAndGet());
185 >        assertEquals(2,ai.get());
186 >        ai.set(-2);
187 >        assertEquals(-1,ai.incrementAndGet());
188 >        assertEquals(0,ai.incrementAndGet());
189 >        assertEquals(1,ai.incrementAndGet());
190 >        assertEquals(1,ai.get());
191      }
192  
193      /**
# Line 209 | Line 213 | public class AtomicIntegerTest extends J
213       */
214      public void testToString() {
215          AtomicInteger ai = new AtomicInteger();
216 <        for (int i = -12; i < 6; ++i) {
217 <            ai.set(i);
218 <            assertEquals(ai.toString(), Integer.toString(i));
216 >        assertEquals("0", ai.toString());
217 >        for (int x : VALUES) {
218 >            ai.set(x);
219 >            assertEquals(ai.toString(), Integer.toString(x));
220          }
221      }
222  
# Line 220 | Line 225 | public class AtomicIntegerTest extends J
225       */
226      public void testIntValue() {
227          AtomicInteger ai = new AtomicInteger();
228 <        for (int i = -12; i < 6; ++i) {
229 <            ai.set(i);
230 <            assertEquals(i, ai.intValue());
228 >        assertEquals(0, ai.intValue());
229 >        for (int x : VALUES) {
230 >            ai.set(x);
231 >            assertEquals(x, ai.intValue());
232          }
233      }
234  
229 –
235      /**
236       * longValue returns current value.
237       */
238      public void testLongValue() {
239          AtomicInteger ai = new AtomicInteger();
240 <        for (int i = -12; i < 6; ++i) {
241 <            ai.set(i);
242 <            assertEquals((long)i, ai.longValue());
240 >        assertEquals(0L, ai.longValue());
241 >        for (int x : VALUES) {
242 >            ai.set(x);
243 >            assertEquals((long)x, ai.longValue());
244          }
245      }
246  
# Line 243 | Line 249 | public class AtomicIntegerTest extends J
249       */
250      public void testFloatValue() {
251          AtomicInteger ai = new AtomicInteger();
252 <        for (int i = -12; i < 6; ++i) {
253 <            ai.set(i);
254 <            assertEquals((float)i, ai.floatValue());
252 >        assertEquals(0.0f, ai.floatValue());
253 >        for (int x : VALUES) {
254 >            ai.set(x);
255 >            assertEquals((float)x, ai.floatValue());
256          }
257      }
258  
# Line 254 | Line 261 | public class AtomicIntegerTest extends J
261       */
262      public void testDoubleValue() {
263          AtomicInteger ai = new AtomicInteger();
264 <        for (int i = -12; i < 6; ++i) {
265 <            ai.set(i);
266 <            assertEquals((double)i, ai.doubleValue());
264 >        assertEquals(0.0d, ai.doubleValue());
265 >        for (int x : VALUES) {
266 >            ai.set(x);
267 >            assertEquals((double)x, ai.doubleValue());
268          }
269      }
270  
263 –
264 –
271   }

Diff Legend

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