ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/LongAccumulatorTest.java
(Generate patch)

Comparing jsr166/src/test/tck/LongAccumulatorTest.java (file contents):
Revision 1.2 by dl, Thu Mar 21 00:26:43 2013 UTC vs.
Revision 1.8 by jsr166, Sun Apr 23 03:14:10 2017 UTC

# Line 4 | Line 4
4   * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7 < import junit.framework.*;
8 < import java.util.concurrent.*;
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 <        junit.textui.TestRunner.run(suite());
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
24 >     * new instance initialized to supplied identity
25       */
26      public void testConstructor() {
27 <        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
28 <        assertEquals(0, ai.get());
27 >        for (long identity : new long[] { Long.MIN_VALUE, 0, Long.MAX_VALUE })
28 >            assertEquals(identity,
29 >                         new LongAccumulator(Long::max, identity).get());
30      }
31  
32      /**
33       * accumulate accumulates given value to current, and get returns current value
34       */
35      public void testAccumulateAndGet() {
36 <        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
37 <        ai.accumulate(2);
38 <        assertEquals(2, ai.get());
39 <        ai.accumulate(-4);
40 <        assertEquals(2, ai.get());
41 <        ai.accumulate(4);
42 <        assertEquals(4, ai.get());
36 >        LongAccumulator acc = new LongAccumulator(Long::max, 0L);
37 >        acc.accumulate(2);
38 >        assertEquals(2, acc.get());
39 >        acc.accumulate(-4);
40 >        assertEquals(2, acc.get());
41 >        acc.accumulate(4);
42 >        assertEquals(4, acc.get());
43      }
44  
45      /**
46 <     * reset zeroes get
46 >     * reset() causes subsequent get() to return zero
47       */
48      public void testReset() {
49 <        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
50 <        ai.accumulate(2);
51 <        assertEquals(2, ai.get());
52 <        ai.reset();
53 <        assertEquals(0, ai.get());
49 >        LongAccumulator acc = new LongAccumulator(Long::max, 0L);
50 >        acc.accumulate(2);
51 >        assertEquals(2, acc.get());
52 >        acc.reset();
53 >        assertEquals(0, acc.get());
54      }
55  
56      /**
57 <     * getThenReset returns get then zeros
57 >     * getThenReset() returns current value; subsequent get() returns zero
58       */
59      public void testGetThenReset() {
60 <        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
61 <        ai.accumulate(2);
62 <        assertEquals(2, ai.get());
63 <        assertEquals(2, ai.getThenReset());
64 <        assertEquals(0, ai.get());
60 >        LongAccumulator acc = new LongAccumulator(Long::max, 0L);
61 >        acc.accumulate(2);
62 >        assertEquals(2, acc.get());
63 >        assertEquals(2, acc.getThenReset());
64 >        assertEquals(0, acc.get());
65      }
66  
67      /**
68       * toString returns current value.
69       */
70      public void testToString() {
71 <        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
72 <        assertEquals("0", ai.toString());
73 <        ai.accumulate(1);
74 <        assertEquals(Long.toString(1), ai.toString());
71 >        LongAccumulator acc = new LongAccumulator(Long::max, 0L);
72 >        assertEquals("0", acc.toString());
73 >        acc.accumulate(1);
74 >        assertEquals(Long.toString(1), acc.toString());
75      }
76  
77      /**
78       * intValue returns current value.
79       */
80      public void testIntValue() {
81 <        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
82 <        assertEquals(0, ai.intValue());
83 <        ai.accumulate(1);
84 <        assertEquals(1, ai.intValue());
81 >        LongAccumulator acc = new LongAccumulator(Long::max, 0L);
82 >        assertEquals(0, acc.intValue());
83 >        acc.accumulate(1);
84 >        assertEquals(1, acc.intValue());
85      }
86  
87      /**
88       * longValue returns current value.
89       */
90      public void testLongValue() {
91 <        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
92 <        assertEquals(0, ai.longValue());
93 <        ai.accumulate(1);
94 <        assertEquals(1, ai.longValue());
91 >        LongAccumulator acc = new LongAccumulator(Long::max, 0L);
92 >        assertEquals(0, acc.longValue());
93 >        acc.accumulate(1);
94 >        assertEquals(1, acc.longValue());
95      }
96  
97      /**
98       * floatValue returns current value.
99       */
100      public void testFloatValue() {
101 <        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
102 <        assertEquals(0.0f, ai.floatValue());
103 <        ai.accumulate(1);
104 <        assertEquals(1.0f, ai.floatValue());
101 >        LongAccumulator acc = new LongAccumulator(Long::max, 0L);
102 >        assertEquals(0.0f, acc.floatValue());
103 >        acc.accumulate(1);
104 >        assertEquals(1.0f, acc.floatValue());
105      }
106  
107      /**
108       * doubleValue returns current value.
109       */
110      public void testDoubleValue() {
111 <        LongAccumulator ai = new LongAccumulator(Long::max, 0L);
112 <        assertEquals(0.0, ai.doubleValue());
113 <        ai.accumulate(1);
114 <        assertEquals(1.0, ai.doubleValue());
111 >        LongAccumulator acc = new LongAccumulator(Long::max, 0L);
112 >        assertEquals(0.0, acc.doubleValue());
113 >        acc.accumulate(1);
114 >        assertEquals(1.0, acc.doubleValue());
115      }
116  
117      /**
# Line 128 | Line 133 | public class LongAccumulatorTest extends
133          pool.shutdown();
134      }
135  
136 <   static final class AccTask implements Runnable {
136 >    static final class AccTask implements Runnable {
137          final LongAccumulator acc;
138          final Phaser phaser;
139          final int incs;
140          volatile long result;
141 <        AccTask(LongAccumulator acc, Phaser phaser, int incs) {
142 <            this.acc = acc;
141 >        AccTask(LongAccumulator acc, Phaser phaser, int incs) {
142 >            this.acc = acc;
143              this.phaser = phaser;
144              this.incs = incs;
145          }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines