--- jsr166/src/test/tck/AtomicIntegerTest.java 2003/08/31 19:24:53 1.1 +++ jsr166/src/test/tck/AtomicIntegerTest.java 2009/11/02 20:28:31 1.12 @@ -1,14 +1,16 @@ /* - * 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/licenses/publicdomain + * 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 class AtomicIntegerTest extends JSR166TestCase { public static void main (String[] args) { junit.textui.TestRunner.run (suite()); } @@ -16,16 +18,25 @@ public class AtomicIntegerTest extends T return new TestSuite(AtomicIntegerTest.class); } + /** + * 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()); } + /** + * get returns the last value set + */ public void testGetSet(){ AtomicInteger ai = new AtomicInteger(1); assertEquals(1,ai.get()); @@ -33,8 +44,24 @@ public class AtomicIntegerTest extends T 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)); @@ -46,6 +73,32 @@ public class AtomicIntegerTest extends T assertEquals(7,ai.get()); } + /** + * compareAndSet in one thread enables another waiting for value + * to succeed + */ + public void testCompareAndSetInMultipleThreads() { + final AtomicInteger ai = new AtomicInteger(1); + Thread t = new Thread(new Runnable() { + public void run() { + while(!ai.compareAndSet(2, 3)) Thread.yield(); + }}); + try { + t.start(); + assertTrue(ai.compareAndSet(1, 2)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertEquals(ai.get(), 3); + } + catch(Exception e) { + unexpectedException(); + } + } + + /** + * repeated weakCompareAndSet succeeds in changing value when equal + * to expected + */ public void testWeakCompareAndSet(){ AtomicInteger ai = new AtomicInteger(1); while(!ai.weakCompareAndSet(1,2)); @@ -55,6 +108,9 @@ public class AtomicIntegerTest extends T 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)); @@ -62,6 +118,9 @@ public class AtomicIntegerTest extends T 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)); @@ -70,6 +129,9 @@ public class AtomicIntegerTest extends T assertEquals(-1,ai.get()); } + /** + * getAndDecrement returns previous value and decrements + */ public void testGetAndDecrement(){ AtomicInteger ai = new AtomicInteger(1); assertEquals(1,ai.getAndDecrement()); @@ -77,6 +139,9 @@ public class AtomicIntegerTest extends T assertEquals(-1,ai.getAndDecrement()); } + /** + * getAndIncrement returns previous value and increments + */ public void testGetAndIncrement(){ AtomicInteger ai = new AtomicInteger(1); assertEquals(1,ai.getAndIncrement()); @@ -88,6 +153,9 @@ public class AtomicIntegerTest extends T 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)); @@ -96,6 +164,9 @@ public class AtomicIntegerTest extends T assertEquals(-1,ai.get()); } + /** + * decrementAndGet decrements and returns current value + */ public void testDecrementAndGet(){ AtomicInteger ai = new AtomicInteger(1); assertEquals(0,ai.decrementAndGet()); @@ -104,6 +175,9 @@ public class AtomicIntegerTest extends T assertEquals(-2,ai.get()); } + /** + * incrementAndGet increments and returns current value + */ public void testIncrementAndGet(){ AtomicInteger ai = new AtomicInteger(1); assertEquals(2,ai.incrementAndGet()); @@ -115,5 +189,84 @@ public class AtomicIntegerTest extends T assertEquals(1,ai.get()); } + /** + * a deserialized serialized atomic holds same value + */ + 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){ + unexpectedException(); + } + } + + /** + * toString returns current value. + */ + public void testToString() { + AtomicInteger ai = new AtomicInteger(); + for (int i = -12; i < 6; ++i) { + ai.set(i); + assertEquals(ai.toString(), Integer.toString(i)); + } + } + + /** + * intValue returns current value. + */ + public void testIntValue() { + AtomicInteger ai = new AtomicInteger(); + for (int i = -12; i < 6; ++i) { + ai.set(i); + assertEquals(i, ai.intValue()); + } + } + + + /** + * longValue returns current value. + */ + public void testLongValue() { + AtomicInteger ai = new AtomicInteger(); + for (int i = -12; i < 6; ++i) { + ai.set(i); + assertEquals((long)i, ai.longValue()); + } + } + + /** + * floatValue returns current value. + */ + public void testFloatValue() { + AtomicInteger ai = new AtomicInteger(); + for (int i = -12; i < 6; ++i) { + ai.set(i); + assertEquals((float)i, ai.floatValue()); + } + } + + /** + * doubleValue returns current value. + */ + public void testDoubleValue() { + AtomicInteger ai = new AtomicInteger(); + for (int i = -12; i < 6; ++i) { + ai.set(i); + assertEquals((double)i, ai.doubleValue()); + } + } + + }