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.9 by dl, Sun Jan 11 01:31:34 2004 UTC vs.
Revision 1.19 by jsr166, Tue Dec 1 09:56:28 2009 UTC

# Line 2 | Line 2
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
5 < * Other contributors include Andrew Wright, Jeffrey Hayes,
6 < * Pat Fisher, Mike Judd.
5 > * Other contributors include Andrew Wright, Jeffrey Hayes,
6 > * Pat Fisher, Mike Judd.
7   */
8  
9   import junit.framework.*;
# 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(){
28 >    public void testConstructor() {
29          AtomicInteger ai = new AtomicInteger(1);
30 <        assertEquals(1,ai.get());
30 >        assertEquals(1,ai.get());
31      }
32  
33      /**
34       * default constructed initializes to zero
35       */
36 <    public void testConstructor2(){
36 >    public void testConstructor2() {
37          AtomicInteger ai = new AtomicInteger();
38 <        assertEquals(0,ai.get());
38 >        assertEquals(0,ai.get());
39      }
40  
41      /**
42       * get returns the last value set
43       */
44 <    public void testGetSet(){
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 +    /**
54 +     * get returns the last value lazySet in same thread
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());
63 +    }
64 +
65      /**
66       * compareAndSet succeeds in changing value if equal to expected else fails
67       */
68 <    public void testCompareAndSet(){
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      /**
80       * compareAndSet in one thread enables another waiting for value
81       * to succeed
82       */
83 <    public void testCompareAndSetInMultipleThreads() {
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 <                }});
89 <        try {
90 <            t.start();
91 <            assertTrue(ai.compareAndSet(1, 2));
92 <            t.join(LONG_DELAY_MS);
93 <            assertFalse(t.isAlive());
94 <            assertEquals(ai.get(), 3);
95 <        }
80 <        catch(Exception e) {
81 <            unexpectedException();
82 <        }
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));
93 >        t.join(LONG_DELAY_MS);
94 >        assertFalse(t.isAlive());
95 >        assertEquals(ai.get(), 3);
96      }
97  
98      /**
99       * repeated weakCompareAndSet succeeds in changing value when equal
100 <     * to expected
100 >     * to expected
101       */
102 <    public void testWeakCompareAndSet(){
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());
107 <        while(!ai.weakCompareAndSet(-4,7));
108 <        assertEquals(7,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());
109      }
110  
111      /**
112       * getAndSet returns previous value and sets to given value
113       */
114 <    public void testGetAndSet(){
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      /**
122       * getAndAdd returns previous value and adds given value
123       */
124 <    public void testGetAndAdd(){
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      /**
133       * getAndDecrement returns previous value and decrements
134       */
135 <    public void testGetAndDecrement(){
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      /**
143       * getAndIncrement returns previous value and increments
144       */
145 <    public void testGetAndIncrement(){
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      /**
157       * addAndGet adds given value to current, and returns current value
158       */
159 <    public void testAddAndGet(){
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      /**
168       * decrementAndGet decrements and returns current value
169       */
170 <    public void testDecrementAndGet(){
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      /**
179       * incrementAndGet increments and returns current value
180       */
181 <    public void testIncrementAndGet(){
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      /**
193       * a deserialized serialized atomic holds same value
194       */
195 <    public void testSerialization() {
195 >    public void testSerialization() throws Exception {
196          AtomicInteger l = new AtomicInteger();
197  
198 <        try {
199 <            l.set(22);
200 <            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
201 <            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
202 <            out.writeObject(l);
203 <            out.close();
204 <
205 <            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
206 <            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
207 <            AtomicInteger r = (AtomicInteger) in.readObject();
195 <            assertEquals(l.get(), r.get());
196 <        } catch(Exception e){
197 <            unexpectedException();
198 <        }
198 >        l.set(22);
199 >        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
200 >        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
201 >        out.writeObject(l);
202 >        out.close();
203 >
204 >        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
205 >        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
206 >        AtomicInteger r = (AtomicInteger) in.readObject();
207 >        assertEquals(l.get(), r.get());
208      }
209  
210      /**
211       * toString returns current value.
212 <     */
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  
222      /**
223       * intValue returns current value.
224 <     */
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  
223 –
234      /**
235       * longValue returns current value.
236 <     */
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  
246      /**
247       * floatValue returns current value.
248 <     */
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  
258      /**
259       * doubleValue returns current value.
260 <     */
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  
257 –
258 –
270   }

Diff Legend

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