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.10 by dl, Wed May 25 14:27:37 2005 UTC vs.
Revision 1.14 by jsr166, Mon Nov 16 05:30:07 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 21 | Line 21 | public class AtomicIntegerTest extends J
21      /**
22       * constructor initializes to given value
23       */
24 <    public void testConstructor(){
24 >    public void testConstructor() {
25          AtomicInteger ai = new AtomicInteger(1);
26          assertEquals(1,ai.get());
27      }
# Line 29 | Line 29 | public class AtomicIntegerTest extends J
29      /**
30       * default constructed initializes to zero
31       */
32 <    public void testConstructor2(){
32 >    public void testConstructor2() {
33          AtomicInteger ai = new AtomicInteger();
34          assertEquals(0,ai.get());
35      }
36  
37      /**
38 +     * get returns the last value set
39 +     */
40 +    public void testGetSet() {
41 +        AtomicInteger ai = new AtomicInteger(1);
42 +        assertEquals(1,ai.get());
43 +        ai.set(2);
44 +        assertEquals(2,ai.get());
45 +        ai.set(-3);
46 +        assertEquals(-3,ai.get());
47 +
48 +    }
49 +
50 +    /**
51       * get returns the last value lazySet in same thread
52       */
53 <    public void testGetLazySet(){
53 >    public void testGetLazySet() {
54          AtomicInteger ai = new AtomicInteger(1);
55          assertEquals(1,ai.get());
56          ai.lazySet(2);
57          assertEquals(2,ai.get());
58          ai.lazySet(-3);
59          assertEquals(-3,ai.get());
60 <        
60 >
61      }
62      /**
63       * compareAndSet succeeds in changing value if equal to expected else fails
64       */
65 <    public void testCompareAndSet(){
65 >    public void testCompareAndSet() {
66          AtomicInteger ai = new AtomicInteger(1);
67          assertTrue(ai.compareAndSet(1,2));
68          assertTrue(ai.compareAndSet(2,-4));
# Line 68 | Line 81 | public class AtomicIntegerTest extends J
81          final AtomicInteger ai = new AtomicInteger(1);
82          Thread t = new Thread(new Runnable() {
83                  public void run() {
84 <                    while(!ai.compareAndSet(2, 3)) Thread.yield();
84 >                    while (!ai.compareAndSet(2, 3)) Thread.yield();
85                  }});
86          try {
87              t.start();
# Line 77 | Line 90 | public class AtomicIntegerTest extends J
90              assertFalse(t.isAlive());
91              assertEquals(ai.get(), 3);
92          }
93 <        catch(Exception e) {
93 >        catch (Exception e) {
94              unexpectedException();
95          }
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));
104 >        while (!ai.weakCompareAndSet(1,2));
105 >        while (!ai.weakCompareAndSet(2,-4));
106          assertEquals(-4,ai.get());
107 <        while(!ai.weakCompareAndSet(-4,7));
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));
# Line 108 | Line 121 | public class AtomicIntegerTest extends J
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());
# Line 119 | Line 132 | public class AtomicIntegerTest extends J
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());
# Line 129 | Line 142 | public class AtomicIntegerTest extends J
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());
# Line 143 | Line 156 | public class AtomicIntegerTest extends J
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());
# Line 154 | Line 167 | public class AtomicIntegerTest extends J
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());
# Line 165 | Line 178 | public class AtomicIntegerTest extends J
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());
# Line 193 | Line 206 | public class AtomicIntegerTest extends J
206              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
207              AtomicInteger r = (AtomicInteger) in.readObject();
208              assertEquals(l.get(), r.get());
209 <        } catch(Exception e){
209 >        } catch (Exception e) {
210              unexpectedException();
211          }
212      }
213  
214      /**
215       * toString returns current value.
216 <     */
216 >     */
217      public void testToString() {
218          AtomicInteger ai = new AtomicInteger();
219          for (int i = -12; i < 6; ++i) {
# Line 211 | Line 224 | public class AtomicIntegerTest extends J
224  
225      /**
226       * intValue returns current value.
227 <     */
227 >     */
228      public void testIntValue() {
229          AtomicInteger ai = new AtomicInteger();
230          for (int i = -12; i < 6; ++i) {
# Line 223 | Line 236 | public class AtomicIntegerTest extends J
236  
237      /**
238       * longValue returns current value.
239 <     */
239 >     */
240      public void testLongValue() {
241          AtomicInteger ai = new AtomicInteger();
242          for (int i = -12; i < 6; ++i) {
# Line 234 | Line 247 | public class AtomicIntegerTest extends J
247  
248      /**
249       * floatValue returns current value.
250 <     */
250 >     */
251      public void testFloatValue() {
252          AtomicInteger ai = new AtomicInteger();
253          for (int i = -12; i < 6; ++i) {
# Line 245 | Line 258 | public class AtomicIntegerTest extends J
258  
259      /**
260       * doubleValue returns current value.
261 <     */
261 >     */
262      public void testDoubleValue() {
263          AtomicInteger ai = new AtomicInteger();
264          for (int i = -12; i < 6; ++i) {

Diff Legend

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