test/tck/LongAccumulatorTest.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.LongAccumulator;

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

    /**
     * default constructed initializes to zero
     */
    public void testConstructor() {
        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
        assertEquals(0, ai.get());
    }

    /**
     * accumulate accumulates given value to current, and get returns current value
     */
    public void testAccumulateAndGet() {
        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
        ai.accumulate(2);
        assertEquals(2, ai.get());
        ai.accumulate(-4);
        assertEquals(2, ai.get());
        ai.accumulate(4);
        assertEquals(4, ai.get());
    }

    /**
     * reset zeroes get
     */
    public void testReset() {
        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
        ai.accumulate(2);
        assertEquals(2, ai.get());
        ai.reset();
        assertEquals(0, ai.get());
    }

    /**
     * getThenReset returns get then zeros
     */
    public void testGetThenReset() {
        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
        ai.accumulate(2);
        assertEquals(2, ai.get());
        assertEquals(2, ai.getThenReset());
        assertEquals(0, ai.get());
    }

    /**
     * toString returns current value.
     */
    public void testToString() {
        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
        assertEquals("0", ai.toString());
        ai.accumulate(1);
        assertEquals(Long.toString(1), ai.toString());
    }

    /**
     * intValue returns current value.
     */
    public void testIntValue() {
        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
        assertEquals(0, ai.intValue());
        ai.accumulate(1);
        assertEquals(1, ai.intValue());
    }

    /**
     * longValue returns current value.
     */
    public void testLongValue() {
        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
        assertEquals(0, ai.longValue());
        ai.accumulate(1);
        assertEquals(1, ai.longValue());
    }

    /**
     * floatValue returns current value.
     */
    public void testFloatValue() {
        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
        assertEquals(0.0f, ai.floatValue());
        ai.accumulate(1);
        assertEquals(1.0f, ai.floatValue());
    }

    /**
     * doubleValue returns current value.
     */
    public void testDoubleValue() {
        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
        assertEquals(0.0, ai.doubleValue());
        ai.accumulate(1);
        assertEquals(1.0, ai.doubleValue());
    }

    /**
     * accumulates by multiple threads produce correct result
     */
    public void testAccumulateAndGetMT() {
        final int incs = 1000000;
        final int nthreads = 4;
        final ExecutorService pool = Executors.newCachedThreadPool();
        LongAccumulator a = new LongAccumulator(Long::max, 0L);
        Phaser phaser = new Phaser(nthreads + 1);
        for (int i = 0; i < nthreads; ++i)
            pool.execute(new AccTask(a, phaser, incs));
        phaser.arriveAndAwaitAdvance();
        phaser.arriveAndAwaitAdvance();
        long expected = incs - 1;
        long result = a.get();
        assertEquals(expected, result);
        pool.shutdown();
    }

    static final class AccTask implements Runnable {
        final LongAccumulator acc;
        final Phaser phaser;
        final int incs;
        volatile long result;
        AccTask(LongAccumulator acc, Phaser phaser, int incs) {
            this.acc = acc;
            this.phaser = phaser;
            this.incs = incs;
        }

        public void run() {
            phaser.arriveAndAwaitAdvance();
            LongAccumulator a = acc;
            for (int i = 0; i < incs; ++i)
                a.accumulate(i);
            result = a.get();
            phaser.arrive();
        }
    }

}
Revision:	1.3
Committed:	Fri Mar 22 16:10:19 2013 UTC (11 years, 1 month ago) by jsr166
Branch:	MAIN
Changes since 1.2:	+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.LongAccumulator;
10
11			public class LongAccumulatorTest 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(LongAccumulatorTest.class);
17			}
18
19			/**
20			* default constructed initializes to zero
21			*/
22			public void testConstructor() {
23			LongAccumulator ai = new LongAccumulator(Long::max, 0L);
24			assertEquals(0, ai.get());
25			}
26
27			/**
28			* accumulate accumulates given value to current, and get returns current value
29			*/
30			public void testAccumulateAndGet() {
31			LongAccumulator ai = new LongAccumulator(Long::max, 0L);
32			ai.accumulate(2);
33			assertEquals(2, ai.get());
34			ai.accumulate(-4);
35			assertEquals(2, ai.get());
36			ai.accumulate(4);
37			assertEquals(4, ai.get());
38			}
39
40			/**
41			* reset zeroes get
42			*/
43			public void testReset() {
44			LongAccumulator ai = new LongAccumulator(Long::max, 0L);
45			ai.accumulate(2);
46			assertEquals(2, ai.get());
47			ai.reset();
48			assertEquals(0, ai.get());
49			}
50
51			/**
52			* getThenReset returns get then zeros
53			*/
54			public void testGetThenReset() {
55			LongAccumulator ai = new LongAccumulator(Long::max, 0L);
56			ai.accumulate(2);
57			assertEquals(2, ai.get());
58			assertEquals(2, ai.getThenReset());
59			assertEquals(0, ai.get());
60			}
61
62			/**
63			* toString returns current value.
64			*/
65			public void testToString() {
66			LongAccumulator ai = new LongAccumulator(Long::max, 0L);
67			assertEquals("0", ai.toString());
68			ai.accumulate(1);
69			assertEquals(Long.toString(1), ai.toString());
70			}
71
72			/**
73			* intValue returns current value.
74			*/
75			public void testIntValue() {
76			LongAccumulator ai = new LongAccumulator(Long::max, 0L);
77			assertEquals(0, ai.intValue());
78			ai.accumulate(1);
79			assertEquals(1, ai.intValue());
80			}
81
82			/**
83			* longValue returns current value.
84			*/
85			public void testLongValue() {
86			LongAccumulator ai = new LongAccumulator(Long::max, 0L);
87			assertEquals(0, ai.longValue());
88			ai.accumulate(1);
89			assertEquals(1, ai.longValue());
90			}
91
92			/**
93			* floatValue returns current value.
94			*/
95			public void testFloatValue() {
96			LongAccumulator ai = new LongAccumulator(Long::max, 0L);
97			assertEquals(0.0f, ai.floatValue());
98			ai.accumulate(1);
99			assertEquals(1.0f, ai.floatValue());
100			}
101
102			/**
103			* doubleValue returns current value.
104			*/
105			public void testDoubleValue() {
106			LongAccumulator ai = new LongAccumulator(Long::max, 0L);
107			assertEquals(0.0, ai.doubleValue());
108			ai.accumulate(1);
109			assertEquals(1.0, ai.doubleValue());
110			}
111
112			/**
113			* accumulates by multiple threads produce correct result
114			*/
115			public void testAccumulateAndGetMT() {
116			final int incs = 1000000;
117			final int nthreads = 4;
118			final ExecutorService pool = Executors.newCachedThreadPool();
119			LongAccumulator a = new LongAccumulator(Long::max, 0L);
120			Phaser phaser = new Phaser(nthreads + 1);
121			for (int i = 0; i < nthreads; ++i)
122	dl	1.2	pool.execute(new AccTask(a, phaser, incs));
123	dl	1.1	phaser.arriveAndAwaitAdvance();
124			phaser.arriveAndAwaitAdvance();
125			long expected = incs - 1;
126			long result = a.get();
127			assertEquals(expected, result);
128			pool.shutdown();
129			}
130
131	jsr166	1.3	static final class AccTask implements Runnable {
132	dl	1.2	final LongAccumulator acc;
133	dl	1.1	final Phaser phaser;
134			final int incs;
135			volatile long result;
136	jsr166	1.3	AccTask(LongAccumulator acc, Phaser phaser, int incs) {
137			this.acc = acc;
138	dl	1.1	this.phaser = phaser;
139			this.incs = incs;
140			}
141
142			public void run() {
143			phaser.arriveAndAwaitAdvance();
144	dl	1.2	LongAccumulator a = acc;
145	dl	1.1	for (int i = 0; i < incs; ++i)
146			a.accumulate(i);
147			result = a.get();
148			phaser.arrive();
149			}
150			}
151
152			}