FileDocCategorySizeDatePackage
AtomicLongTest.javaAPI DocAndroid 1.5 API7128Wed May 06 22:41:02 BST 2009tests.api.java.util.concurrent

AtomicLongTest

public class AtomicLongTest extends JSR166TestCase

Fields Summary
Constructors Summary
Methods Summary
public static voidmain(java.lang.String[] args)

        junit.textui.TestRunner.run (suite());
    
public static junit.framework.Testsuite()

        return new TestSuite(AtomicLongTest.class);
    
public voidtestAddAndGet()
addAndGet adds given value to current, and returns current value

        AtomicLong ai = new AtomicLong(1);
        assertEquals(3,ai.addAndGet(2));
        assertEquals(3,ai.get());
        assertEquals(-1,ai.addAndGet(-4));
        assertEquals(-1,ai.get());
    
public voidtestCompareAndSet()
compareAndSet succeeds in changing value if equal to expected else fails

        AtomicLong ai = new AtomicLong(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());
    
public voidtestCompareAndSetInMultipleThreads()
compareAndSet in one thread enables another waiting for value to succeed

        final AtomicLong ai = new AtomicLong(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();
        }
    
public voidtestConstructor()
constructor initializes to given value

        AtomicLong ai = new AtomicLong(1);
        assertEquals(1,ai.get());
    
public voidtestConstructor2()
default constructed initializes to zero

        AtomicLong ai = new AtomicLong();
        assertEquals(0,ai.get());
    
public voidtestDecrementAndGet()
decrementAndGet decrements and returns current value

        AtomicLong ai = new AtomicLong(1);
        assertEquals(0,ai.decrementAndGet());
        assertEquals(-1,ai.decrementAndGet());
        assertEquals(-2,ai.decrementAndGet());
        assertEquals(-2,ai.get());
    
public voidtestDoubleValue()
doubleValue returns current value.

        AtomicLong ai = new AtomicLong();
        for (int i = -12; i < 6; ++i) {
            ai.set(i);
            assertEquals((double)i, ai.doubleValue());
        }
    
public voidtestFloatValue()
floatValue returns current value.

        AtomicLong ai = new AtomicLong();
        for (int i = -12; i < 6; ++i) {
            ai.set(i);
            assertEquals((float)i, ai.floatValue());
        }
    
public voidtestGetAndAdd()
getAndAdd returns previous value and adds given value

        AtomicLong ai = new AtomicLong(1);
        assertEquals(1,ai.getAndAdd(2));
        assertEquals(3,ai.get());
        assertEquals(3,ai.getAndAdd(-4));
        assertEquals(-1,ai.get());
    
public voidtestGetAndDecrement()
getAndDecrement returns previous value and decrements

        AtomicLong ai = new AtomicLong(1);
        assertEquals(1,ai.getAndDecrement());
        assertEquals(0,ai.getAndDecrement());
        assertEquals(-1,ai.getAndDecrement());
    
public voidtestGetAndIncrement()
getAndIncrement returns previous value and increments

        AtomicLong ai = new AtomicLong(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());
    
public voidtestGetAndSet()
getAndSet returns previous value and sets to given value

        AtomicLong ai = new AtomicLong(1);
        assertEquals(1,ai.getAndSet(0));
        assertEquals(0,ai.getAndSet(-10));
        assertEquals(-10,ai.getAndSet(1));
    
public voidtestGetSet()
get returns the last value set

        AtomicLong ai = new AtomicLong(1);
        assertEquals(1,ai.get());
        ai.set(2);
        assertEquals(2,ai.get());
        ai.set(-3);
        assertEquals(-3,ai.get());
        
    
public voidtestIncrementAndGet()
incrementAndGet increments and returns current value

        AtomicLong ai = new AtomicLong(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());
    
public voidtestLongValue()
longValue returns current value.

        AtomicLong ai = new AtomicLong();
        for (int i = -12; i < 6; ++i) {
            ai.set(i);
            assertEquals((long)i, ai.longValue());
        }
    
public voidtestSerialization()
a deserialized serialized atomic holds same value

        AtomicLong l = new AtomicLong();

        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));
            AtomicLong r = (AtomicLong) in.readObject();
            assertEquals(l.get(), r.get());
        } catch(Exception e){
            unexpectedException();
        }
    
public voidtestToString()
toString returns current value.

        AtomicLong ai = new AtomicLong();
        for (long i = -12; i < 6; ++i) {
            ai.set(i);
            assertEquals(ai.toString(), Long.toString(i));
        }
    
public voidtestWeakCompareAndSet()
repeated weakCompareAndSet succeeds in changing value when equal to expected

        AtomicLong ai = new AtomicLong(1);
        while(!ai.weakCompareAndSet(1,2));
        while(!ai.weakCompareAndSet(2,-4));
        assertEquals(-4,ai.get());
        while(!ai.weakCompareAndSet(-4,7));
        assertEquals(7,ai.get());