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 junit.framework.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.DoubleAdder;

public class DoubleAdderTest extends JSR166TestCase {
    public static void main(String[] args) {
        junit.textui.TestRunner.run(suite());
    }
    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);
        assertTrue(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() {
        final int incs = 1000000;
        final int nthreads = 4;
        final ExecutorService pool = Executors.newCachedThreadPool();
        DoubleAdder a = new DoubleAdder();
        Phaser phaser = new Phaser(nthreads + 1);
        for (int i = 0; i < nthreads; ++i)
            pool.execute(new AdderTask(a, phaser, incs));
        phaser.arriveAndAwaitAdvance();
        phaser.arriveAndAwaitAdvance();
        double total = (long)nthreads * incs;
        double sum = a.sum();
        assertEquals(sum, total);
        pool.shutdown();
    }

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

        public void run() {
            phaser.arriveAndAwaitAdvance();
            DoubleAdder a = adder;
            for (int i = 0; i < incs; ++i)
                a.add(1.0);
            result = a.sum();
            phaser.arrive();
        }
    }

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