test/tck/DoubleAdderTest.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.DoubleAdder;

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

public class DoubleAdderTest extends JSR166TestCase {
    public static void main(String[] args) {
        main(suite(), args);
    }
    public static Test suite() {
        return new TestSuite(DoubleAdderTest.class);
    }

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

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

    /**
     * reset zeroes sum
     */
    public void testReset() {
        DoubleAdder ai = new DoubleAdder();
        ai.add(2.0);
        assertEquals(2.0, ai.sum());
        ai.reset();
        assertEquals(0.0, ai.sum());
    }

    /**
     * sumThenReset returns sum then zeros
     */
    public void testSumThenReset() {
        DoubleAdder ai = new DoubleAdder();
        ai.add(2.0);
        assertEquals(2.0, ai.sum());
        assertEquals(2.0, ai.sumThenReset());
        assertEquals(0.0, ai.sum());
    }

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

    /**
     * toString returns current value.
     */
    public void testToString() {
        DoubleAdder ai = new DoubleAdder();
        assertEquals(Double.toString(0.0), ai.toString());
        ai.add(1.0);
        assertEquals(Double.toString(1.0), ai.toString());
    }

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

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

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

    /**
     * doubleValue returns current value.
     */
    public void testDoubleValue() {
        DoubleAdder ai = new DoubleAdder();
        assertEquals(0.0, ai.doubleValue());
        ai.add(1.0);
        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();
        DoubleAdder a = new DoubleAdder();
        CyclicBarrier barrier = new CyclicBarrier(nthreads + 1);
        for (int i = 0; i < nthreads; ++i)
            pool.execute(new AdderTask(a, barrier, incs));
        barrier.await();
        barrier.await();
        double total = (long)nthreads * incs;
        double sum = a.sum();
        assertEquals(sum, total);
        pool.shutdown();
    }

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

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

}
Revision:	1.6
Committed:	Sat Apr 25 04:55:30 2015 UTC (9 years ago) by jsr166
Branch:	MAIN
Changes since 1.5:	+1 -1 lines
Log Message:	improve main methods; respect system properties; actually fail if a test fails
#	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.DoubleAdder;
11
12	jsr166	1.5	import junit.framework.Test;
13			import junit.framework.TestSuite;
14
15	dl	1.1	public class DoubleAdderTest extends JSR166TestCase {
16			public static void main(String[] args) {
17	jsr166	1.6	main(suite(), args);
18	dl	1.1	}
19			public static Test suite() {
20			return new TestSuite(DoubleAdderTest.class);
21			}
22
23			/**
24			* default constructed initializes to zero
25			*/
26			public void testConstructor() {
27			DoubleAdder ai = new DoubleAdder();
28			assertEquals(0.0, ai.sum());
29			}
30
31			/**
32			* add adds given value to current, and sum returns current value
33			*/
34			public void testAddAndSum() {
35			DoubleAdder ai = new DoubleAdder();
36			ai.add(2.0);
37			assertEquals(2.0, ai.sum());
38			ai.add(-4.0);
39			assertEquals(-2.0, ai.sum());
40			}
41
42			/**
43			* reset zeroes sum
44			*/
45			public void testReset() {
46			DoubleAdder ai = new DoubleAdder();
47			ai.add(2.0);
48			assertEquals(2.0, ai.sum());
49			ai.reset();
50			assertEquals(0.0, ai.sum());
51			}
52
53			/**
54			* sumThenReset returns sum then zeros
55			*/
56			public void testSumThenReset() {
57			DoubleAdder ai = new DoubleAdder();
58			ai.add(2.0);
59			assertEquals(2.0, ai.sum());
60			assertEquals(2.0, ai.sumThenReset());
61			assertEquals(0.0, ai.sum());
62			}
63
64			/**
65			* a deserialized serialized adder holds same value
66			*/
67			public void testSerialization() throws Exception {
68			DoubleAdder x = new DoubleAdder();
69			DoubleAdder y = serialClone(x);
70	jsr166	1.3	assertNotSame(x, y);
71	dl	1.1	x.add(-22.0);
72			DoubleAdder z = serialClone(x);
73			assertEquals(-22.0, x.sum());
74			assertEquals(0.0, y.sum());
75			assertEquals(-22.0, z.sum());
76			}
77
78			/**
79			* toString returns current value.
80			*/
81			public void testToString() {
82			DoubleAdder ai = new DoubleAdder();
83			assertEquals(Double.toString(0.0), ai.toString());
84			ai.add(1.0);
85			assertEquals(Double.toString(1.0), ai.toString());
86			}
87
88			/**
89			* intValue returns current value.
90			*/
91			public void testIntValue() {
92			DoubleAdder ai = new DoubleAdder();
93			assertEquals(0, ai.intValue());
94			ai.add(1.0);
95			assertEquals(1, ai.intValue());
96			}
97
98			/**
99			* longValue returns current value.
100			*/
101			public void testLongValue() {
102			DoubleAdder ai = new DoubleAdder();
103			assertEquals(0, ai.longValue());
104			ai.add(1.0);
105			assertEquals(1, ai.longValue());
106			}
107
108			/**
109			* floatValue returns current value.
110			*/
111			public void testFloatValue() {
112			DoubleAdder ai = new DoubleAdder();
113			assertEquals(0.0f, ai.floatValue());
114			ai.add(1.0);
115			assertEquals(1.0f, ai.floatValue());
116			}
117
118			/**
119			* doubleValue returns current value.
120			*/
121			public void testDoubleValue() {
122			DoubleAdder ai = new DoubleAdder();
123			assertEquals(0.0, ai.doubleValue());
124			ai.add(1.0);
125			assertEquals(1.0, ai.doubleValue());
126			}
127
128			/**
129			* adds by multiple threads produce correct sum
130			*/
131	jsr166	1.4	public void testAddAndSumMT() throws Throwable {
132	dl	1.1	final int incs = 1000000;
133			final int nthreads = 4;
134			final ExecutorService pool = Executors.newCachedThreadPool();
135			DoubleAdder a = new DoubleAdder();
136	jsr166	1.4	CyclicBarrier barrier = new CyclicBarrier(nthreads + 1);
137	dl	1.1	for (int i = 0; i < nthreads; ++i)
138	jsr166	1.4	pool.execute(new AdderTask(a, barrier, incs));
139			barrier.await();
140			barrier.await();
141	dl	1.1	double total = (long)nthreads * incs;
142			double sum = a.sum();
143			assertEquals(sum, total);
144			pool.shutdown();
145			}
146
147	jsr166	1.2	static final class AdderTask implements Runnable {
148	dl	1.1	final DoubleAdder adder;
149	jsr166	1.4	final CyclicBarrier barrier;
150	dl	1.1	final int incs;
151			volatile double result;
152	jsr166	1.4	AdderTask(DoubleAdder adder, CyclicBarrier barrier, int incs) {
153	jsr166	1.2	this.adder = adder;
154	jsr166	1.4	this.barrier = barrier;
155	dl	1.1	this.incs = incs;
156			}
157
158			public void run() {
159	jsr166	1.4	try {
160			barrier.await();
161			DoubleAdder a = adder;
162			for (int i = 0; i < incs; ++i)
163			a.add(1.0);
164			result = a.sum();
165			barrier.await();
166			} catch (Throwable t) { throw new Error(t); }
167	dl	1.1	}
168			}
169
170			}