libcore/luni/src/test/java/tests/api/java/util/concurrent/AtomicIntegerTest.java

   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
   5  * Other contributors include Andrew Wright, Jeffrey Hayes,
   6  * Pat Fisher, Mike Judd.
   7  */
   8
   9 package tests.api.java.util.concurrent; // android-added
  10
  11 import junit.framework.*;
  12 import java.util.concurrent.atomic.*;
  13 import java.io.*;
  14
  15 public class AtomicIntegerTest extends JSR166TestCase {
  16     public static Test suite() {
  17         return new TestSuite(AtomicIntegerTest.class);
  18     }
  19
  20     final int[] VALUES = {
  21         Integer.MIN_VALUE, -1, 0, 1, 42, Integer.MAX_VALUE,
  22     };
  23
  24     /**
  25      * constructor initializes to given value
  26      */
  27     public void testConstructor() {
  28         AtomicInteger ai = new AtomicInteger(1);
  29         assertEquals(1,ai.get());
  30     }
  31
  32     /**
  33      * default constructed initializes to zero
  34      */
  35     public void testConstructor2() {
  36         AtomicInteger ai = new AtomicInteger();
  37         assertEquals(0,ai.get());
  38     }
  39
  40     /**
  41      * get returns the last value set
  42      */
  43     public void testGetSet() {
  44         AtomicInteger ai = new AtomicInteger(1);
  45         assertEquals(1,ai.get());
  46         ai.set(2);
  47         assertEquals(2,ai.get());
  48         ai.set(-3);
  49         assertEquals(-3,ai.get());
  50     }
  51
  52     /**
  53      * get returns the last value lazySet in same thread
  54      */
  55     public void testGetLazySet() {
  56         AtomicInteger ai = new AtomicInteger(1);
  57         assertEquals(1,ai.get());
  58         ai.lazySet(2);
  59         assertEquals(2,ai.get());
  60         ai.lazySet(-3);
  61         assertEquals(-3,ai.get());
  62     }
  63
  64     /**
  65      * compareAndSet succeeds in changing value if equal to expected else fails
  66      */
  67     public void testCompareAndSet() {
  68         AtomicInteger ai = new AtomicInteger(1);
  69         assertTrue(ai.compareAndSet(1,2));
  70         assertTrue(ai.compareAndSet(2,-4));
  71         assertEquals(-4,ai.get());
  72         assertFalse(ai.compareAndSet(-5,7));
  73         assertEquals(-4,ai.get());
  74         assertTrue(ai.compareAndSet(-4,7));
  75         assertEquals(7,ai.get());
  76     }
  77
  78     /**
  79      * compareAndSet in one thread enables another waiting for value
  80      * to succeed
  81      */
  82     public void testCompareAndSetInMultipleThreads() throws Exception {
  83         final AtomicInteger ai = new AtomicInteger(1);
  84         Thread t = new Thread(new CheckedRunnable() {
  85             public void realRun() {
  86                 while (!ai.compareAndSet(2, 3))
  87                     Thread.yield();
  88             }});
  89
  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     }
  96
  97     /**
  98      * repeated weakCompareAndSet succeeds in changing value when equal
  99      * to expected
 100      */
 101     public void testWeakCompareAndSet() {
 102         AtomicInteger ai = new AtomicInteger(1);
 103         while (!ai.weakCompareAndSet(1,2));
 104         while (!ai.weakCompareAndSet(2,-4));
 105         assertEquals(-4,ai.get());
 106         while (!ai.weakCompareAndSet(-4,7));
 107         assertEquals(7,ai.get());
 108     }
 109
 110     /**
 111      * getAndSet returns previous value and sets to given value
 112      */
 113     public void testGetAndSet() {
 114         AtomicInteger ai = new AtomicInteger(1);
 115         assertEquals(1,ai.getAndSet(0));
 116         assertEquals(0,ai.getAndSet(-10));
 117         assertEquals(-10,ai.getAndSet(1));
 118     }
 119
 120     /**
 121      * getAndAdd returns previous value and adds given value
 122      */
 123     public void testGetAndAdd() {
 124         AtomicInteger ai = new AtomicInteger(1);
 125         assertEquals(1,ai.getAndAdd(2));
 126         assertEquals(3,ai.get());
 127         assertEquals(3,ai.getAndAdd(-4));
 128         assertEquals(-1,ai.get());
 129     }
 130
 131     /**
 132      * getAndDecrement returns previous value and decrements
 133      */
 134     public void testGetAndDecrement() {
 135         AtomicInteger ai = new AtomicInteger(1);
 136         assertEquals(1,ai.getAndDecrement());
 137         assertEquals(0,ai.getAndDecrement());
 138         assertEquals(-1,ai.getAndDecrement());
 139     }
 140
 141     /**
 142      * getAndIncrement returns previous value and increments
 143      */
 144     public void testGetAndIncrement() {
 145         AtomicInteger ai = new AtomicInteger(1);
 146         assertEquals(1,ai.getAndIncrement());
 147         assertEquals(2,ai.get());
 148         ai.set(-2);
 149         assertEquals(-2,ai.getAndIncrement());
 150         assertEquals(-1,ai.getAndIncrement());
 151         assertEquals(0,ai.getAndIncrement());
 152         assertEquals(1,ai.get());
 153     }
 154
 155     /**
 156      * addAndGet adds given value to current, and returns current value
 157      */
 158     public void testAddAndGet() {
 159         AtomicInteger ai = new AtomicInteger(1);
 160         assertEquals(3,ai.addAndGet(2));
 161         assertEquals(3,ai.get());
 162         assertEquals(-1,ai.addAndGet(-4));
 163         assertEquals(-1,ai.get());
 164     }
 165
 166     /**
 167      * decrementAndGet decrements and returns current value
 168      */
 169     public void testDecrementAndGet() {
 170         AtomicInteger ai = new AtomicInteger(1);
 171         assertEquals(0,ai.decrementAndGet());
 172         assertEquals(-1,ai.decrementAndGet());
 173         assertEquals(-2,ai.decrementAndGet());
 174         assertEquals(-2,ai.get());
 175     }
 176
 177     /**
 178      * incrementAndGet increments and returns current value
 179      */
 180     public void testIncrementAndGet() {
 181         AtomicInteger ai = new AtomicInteger(1);
 182         assertEquals(2,ai.incrementAndGet());
 183         assertEquals(2,ai.get());
 184         ai.set(-2);
 185         assertEquals(-1,ai.incrementAndGet());
 186         assertEquals(0,ai.incrementAndGet());
 187         assertEquals(1,ai.incrementAndGet());
 188         assertEquals(1,ai.get());
 189     }
 190
 191     /**
 192      * a deserialized serialized atomic holds same value
 193      */
 194     public void testSerialization() throws Exception {
 195         AtomicInteger l = new AtomicInteger();
 196
 197         l.set(22);
 198         ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
 199         ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
 200         out.writeObject(l);
 201         out.close();
 202
 203         ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
 204         ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
 205         AtomicInteger r = (AtomicInteger) in.readObject();
 206         assertEquals(l.get(), r.get());
 207     }
 208
 209     /**
 210      * toString returns current value.
 211      */
 212     public void testToString() {
 213         AtomicInteger ai = new AtomicInteger();
 214         assertEquals("0", ai.toString());
 215         for (int x : VALUES) {
 216             ai.set(x);
 217             assertEquals(ai.toString(), Integer.toString(x));
 218         }
 219     }
 220
 221     /**
 222      * intValue returns current value.
 223      */
 224     public void testIntValue() {
 225         AtomicInteger ai = new AtomicInteger();
 226         assertEquals(0, ai.intValue());
 227         for (int x : VALUES) {
 228             ai.set(x);
 229             assertEquals(x, ai.intValue());
 230         }
 231     }
 232
 233     /**
 234      * longValue returns current value.
 235      */
 236     public void testLongValue() {
 237         AtomicInteger ai = new AtomicInteger();
 238         assertEquals(0L, ai.longValue());
 239         for (int x : VALUES) {
 240             ai.set(x);
 241             assertEquals((long)x, ai.longValue());
 242         }
 243     }
 244
 245     /**
 246      * floatValue returns current value.
 247      */
 248     public void testFloatValue() {
 249         AtomicInteger ai = new AtomicInteger();
 250         assertEquals(0.0f, ai.floatValue());
 251         for (int x : VALUES) {
 252             ai.set(x);
 253             assertEquals((float)x, ai.floatValue());
 254         }
 255     }
 256
 257     /**
 258      * doubleValue returns current value.
 259      */
 260     public void testDoubleValue() {
 261         AtomicInteger ai = new AtomicInteger();
 262         assertEquals(0.0d, ai.doubleValue());
 263         for (int x : VALUES) {
 264             ai.set(x);
 265             assertEquals((double)x, ai.doubleValue());
 266         }
 267     }
 268
 269 }