test/tck/LongAdderTest.java

/*
 * 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/
 */

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.LongAdder;

import junit.framework.Test;
import junit.framework.TestSuite;

public class LongAdderTest extends JSR166TestCase {
    public static void main(String[] args) {
        junit.textui.TestRunner.run(suite());
    }
    public static Test suite() {
        return new TestSuite(LongAdderTest.class);
    }

    /**
     * default constructed initializes to zero
     */
    public void testConstructor() {
        LongAdder ai = new LongAdder();
        assertEquals(0, ai.sum());
    }

    /**
     * add adds given value to current, and sum returns current value
     */
    public void testAddAndSum() {
        LongAdder ai = new LongAdder();
        ai.add(2);
        assertEquals(2, ai.sum());
        ai.add(-4);
        assertEquals(-2, ai.sum());
    }

    /**
     * decrement decrements and sum returns current value
     */
    public void testDecrementAndsum() {
        LongAdder ai = new LongAdder();
        ai.decrement();
        assertEquals(-1, ai.sum());
        ai.decrement();
        assertEquals(-2, ai.sum());
    }

    /**
     * incrementAndGet increments and returns current value
     */
    public void testIncrementAndsum() {
        LongAdder ai = new LongAdder();
        ai.increment();
        assertEquals(1, ai.sum());
        ai.increment();
        assertEquals(2, ai.sum());
    }

    /**
     * reset zeroes sum
     */
    public void testReset() {
        LongAdder ai = new LongAdder();
        ai.add(2);
        assertEquals(2, ai.sum());
        ai.reset();
        assertEquals(0, ai.sum());
    }

    /**
     * sumThenReset returns sum then zeros
     */
    public void testSumThenReset() {
        LongAdder ai = new LongAdder();
        ai.add(2);
        assertEquals(2, ai.sum());
        assertEquals(2, ai.sumThenReset());
        assertEquals(0, ai.sum());
    }

    /**
     * a deserialized serialized adder holds same value
     */
    public void testSerialization() throws Exception {
        LongAdder x = new LongAdder();
        LongAdder y = serialClone(x);
        assertNotSame(x, y);
        x.add(-22);
        LongAdder z = serialClone(x);
        assertNotSame(y, z);
        assertEquals(-22, x.sum());
        assertEquals(0, y.sum());
        assertEquals(-22, z.sum());
    }

    /**
     * toString returns current value.
     */
    public void testToString() {
        LongAdder ai = new LongAdder();
        assertEquals("0", ai.toString());
        ai.increment();
        assertEquals(Long.toString(1), ai.toString());
    }

    /**
     * intValue returns current value.
     */
    public void testIntValue() {
        LongAdder ai = new LongAdder();
        assertEquals(0, ai.intValue());
        ai.increment();
        assertEquals(1, ai.intValue());
    }

    /**
     * longValue returns current value.
     */
    public void testLongValue() {
        LongAdder ai = new LongAdder();
        assertEquals(0, ai.longValue());
        ai.increment();
        assertEquals(1, ai.longValue());
    }

    /**
     * floatValue returns current value.
     */
    public void testFloatValue() {
        LongAdder ai = new LongAdder();
        assertEquals(0.0f, ai.floatValue());
        ai.increment();
        assertEquals(1.0f, ai.floatValue());
    }

    /**
     * doubleValue returns current value.
     */
    public void testDoubleValue() {
        LongAdder ai = new LongAdder();
        assertEquals(0.0, ai.doubleValue());
        ai.increment();
        assertEquals(1.0, ai.doubleValue());
    }

    /**
     * adds by multiple threads produce correct sum
     */
    public void testAddAndSumMT() throws Throwable {
        final int incs = 1000000;
        final int nthreads = 4;
        final ExecutorService pool = Executors.newCachedThreadPool();
        LongAdder a = new LongAdder();
        CyclicBarrier barrier = new CyclicBarrier(nthreads + 1);
        for (int i = 0; i < nthreads; ++i)
            pool.execute(new AdderTask(a, barrier, incs));
        barrier.await();
        barrier.await();
        long total = (long)nthreads * incs;
        long sum = a.sum();
        assertEquals(sum, total);
        pool.shutdown();
    }

    static final class AdderTask implements Runnable {
        final LongAdder adder;
        final CyclicBarrier barrier;
        final int incs;
        volatile long result;
        AdderTask(LongAdder adder, CyclicBarrier barrier, int incs) {
            this.adder = adder;
            this.barrier = barrier;
            this.incs = incs;
        }

        public void run() {
            try {
                barrier.await();
                LongAdder a = adder;
                for (int i = 0; i < incs; ++i)
                    a.add(1L);
                result = a.sum();
                barrier.await();
            } catch (Throwable t) { throw new Error(t); }
        }
    }

}
Revision:	1.5
Committed:	Wed Dec 31 19:05:43 2014 UTC (9 years, 4 months ago) by jsr166
Branch:	MAIN
Changes since 1.4:	+6 -2 lines
Log Message:	no wildcard imports
#	User	Rev	Content
1	dl	1.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/publicdomain/zero/1.0/
5			*/
6
7	jsr166	1.5	import java.util.concurrent.CyclicBarrier;
8			import java.util.concurrent.Executors;
9			import java.util.concurrent.ExecutorService;
10	dl	1.1	import java.util.concurrent.atomic.LongAdder;
11
12	jsr166	1.5	import junit.framework.Test;
13			import junit.framework.TestSuite;
14
15	dl	1.1	public class LongAdderTest extends JSR166TestCase {
16			public static void main(String[] args) {
17			junit.textui.TestRunner.run(suite());
18			}
19			public static Test suite() {
20			return new TestSuite(LongAdderTest.class);
21			}
22
23			/**
24			* default constructed initializes to zero
25			*/
26			public void testConstructor() {
27			LongAdder ai = new LongAdder();
28			assertEquals(0, ai.sum());
29			}
30
31			/**
32			* add adds given value to current, and sum returns current value
33			*/
34			public void testAddAndSum() {
35			LongAdder ai = new LongAdder();
36			ai.add(2);
37			assertEquals(2, ai.sum());
38			ai.add(-4);
39			assertEquals(-2, ai.sum());
40			}
41
42			/**
43			* decrement decrements and sum returns current value
44			*/
45			public void testDecrementAndsum() {
46			LongAdder ai = new LongAdder();
47			ai.decrement();
48			assertEquals(-1, ai.sum());
49			ai.decrement();
50			assertEquals(-2, ai.sum());
51			}
52
53			/**
54			* incrementAndGet increments and returns current value
55			*/
56			public void testIncrementAndsum() {
57			LongAdder ai = new LongAdder();
58			ai.increment();
59			assertEquals(1, ai.sum());
60			ai.increment();
61			assertEquals(2, ai.sum());
62			}
63
64			/**
65			* reset zeroes sum
66			*/
67			public void testReset() {
68			LongAdder ai = new LongAdder();
69			ai.add(2);
70			assertEquals(2, ai.sum());
71			ai.reset();
72			assertEquals(0, ai.sum());
73			}
74
75			/**
76			* sumThenReset returns sum then zeros
77			*/
78			public void testSumThenReset() {
79			LongAdder ai = new LongAdder();
80			ai.add(2);
81			assertEquals(2, ai.sum());
82			assertEquals(2, ai.sumThenReset());
83			assertEquals(0, ai.sum());
84			}
85
86			/**
87			* a deserialized serialized adder holds same value
88			*/
89			public void testSerialization() throws Exception {
90			LongAdder x = new LongAdder();
91			LongAdder y = serialClone(x);
92	jsr166	1.3	assertNotSame(x, y);
93	dl	1.1	x.add(-22);
94			LongAdder z = serialClone(x);
95	jsr166	1.3	assertNotSame(y, z);
96	dl	1.1	assertEquals(-22, x.sum());
97			assertEquals(0, y.sum());
98			assertEquals(-22, z.sum());
99			}
100
101			/**
102			* toString returns current value.
103			*/
104			public void testToString() {
105			LongAdder ai = new LongAdder();
106			assertEquals("0", ai.toString());
107			ai.increment();
108			assertEquals(Long.toString(1), ai.toString());
109			}
110
111			/**
112			* intValue returns current value.
113			*/
114			public void testIntValue() {
115			LongAdder ai = new LongAdder();
116			assertEquals(0, ai.intValue());
117			ai.increment();
118			assertEquals(1, ai.intValue());
119			}
120
121			/**
122			* longValue returns current value.
123			*/
124			public void testLongValue() {
125			LongAdder ai = new LongAdder();
126			assertEquals(0, ai.longValue());
127			ai.increment();
128			assertEquals(1, ai.longValue());
129			}
130
131			/**
132			* floatValue returns current value.
133			*/
134			public void testFloatValue() {
135			LongAdder ai = new LongAdder();
136			assertEquals(0.0f, ai.floatValue());
137			ai.increment();
138			assertEquals(1.0f, ai.floatValue());
139			}
140
141			/**
142			* doubleValue returns current value.
143			*/
144			public void testDoubleValue() {
145			LongAdder ai = new LongAdder();
146			assertEquals(0.0, ai.doubleValue());
147			ai.increment();
148			assertEquals(1.0, ai.doubleValue());
149			}
150
151			/**
152			* adds by multiple threads produce correct sum
153			*/
154	jsr166	1.4	public void testAddAndSumMT() throws Throwable {
155	dl	1.1	final int incs = 1000000;
156			final int nthreads = 4;
157			final ExecutorService pool = Executors.newCachedThreadPool();
158			LongAdder a = new LongAdder();
159	jsr166	1.4	CyclicBarrier barrier = new CyclicBarrier(nthreads + 1);
160	dl	1.1	for (int i = 0; i < nthreads; ++i)
161	jsr166	1.4	pool.execute(new AdderTask(a, barrier, incs));
162			barrier.await();
163			barrier.await();
164	dl	1.1	long total = (long)nthreads * incs;
165			long sum = a.sum();
166			assertEquals(sum, total);
167			pool.shutdown();
168			}
169
170	jsr166	1.2	static final class AdderTask implements Runnable {
171	dl	1.1	final LongAdder adder;
172	jsr166	1.4	final CyclicBarrier barrier;
173	dl	1.1	final int incs;
174			volatile long result;
175	jsr166	1.4	AdderTask(LongAdder adder, CyclicBarrier barrier, int incs) {
176	jsr166	1.2	this.adder = adder;
177	jsr166	1.4	this.barrier = barrier;
178	dl	1.1	this.incs = incs;
179			}
180
181			public void run() {
182	jsr166	1.4	try {
183			barrier.await();
184			LongAdder a = adder;
185			for (int i = 0; i < incs; ++i)
186			a.add(1L);
187			result = a.sum();
188			barrier.await();
189			} catch (Throwable t) { throw new Error(t); }
190	dl	1.1	}
191			}
192
193			}