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 java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Phaser;
import java.util.concurrent.atomic.LongAccumulator;

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

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