--- jsr166/src/test/tck/AtomicIntegerTest.java 2003/09/07 20:39:11 1.2 +++ jsr166/src/test/tck/AtomicIntegerTest.java 2016/06/16 23:35:25 1.29 @@ -1,140 +1,426 @@ /* - * Written by members of JCP JSR-166 Expert Group and released to the - * public domain. Use, modify, and redistribute this code in any way - * without acknowledgement. Other contributors include Andrew Wright, - * Jeffrey Hayes, Pat Fischer, Mike Judd. + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/publicdomain/zero/1.0/ + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -import junit.framework.*; -import java.util.concurrent.atomic.*; -import java.io.*; - -public class AtomicIntegerTest extends TestCase { - public static void main (String[] args) { - junit.textui.TestRunner.run (suite()); +import java.util.concurrent.atomic.AtomicInteger; + +import junit.framework.Test; +import junit.framework.TestSuite; + +public class AtomicIntegerTest extends JSR166TestCase { + public static void main(String[] args) { + main(suite(), args); } public static Test suite() { return new TestSuite(AtomicIntegerTest.class); } - public void testConstructor(){ - AtomicInteger ai = new AtomicInteger(1); - assertEquals(1,ai.get()); - } - - public void testConstructor2(){ + final int[] VALUES = { + Integer.MIN_VALUE, -1, 0, 1, 42, Integer.MAX_VALUE, + }; + + /** + * constructor initializes to given value + */ + public void testConstructor() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.get()); + } + + /** + * default constructed initializes to zero + */ + public void testConstructor2() { AtomicInteger ai = new AtomicInteger(); - assertEquals(0,ai.get()); - } - - public void testGetSet(){ - AtomicInteger ai = new AtomicInteger(1); - assertEquals(1,ai.get()); - ai.set(2); - assertEquals(2,ai.get()); - ai.set(-3); - assertEquals(-3,ai.get()); - - } - public void testCompareAndSet(){ - AtomicInteger ai = new AtomicInteger(1); - assertTrue(ai.compareAndSet(1,2)); - assertTrue(ai.compareAndSet(2,-4)); - assertEquals(-4,ai.get()); - assertFalse(ai.compareAndSet(-5,7)); - assertFalse((7 == ai.get())); - assertTrue(ai.compareAndSet(-4,7)); - assertEquals(7,ai.get()); + assertEquals(0, ai.get()); } - public void testWeakCompareAndSet(){ - AtomicInteger ai = new AtomicInteger(1); - while(!ai.weakCompareAndSet(1,2)); - while(!ai.weakCompareAndSet(2,-4)); - assertEquals(-4,ai.get()); - while(!ai.weakCompareAndSet(-4,7)); - assertEquals(7,ai.get()); - } - - public void testGetAndSet(){ - AtomicInteger ai = new AtomicInteger(1); - assertEquals(1,ai.getAndSet(0)); - assertEquals(0,ai.getAndSet(-10)); - assertEquals(-10,ai.getAndSet(1)); - } - - public void testGetAndAdd(){ - AtomicInteger ai = new AtomicInteger(1); - assertEquals(1,ai.getAndAdd(2)); - assertEquals(3,ai.get()); - assertEquals(3,ai.getAndAdd(-4)); - assertEquals(-1,ai.get()); - } - - public void testGetAndDecrement(){ - AtomicInteger ai = new AtomicInteger(1); - assertEquals(1,ai.getAndDecrement()); - assertEquals(0,ai.getAndDecrement()); - assertEquals(-1,ai.getAndDecrement()); - } - - public void testGetAndIncrement(){ - AtomicInteger ai = new AtomicInteger(1); - assertEquals(1,ai.getAndIncrement()); - assertEquals(2,ai.get()); - ai.set(-2); - assertEquals(-2,ai.getAndIncrement()); - assertEquals(-1,ai.getAndIncrement()); - assertEquals(0,ai.getAndIncrement()); - assertEquals(1,ai.get()); + /** + * get returns the last value set + */ + public void testGetSet() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.get()); + ai.set(2); + assertEquals(2, ai.get()); + ai.set(-3); + assertEquals(-3, ai.get()); + } + + /** + * get returns the last value lazySet in same thread + */ + public void testGetLazySet() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.get()); + ai.lazySet(2); + assertEquals(2, ai.get()); + ai.lazySet(-3); + assertEquals(-3, ai.get()); + } + + /** + * compareAndSet succeeds in changing value if equal to expected else fails + */ + public void testCompareAndSet() { + AtomicInteger ai = new AtomicInteger(1); + assertTrue(ai.compareAndSet(1, 2)); + assertTrue(ai.compareAndSet(2, -4)); + assertEquals(-4, ai.get()); + assertFalse(ai.compareAndSet(-5, 7)); + assertEquals(-4, ai.get()); + assertTrue(ai.compareAndSet(-4, 7)); + assertEquals(7, ai.get()); + } + + /** + * compareAndSet in one thread enables another waiting for value + * to succeed + */ + public void testCompareAndSetInMultipleThreads() throws Exception { + final AtomicInteger ai = new AtomicInteger(1); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!ai.compareAndSet(2, 3)) + Thread.yield(); + }}); + + t.start(); + assertTrue(ai.compareAndSet(1, 2)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertEquals(3, ai.get()); + } + + /** + * repeated weakCompareAndSet succeeds in changing value when equal + * to expected + */ + public void testWeakCompareAndSet() { + AtomicInteger ai = new AtomicInteger(1); + do {} while (!ai.weakCompareAndSet(1, 2)); + do {} while (!ai.weakCompareAndSet(2, -4)); + assertEquals(-4, ai.get()); + do {} while (!ai.weakCompareAndSet(-4, 7)); + assertEquals(7, ai.get()); + } + + /** + * getAndSet returns previous value and sets to given value + */ + public void testGetAndSet() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.getAndSet(0)); + assertEquals(0, ai.getAndSet(-10)); + assertEquals(-10, ai.getAndSet(1)); + } + + /** + * getAndAdd returns previous value and adds given value + */ + public void testGetAndAdd() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.getAndAdd(2)); + assertEquals(3, ai.get()); + assertEquals(3, ai.getAndAdd(-4)); + assertEquals(-1, ai.get()); + } + + /** + * getAndDecrement returns previous value and decrements + */ + public void testGetAndDecrement() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.getAndDecrement()); + assertEquals(0, ai.getAndDecrement()); + assertEquals(-1, ai.getAndDecrement()); + } + + /** + * getAndIncrement returns previous value and increments + */ + public void testGetAndIncrement() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.getAndIncrement()); + assertEquals(2, ai.get()); + ai.set(-2); + assertEquals(-2, ai.getAndIncrement()); + assertEquals(-1, ai.getAndIncrement()); + assertEquals(0, ai.getAndIncrement()); + assertEquals(1, ai.get()); + } + + /** + * addAndGet adds given value to current, and returns current value + */ + public void testAddAndGet() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(3, ai.addAndGet(2)); + assertEquals(3, ai.get()); + assertEquals(-1, ai.addAndGet(-4)); + assertEquals(-1, ai.get()); + } + + /** + * decrementAndGet decrements and returns current value + */ + public void testDecrementAndGet() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(0, ai.decrementAndGet()); + assertEquals(-1, ai.decrementAndGet()); + assertEquals(-2, ai.decrementAndGet()); + assertEquals(-2, ai.get()); + } + + /** + * incrementAndGet increments and returns current value + */ + public void testIncrementAndGet() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(2, ai.incrementAndGet()); + assertEquals(2, ai.get()); + ai.set(-2); + assertEquals(-1, ai.incrementAndGet()); + assertEquals(0, ai.incrementAndGet()); + assertEquals(1, ai.incrementAndGet()); + assertEquals(1, ai.get()); + } + + /** + * a deserialized serialized atomic holds same value + */ + public void testSerialization() throws Exception { + AtomicInteger x = new AtomicInteger(); + AtomicInteger y = serialClone(x); + assertNotSame(x, y); + x.set(22); + AtomicInteger z = serialClone(x); + assertEquals(22, x.get()); + assertEquals(0, y.get()); + assertEquals(22, z.get()); + } + + /** + * toString returns current value. + */ + public void testToString() { + AtomicInteger ai = new AtomicInteger(); + assertEquals("0", ai.toString()); + for (int x : VALUES) { + ai.set(x); + assertEquals(Integer.toString(x), ai.toString()); + } } - public void testAddAndGet(){ - AtomicInteger ai = new AtomicInteger(1); - assertEquals(3,ai.addAndGet(2)); - assertEquals(3,ai.get()); - assertEquals(-1,ai.addAndGet(-4)); - assertEquals(-1,ai.get()); + /** + * intValue returns current value. + */ + public void testIntValue() { + AtomicInteger ai = new AtomicInteger(); + assertEquals(0, ai.intValue()); + for (int x : VALUES) { + ai.set(x); + assertEquals(x, ai.intValue()); + } } - public void testDecrementAndGet(){ - AtomicInteger ai = new AtomicInteger(1); - assertEquals(0,ai.decrementAndGet()); - assertEquals(-1,ai.decrementAndGet()); - assertEquals(-2,ai.decrementAndGet()); - assertEquals(-2,ai.get()); + /** + * longValue returns current value. + */ + public void testLongValue() { + AtomicInteger ai = new AtomicInteger(); + assertEquals(0L, ai.longValue()); + for (int x : VALUES) { + ai.set(x); + assertEquals((long)x, ai.longValue()); + } } - public void testIncrementAndGet(){ - AtomicInteger ai = new AtomicInteger(1); - assertEquals(2,ai.incrementAndGet()); - assertEquals(2,ai.get()); - ai.set(-2); - assertEquals(-1,ai.incrementAndGet()); - assertEquals(0,ai.incrementAndGet()); - assertEquals(1,ai.incrementAndGet()); - assertEquals(1,ai.get()); + /** + * floatValue returns current value. + */ + public void testFloatValue() { + AtomicInteger ai = new AtomicInteger(); + assertEquals(0.0f, ai.floatValue()); + for (int x : VALUES) { + ai.set(x); + assertEquals((float)x, ai.floatValue()); + } } - public void testSerialization() { - AtomicInteger l = new AtomicInteger(); - - try { - l.set(22); - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(l); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - AtomicInteger r = (AtomicInteger) in.readObject(); - assertEquals(l.get(), r.get()); - } catch(Exception e){ - e.printStackTrace(); - fail("unexpected exception"); + /** + * doubleValue returns current value. + */ + public void testDoubleValue() { + AtomicInteger ai = new AtomicInteger(); + assertEquals(0.0d, ai.doubleValue()); + for (int x : VALUES) { + ai.set(x); + assertEquals((double)x, ai.doubleValue()); } } - + // jdk9 + + /** + * getPlain returns the last value set + */ + public void testGetPlainSet() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.getPlain()); + ai.set(2); + assertEquals(2, ai.getPlain()); + ai.set(-3); + assertEquals(-3, ai.getPlain()); + } + + /** + * getOpaque returns the last value set + */ + public void testGetOpaqueSet() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.getOpaque()); + ai.set(2); + assertEquals(2, ai.getOpaque()); + ai.set(-3); + assertEquals(-3, ai.getOpaque()); + } + + /** + * getAcquire returns the last value set + */ + public void testGetAcquireSet() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.getAcquire()); + ai.set(2); + assertEquals(2, ai.getAcquire()); + ai.set(-3); + assertEquals(-3, ai.getAcquire()); + } + + /** + * get returns the last value setPlain + */ + public void testGetSetPlain() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.get()); + ai.setPlain(2); + assertEquals(2, ai.get()); + ai.setPlain(-3); + assertEquals(-3, ai.get()); + } + + /** + * get returns the last value setOpaque + */ + public void testGetSetOpaque() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.get()); + ai.setOpaque(2); + assertEquals(2, ai.get()); + ai.setOpaque(-3); + assertEquals(-3, ai.get()); + } + + /** + * get returns the last value setRelease + */ + public void testGetSetRelease() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.get()); + ai.setRelease(2); + assertEquals(2, ai.get()); + ai.setRelease(-3); + assertEquals(-3, ai.get()); + } + + /** + * compareAndExchange succeeds in changing value if equal to + * expected else fails + */ + public void testCompareAndExchange() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.compareAndExchange(1, 2)); + assertEquals(2, ai.compareAndExchange(2, -4)); + assertEquals(-4, ai.get()); + assertEquals(-4, ai.compareAndExchange(-5, 7)); + assertEquals(-4, ai.get()); + assertEquals(-4, ai.compareAndExchange(-4, 7)); + assertEquals(7, ai.get()); + } + + /** + * compareAndExchangeAcquire succeeds in changing value if equal to + * expected else fails + */ + public void testCompareAndExchangeAcquire() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.compareAndExchangeAcquire(1, 2)); + assertEquals(2, ai.compareAndExchangeAcquire(2, -4)); + assertEquals(-4, ai.get()); + assertEquals(-4, ai.compareAndExchangeAcquire(-5, 7)); + assertEquals(-4, ai.get()); + assertEquals(-4, ai.compareAndExchangeAcquire(-4, 7)); + assertEquals(7, ai.get()); + } + + /** + * compareAndExchangeRelease succeeds in changing value if equal to + * expected else fails + */ + public void testCompareAndExchangeRelease() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1, ai.compareAndExchangeRelease(1, 2)); + assertEquals(2, ai.compareAndExchangeRelease(2, -4)); + assertEquals(-4, ai.get()); + assertEquals(-4, ai.compareAndExchangeRelease(-5, 7)); + assertEquals(-4, ai.get()); + assertEquals(-4, ai.compareAndExchangeRelease(-4, 7)); + assertEquals(7, ai.get()); + } + + /** + * repeated weakCompareAndSetVolatile succeeds in changing value when equal + * to expected + */ + public void testWeakCompareAndSetVolatile() { + AtomicInteger ai = new AtomicInteger(1); + do {} while (!ai.weakCompareAndSetVolatile(1, 2)); + do {} while (!ai.weakCompareAndSetVolatile(2, -4)); + assertEquals(-4, ai.get()); + do {} while (!ai.weakCompareAndSetVolatile(-4, 7)); + assertEquals(7, ai.get()); + } + + /** + * repeated weakCompareAndSetAcquire succeeds in changing value when equal + * to expected + */ + public void testWeakCompareAndSetAcquire() { + AtomicInteger ai = new AtomicInteger(1); + do {} while (!ai.weakCompareAndSetAcquire(1, 2)); + do {} while (!ai.weakCompareAndSetAcquire(2, -4)); + assertEquals(-4, ai.get()); + do {} while (!ai.weakCompareAndSetAcquire(-4, 7)); + assertEquals(7, ai.get()); + } + + /** + * repeated weakCompareAndSetRelease succeeds in changing value when equal + * to expected + */ + public void testWeakCompareAndSetRelease() { + AtomicInteger ai = new AtomicInteger(1); + do {} while (!ai.weakCompareAndSetRelease(1, 2)); + do {} while (!ai.weakCompareAndSetRelease(2, -4)); + assertEquals(-4, ai.get()); + do {} while (!ai.weakCompareAndSetRelease(-4, 7)); + assertEquals(7, ai.get()); + } + + }