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