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.20 by jsr166, Tue Mar 15 19:47:06 2011 UTC vs.
Revision 1.34 by dl, Tue Jan 26 13:33:05 2021 UTC

# Line 6 | Line 6
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());
16 >        main(suite(), args);
17      }
18      public static Test suite() {
19          return new TestSuite(AtomicLongTest.class);
# Line 29 | Line 30 | public class AtomicLongTest extends JSR1
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 37 | 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 45 | Line 46 | public class AtomicLongTest extends JSR1
46       */
47      public void testGetSet() {
48          AtomicLong ai = new AtomicLong(1);
49 <        assertEquals(1,ai.get());
49 >        assertEquals(1, ai.get());
50          ai.set(2);
51 <        assertEquals(2,ai.get());
51 >        assertEquals(2, ai.get());
52          ai.set(-3);
53 <        assertEquals(-3,ai.get());
53 >        assertEquals(-3, ai.get());
54      }
55  
56      /**
# Line 57 | Line 58 | public class AtomicLongTest extends JSR1
58       */
59      public void testGetLazySet() {
60          AtomicLong ai = new AtomicLong(1);
61 <        assertEquals(1,ai.get());
61 >        assertEquals(1, ai.get());
62          ai.lazySet(2);
63 <        assertEquals(2,ai.get());
63 >        assertEquals(2, ai.get());
64          ai.lazySet(-3);
65 <        assertEquals(-3,ai.get());
65 >        assertEquals(-3, ai.get());
66      }
67  
68      /**
# Line 69 | 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 <        assertEquals(-4,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 94 | 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      /**
102       * repeated weakCompareAndSet succeeds in changing value when equal
103       * to expected
104       */
105 +    @SuppressWarnings("deprecation")
106      public void testWeakCompareAndSet() {
107          AtomicLong ai = new AtomicLong(1);
108 <        while (!ai.weakCompareAndSet(1,2));
109 <        while (!ai.weakCompareAndSet(2,-4));
110 <        assertEquals(-4,ai.get());
111 <        while (!ai.weakCompareAndSet(-4,7));
112 <        assertEquals(7,ai.get());
108 >        do {} while (!ai.weakCompareAndSet(1, 2));
109 >        do {} while (!ai.weakCompareAndSet(2, -4));
110 >        assertEquals(-4, ai.get());
111 >        do {} while (!ai.weakCompareAndSet(-4, 7));
112 >        assertEquals(7, ai.get());
113      }
114  
115      /**
# Line 115 | Line 117 | public class AtomicLongTest extends JSR1
117       */
118      public void testGetAndSet() {
119          AtomicLong ai = new AtomicLong(1);
120 <        assertEquals(1,ai.getAndSet(0));
121 <        assertEquals(0,ai.getAndSet(-10));
122 <        assertEquals(-10,ai.getAndSet(1));
120 >        assertEquals(1, ai.getAndSet(0));
121 >        assertEquals(0, ai.getAndSet(-10));
122 >        assertEquals(-10, ai.getAndSet(1));
123      }
124  
125      /**
# Line 125 | Line 127 | public class AtomicLongTest extends JSR1
127       */
128      public void testGetAndAdd() {
129          AtomicLong ai = new AtomicLong(1);
130 <        assertEquals(1,ai.getAndAdd(2));
131 <        assertEquals(3,ai.get());
132 <        assertEquals(3,ai.getAndAdd(-4));
133 <        assertEquals(-1,ai.get());
130 >        assertEquals(1, ai.getAndAdd(2));
131 >        assertEquals(3, ai.get());
132 >        assertEquals(3, ai.getAndAdd(-4));
133 >        assertEquals(-1, ai.get());
134      }
135  
136      /**
# Line 136 | Line 138 | public class AtomicLongTest extends JSR1
138       */
139      public void testGetAndDecrement() {
140          AtomicLong ai = new AtomicLong(1);
141 <        assertEquals(1,ai.getAndDecrement());
142 <        assertEquals(0,ai.getAndDecrement());
143 <        assertEquals(-1,ai.getAndDecrement());
141 >        assertEquals(1, ai.getAndDecrement());
142 >        assertEquals(0, ai.getAndDecrement());
143 >        assertEquals(-1, ai.getAndDecrement());
144      }
145  
146      /**
# Line 146 | Line 148 | public class AtomicLongTest extends JSR1
148       */
149      public void testGetAndIncrement() {
150          AtomicLong ai = new AtomicLong(1);
151 <        assertEquals(1,ai.getAndIncrement());
152 <        assertEquals(2,ai.get());
151 >        assertEquals(1, ai.getAndIncrement());
152 >        assertEquals(2, ai.get());
153          ai.set(-2);
154 <        assertEquals(-2,ai.getAndIncrement());
155 <        assertEquals(-1,ai.getAndIncrement());
156 <        assertEquals(0,ai.getAndIncrement());
157 <        assertEquals(1,ai.get());
154 >        assertEquals(-2, ai.getAndIncrement());
155 >        assertEquals(-1, ai.getAndIncrement());
156 >        assertEquals(0, ai.getAndIncrement());
157 >        assertEquals(1, ai.get());
158      }
159  
160      /**
# Line 160 | Line 162 | public class AtomicLongTest extends JSR1
162       */
163      public void testAddAndGet() {
164          AtomicLong ai = new AtomicLong(1);
165 <        assertEquals(3,ai.addAndGet(2));
166 <        assertEquals(3,ai.get());
167 <        assertEquals(-1,ai.addAndGet(-4));
168 <        assertEquals(-1,ai.get());
165 >        assertEquals(3, ai.addAndGet(2));
166 >        assertEquals(3, ai.get());
167 >        assertEquals(-1, ai.addAndGet(-4));
168 >        assertEquals(-1, ai.get());
169      }
170  
171      /**
# Line 171 | Line 173 | public class AtomicLongTest extends JSR1
173       */
174      public void testDecrementAndGet() {
175          AtomicLong ai = new AtomicLong(1);
176 <        assertEquals(0,ai.decrementAndGet());
177 <        assertEquals(-1,ai.decrementAndGet());
178 <        assertEquals(-2,ai.decrementAndGet());
179 <        assertEquals(-2,ai.get());
176 >        assertEquals(0, ai.decrementAndGet());
177 >        assertEquals(-1, ai.decrementAndGet());
178 >        assertEquals(-2, ai.decrementAndGet());
179 >        assertEquals(-2, ai.get());
180      }
181  
182      /**
# Line 182 | Line 184 | public class AtomicLongTest extends JSR1
184       */
185      public void testIncrementAndGet() {
186          AtomicLong ai = new AtomicLong(1);
187 <        assertEquals(2,ai.incrementAndGet());
188 <        assertEquals(2,ai.get());
187 >        assertEquals(2, ai.incrementAndGet());
188 >        assertEquals(2, ai.get());
189          ai.set(-2);
190 <        assertEquals(-1,ai.incrementAndGet());
191 <        assertEquals(0,ai.incrementAndGet());
192 <        assertEquals(1,ai.incrementAndGet());
193 <        assertEquals(1,ai.get());
190 >        assertEquals(-1, ai.incrementAndGet());
191 >        assertEquals(0, ai.incrementAndGet());
192 >        assertEquals(1, ai.incrementAndGet());
193 >        assertEquals(1, ai.get());
194      }
195  
196      /**
197 <     * a deserialized serialized atomic holds same value
197 >     * a deserialized/reserialized atomic holds same value
198       */
199      public void testSerialization() throws Exception {
200 <        AtomicLong l = new AtomicLong();
201 <
202 <        l.set(-22);
203 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
204 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
205 <        out.writeObject(l);
206 <        out.close();
207 <
208 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
207 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
208 <        AtomicLong r = (AtomicLong) in.readObject();
209 <        assertEquals(l.get(), r.get());
200 >        AtomicLong x = new AtomicLong();
201 >        AtomicLong y = serialClone(x);
202 >        assertNotSame(x, y);
203 >        x.set(-22);
204 >        AtomicLong z = serialClone(x);
205 >        assertNotSame(y, z);
206 >        assertEquals(-22, x.get());
207 >        assertEquals(0, y.get());
208 >        assertEquals(-22, z.get());
209      }
210  
211      /**
# Line 215 | Line 214 | public class AtomicLongTest extends JSR1
214      public void testToString() {
215          AtomicLong ai = new AtomicLong();
216          assertEquals("0", ai.toString());
217 <        for (long i : VALUES) {
218 <            ai.set(i);
219 <            assertEquals(ai.toString(), Long.toString(i));
217 >        for (long x : VALUES) {
218 >            ai.set(x);
219 >            assertEquals(Long.toString(x), ai.toString());
220          }
221      }
222  
# Line 241 | Line 240 | public class AtomicLongTest extends JSR1
240          assertEquals(0L, ai.longValue());
241          for (long x : VALUES) {
242              ai.set(x);
243 <            assertEquals((long)x, ai.longValue());
243 >            assertEquals(x, ai.longValue());
244          }
245      }
246  

Diff Legend

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