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

Comparing jsr166/src/test/tck/AtomicLongTest.java (file contents):
Revision 1.15 by jsr166, Tue Nov 17 06:58:50 2009 UTC vs.
Revision 1.27 by jsr166, Wed Dec 31 19:05:42 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.*;
11 < import java.io.*;
9 > import java.util.concurrent.atomic.AtomicLong;
10 >
11 > import junit.framework.Test;
12 > import junit.framework.TestSuite;
13  
14   public class AtomicLongTest extends JSR166TestCase {
15 <    public static void main (String[] args) {
16 <        junit.textui.TestRunner.run (suite());
15 >    public static void main(String[] args) {
16 >        junit.textui.TestRunner.run(suite());
17      }
18      public static Test suite() {
19          return new TestSuite(AtomicLongTest.class);
20      }
21  
22 +    final long[] VALUES = {
23 +        Long.MIN_VALUE,
24 +        Integer.MIN_VALUE, -1, 0, 1, 42, Integer.MAX_VALUE,
25 +        Long.MAX_VALUE,
26 +    };
27 +
28      /**
29       * constructor initializes to given value
30       */
31      public void testConstructor() {
32          AtomicLong ai = new AtomicLong(1);
33 <        assertEquals(1,ai.get());
33 >        assertEquals(1, ai.get());
34      }
35  
36      /**
# Line 31 | Line 38 | public class AtomicLongTest extends JSR1
38       */
39      public void testConstructor2() {
40          AtomicLong ai = new AtomicLong();
41 <        assertEquals(0,ai.get());
41 >        assertEquals(0, ai.get());
42      }
43  
44      /**
# Line 39 | Line 46 | public class AtomicLongTest extends JSR1
46       */
47      public void testGetSet() {
48          AtomicLong ai = new AtomicLong(1);
49 <        assertEquals(1,ai.get());
50 <        ai.set(2);
51 <        assertEquals(2,ai.get());
52 <        ai.set(-3);
53 <        assertEquals(-3,ai.get());
47 <
49 >        assertEquals(1, ai.get());
50 >        ai.set(2);
51 >        assertEquals(2, ai.get());
52 >        ai.set(-3);
53 >        assertEquals(-3, ai.get());
54      }
55  
56      /**
# Line 52 | Line 58 | public class AtomicLongTest extends JSR1
58       */
59      public void testGetLazySet() {
60          AtomicLong ai = new AtomicLong(1);
61 <        assertEquals(1,ai.get());
62 <        ai.lazySet(2);
63 <        assertEquals(2,ai.get());
64 <        ai.lazySet(-3);
65 <        assertEquals(-3,ai.get());
60 <
61 >        assertEquals(1, ai.get());
62 >        ai.lazySet(2);
63 >        assertEquals(2, ai.get());
64 >        ai.lazySet(-3);
65 >        assertEquals(-3, ai.get());
66      }
67  
68      /**
# Line 65 | Line 70 | public class AtomicLongTest extends JSR1
70       */
71      public void testCompareAndSet() {
72          AtomicLong ai = new AtomicLong(1);
73 <        assertTrue(ai.compareAndSet(1,2));
74 <        assertTrue(ai.compareAndSet(2,-4));
75 <        assertEquals(-4,ai.get());
76 <        assertFalse(ai.compareAndSet(-5,7));
77 <        assertFalse((7 == ai.get()));
78 <        assertTrue(ai.compareAndSet(-4,7));
79 <        assertEquals(7,ai.get());
73 >        assertTrue(ai.compareAndSet(1, 2));
74 >        assertTrue(ai.compareAndSet(2, -4));
75 >        assertEquals(-4, ai.get());
76 >        assertFalse(ai.compareAndSet(-5, 7));
77 >        assertEquals(-4, ai.get());
78 >        assertTrue(ai.compareAndSet(-4, 7));
79 >        assertEquals(7, ai.get());
80      }
81  
82      /**
# Line 90 | Line 95 | public class AtomicLongTest extends JSR1
95          assertTrue(ai.compareAndSet(1, 2));
96          t.join(LONG_DELAY_MS);
97          assertFalse(t.isAlive());
98 <        assertEquals(ai.get(), 3);
98 >        assertEquals(3, ai.get());
99      }
100  
101      /**
# Line 99 | Line 104 | public class AtomicLongTest extends JSR1
104       */
105      public void testWeakCompareAndSet() {
106          AtomicLong ai = new AtomicLong(1);
107 <        while (!ai.weakCompareAndSet(1,2));
108 <        while (!ai.weakCompareAndSet(2,-4));
109 <        assertEquals(-4,ai.get());
110 <        while (!ai.weakCompareAndSet(-4,7));
111 <        assertEquals(7,ai.get());
107 >        while (!ai.weakCompareAndSet(1, 2));
108 >        while (!ai.weakCompareAndSet(2, -4));
109 >        assertEquals(-4, ai.get());
110 >        while (!ai.weakCompareAndSet(-4, 7));
111 >        assertEquals(7, ai.get());
112      }
113  
114      /**
# Line 111 | Line 116 | public class AtomicLongTest extends JSR1
116       */
117      public void testGetAndSet() {
118          AtomicLong ai = new AtomicLong(1);
119 <        assertEquals(1,ai.getAndSet(0));
120 <        assertEquals(0,ai.getAndSet(-10));
121 <        assertEquals(-10,ai.getAndSet(1));
119 >        assertEquals(1, ai.getAndSet(0));
120 >        assertEquals(0, ai.getAndSet(-10));
121 >        assertEquals(-10, ai.getAndSet(1));
122      }
123  
124      /**
# Line 121 | Line 126 | public class AtomicLongTest extends JSR1
126       */
127      public void testGetAndAdd() {
128          AtomicLong ai = new AtomicLong(1);
129 <        assertEquals(1,ai.getAndAdd(2));
130 <        assertEquals(3,ai.get());
131 <        assertEquals(3,ai.getAndAdd(-4));
132 <        assertEquals(-1,ai.get());
129 >        assertEquals(1, ai.getAndAdd(2));
130 >        assertEquals(3, ai.get());
131 >        assertEquals(3, ai.getAndAdd(-4));
132 >        assertEquals(-1, ai.get());
133      }
134  
135      /**
# Line 132 | Line 137 | public class AtomicLongTest extends JSR1
137       */
138      public void testGetAndDecrement() {
139          AtomicLong ai = new AtomicLong(1);
140 <        assertEquals(1,ai.getAndDecrement());
141 <        assertEquals(0,ai.getAndDecrement());
142 <        assertEquals(-1,ai.getAndDecrement());
140 >        assertEquals(1, ai.getAndDecrement());
141 >        assertEquals(0, ai.getAndDecrement());
142 >        assertEquals(-1, ai.getAndDecrement());
143      }
144  
145      /**
# Line 142 | Line 147 | public class AtomicLongTest extends JSR1
147       */
148      public void testGetAndIncrement() {
149          AtomicLong ai = new AtomicLong(1);
150 <        assertEquals(1,ai.getAndIncrement());
151 <        assertEquals(2,ai.get());
152 <        ai.set(-2);
153 <        assertEquals(-2,ai.getAndIncrement());
154 <        assertEquals(-1,ai.getAndIncrement());
155 <        assertEquals(0,ai.getAndIncrement());
156 <        assertEquals(1,ai.get());
150 >        assertEquals(1, ai.getAndIncrement());
151 >        assertEquals(2, ai.get());
152 >        ai.set(-2);
153 >        assertEquals(-2, ai.getAndIncrement());
154 >        assertEquals(-1, ai.getAndIncrement());
155 >        assertEquals(0, ai.getAndIncrement());
156 >        assertEquals(1, ai.get());
157      }
158  
159      /**
# Line 156 | Line 161 | public class AtomicLongTest extends JSR1
161       */
162      public void testAddAndGet() {
163          AtomicLong ai = new AtomicLong(1);
164 <        assertEquals(3,ai.addAndGet(2));
165 <        assertEquals(3,ai.get());
166 <        assertEquals(-1,ai.addAndGet(-4));
167 <        assertEquals(-1,ai.get());
164 >        assertEquals(3, ai.addAndGet(2));
165 >        assertEquals(3, ai.get());
166 >        assertEquals(-1, ai.addAndGet(-4));
167 >        assertEquals(-1, ai.get());
168      }
169  
170      /**
# Line 167 | Line 172 | public class AtomicLongTest extends JSR1
172       */
173      public void testDecrementAndGet() {
174          AtomicLong ai = new AtomicLong(1);
175 <        assertEquals(0,ai.decrementAndGet());
176 <        assertEquals(-1,ai.decrementAndGet());
177 <        assertEquals(-2,ai.decrementAndGet());
178 <        assertEquals(-2,ai.get());
175 >        assertEquals(0, ai.decrementAndGet());
176 >        assertEquals(-1, ai.decrementAndGet());
177 >        assertEquals(-2, ai.decrementAndGet());
178 >        assertEquals(-2, ai.get());
179      }
180  
181      /**
# Line 178 | Line 183 | public class AtomicLongTest extends JSR1
183       */
184      public void testIncrementAndGet() {
185          AtomicLong ai = new AtomicLong(1);
186 <        assertEquals(2,ai.incrementAndGet());
187 <        assertEquals(2,ai.get());
188 <        ai.set(-2);
189 <        assertEquals(-1,ai.incrementAndGet());
190 <        assertEquals(0,ai.incrementAndGet());
191 <        assertEquals(1,ai.incrementAndGet());
192 <        assertEquals(1,ai.get());
186 >        assertEquals(2, ai.incrementAndGet());
187 >        assertEquals(2, ai.get());
188 >        ai.set(-2);
189 >        assertEquals(-1, ai.incrementAndGet());
190 >        assertEquals(0, ai.incrementAndGet());
191 >        assertEquals(1, ai.incrementAndGet());
192 >        assertEquals(1, ai.get());
193      }
194  
195      /**
196       * a deserialized serialized atomic holds same value
197       */
198      public void testSerialization() throws Exception {
199 <        AtomicLong l = new AtomicLong();
200 <
201 <        l.set(-22);
202 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
203 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
204 <        out.writeObject(l);
205 <        out.close();
206 <
207 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
203 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
204 <        AtomicLong r = (AtomicLong) in.readObject();
205 <        assertEquals(l.get(), r.get());
199 >        AtomicLong x = new AtomicLong();
200 >        AtomicLong y = serialClone(x);
201 >        assertNotSame(x, y);
202 >        x.set(-22);
203 >        AtomicLong z = serialClone(x);
204 >        assertNotSame(y, z);
205 >        assertEquals(-22, x.get());
206 >        assertEquals(0, y.get());
207 >        assertEquals(-22, z.get());
208      }
209  
210      /**
# Line 210 | Line 212 | public class AtomicLongTest extends JSR1
212       */
213      public void testToString() {
214          AtomicLong ai = new AtomicLong();
215 <        for (long i = -12; i < 6; ++i) {
216 <            ai.set(i);
217 <            assertEquals(ai.toString(), Long.toString(i));
215 >        assertEquals("0", ai.toString());
216 >        for (long x : VALUES) {
217 >            ai.set(x);
218 >            assertEquals(Long.toString(x), ai.toString());
219 >        }
220 >    }
221 >
222 >    /**
223 >     * intValue returns current value.
224 >     */
225 >    public void testIntValue() {
226 >        AtomicLong ai = new AtomicLong();
227 >        assertEquals(0, ai.intValue());
228 >        for (long x : VALUES) {
229 >            ai.set(x);
230 >            assertEquals((int)x, ai.intValue());
231          }
232      }
233  
# Line 221 | Line 236 | public class AtomicLongTest extends JSR1
236       */
237      public void testLongValue() {
238          AtomicLong ai = new AtomicLong();
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 (long x : VALUES) {
241 >            ai.set(x);
242 >            assertEquals(x, ai.longValue());
243          }
244      }
245  
# Line 232 | Line 248 | public class AtomicLongTest extends JSR1
248       */
249      public void testFloatValue() {
250          AtomicLong ai = new AtomicLong();
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 (long x : VALUES) {
253 >            ai.set(x);
254 >            assertEquals((float)x, ai.floatValue());
255          }
256      }
257  
# Line 243 | Line 260 | public class AtomicLongTest extends JSR1
260       */
261      public void testDoubleValue() {
262          AtomicLong ai = new AtomicLong();
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 (long x : VALUES) {
265 >            ai.set(x);
266 >            assertEquals((double)x, ai.doubleValue());
267          }
268      }
269  
252 –
270   }

Diff Legend

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