[cvs] / jsr166 / src / test / tck / AtomicIntegerArrayTest.java Repository:
ViewVC logotype

Annotation of /jsr166/src/test/tck/AtomicIntegerArrayTest.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.23 - (view) (download)

1 : dl 1.1 /*
2 : dl 1.6 * 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 : jsr166 1.20 * http://creativecommons.org/publicdomain/zero/1.0/
5 : jsr166 1.11 * Other contributors include Andrew Wright, Jeffrey Hayes,
6 :     * Pat Fisher, Mike Judd.
7 : dl 1.1 */
8 :    
9 :     import junit.framework.*;
10 : jsr166 1.22 import java.util.Arrays;
11 :     import java.util.concurrent.atomic.AtomicIntegerArray;
12 : dl 1.1
13 : dl 1.3 public class AtomicIntegerArrayTest extends JSR166TestCase {
14 : dl 1.1
15 : jsr166 1.17 public static void main(String[] args) {
16 :     junit.textui.TestRunner.run(suite());
17 : dl 1.1 }
18 :     public static Test suite() {
19 :     return new TestSuite(AtomicIntegerArrayTest.class);
20 :     }
21 :    
22 : dl 1.4 /**
23 : dl 1.5 * constructor creates array of given size with all elements zero
24 : dl 1.4 */
25 :     public void testConstructor() {
26 : dl 1.3 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
27 : jsr166 1.11 for (int i = 0; i < SIZE; ++i)
28 : dl 1.1 assertEquals(0,ai.get(i));
29 :     }
30 :    
31 : dl 1.4 /**
32 : dl 1.7 * constructor with null array throws NPE
33 :     */
34 :     public void testConstructor2NPE() {
35 :     try {
36 :     int[] a = null;
37 :     AtomicIntegerArray ai = new AtomicIntegerArray(a);
38 : jsr166 1.14 shouldThrow();
39 :     } catch (NullPointerException success) {}
40 : dl 1.7 }
41 :    
42 :     /**
43 :     * constructor with array is of same size and has all elements
44 :     */
45 :     public void testConstructor2() {
46 : jsr166 1.23 int[] a = { 17, 3, -42, 99, -7 };
47 : dl 1.7 AtomicIntegerArray ai = new AtomicIntegerArray(a);
48 :     assertEquals(a.length, ai.length());
49 : jsr166 1.11 for (int i = 0; i < a.length; ++i)
50 : dl 1.7 assertEquals(a[i], ai.get(i));
51 :     }
52 :    
53 :     /**
54 : dl 1.5 * get and set for out of bound indices throw IndexOutOfBoundsException
55 :     */
56 : jsr166 1.13 public void testIndexing() {
57 : dl 1.5 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
58 :     try {
59 :     ai.get(SIZE);
60 : jsr166 1.14 shouldThrow();
61 : jsr166 1.13 } catch (IndexOutOfBoundsException success) {
62 : dl 1.5 }
63 :     try {
64 :     ai.get(-1);
65 : jsr166 1.14 shouldThrow();
66 : jsr166 1.13 } catch (IndexOutOfBoundsException success) {
67 : dl 1.5 }
68 :     try {
69 :     ai.set(SIZE, 0);
70 : jsr166 1.14 shouldThrow();
71 : jsr166 1.13 } catch (IndexOutOfBoundsException success) {
72 : dl 1.5 }
73 :     try {
74 :     ai.set(-1, 0);
75 : jsr166 1.14 shouldThrow();
76 : jsr166 1.13 } catch (IndexOutOfBoundsException success) {
77 : dl 1.5 }
78 :     }
79 :    
80 :     /**
81 :     * get returns the last value set at index
82 : dl 1.4 */
83 :     public void testGetSet() {
84 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
85 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
86 : dl 1.1 ai.set(i, 1);
87 :     assertEquals(1,ai.get(i));
88 :     ai.set(i, 2);
89 :     assertEquals(2,ai.get(i));
90 :     ai.set(i, -3);
91 :     assertEquals(-3,ai.get(i));
92 :     }
93 :     }
94 :    
95 : dl 1.4 /**
96 : dl 1.10 * get returns the last value lazySet at index by same thread
97 :     */
98 :     public void testGetLazySet() {
99 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
100 : dl 1.10 for (int i = 0; i < SIZE; ++i) {
101 :     ai.lazySet(i, 1);
102 :     assertEquals(1,ai.get(i));
103 :     ai.lazySet(i, 2);
104 :     assertEquals(2,ai.get(i));
105 :     ai.lazySet(i, -3);
106 :     assertEquals(-3,ai.get(i));
107 :     }
108 :     }
109 :    
110 :     /**
111 : dl 1.5 * compareAndSet succeeds in changing value if equal to expected else fails
112 : dl 1.4 */
113 :     public void testCompareAndSet() {
114 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
115 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
116 : dl 1.1 ai.set(i, 1);
117 :     assertTrue(ai.compareAndSet(i, 1,2));
118 :     assertTrue(ai.compareAndSet(i, 2,-4));
119 :     assertEquals(-4,ai.get(i));
120 :     assertFalse(ai.compareAndSet(i, -5,7));
121 : jsr166 1.16 assertEquals(-4,ai.get(i));
122 : dl 1.1 assertTrue(ai.compareAndSet(i, -4,7));
123 :     assertEquals(7,ai.get(i));
124 :     }
125 :     }
126 :    
127 : dl 1.4 /**
128 : dl 1.5 * compareAndSet in one thread enables another waiting for value
129 :     * to succeed
130 :     */
131 : jsr166 1.14 public void testCompareAndSetInMultipleThreads() throws Exception {
132 : dl 1.5 final AtomicIntegerArray a = new AtomicIntegerArray(1);
133 :     a.set(0, 1);
134 : jsr166 1.15 Thread t = new Thread(new CheckedRunnable() {
135 :     public void realRun() {
136 :     while (!a.compareAndSet(0, 2, 3))
137 :     Thread.yield();
138 :     }});
139 : jsr166 1.14
140 :     t.start();
141 :     assertTrue(a.compareAndSet(0, 1, 2));
142 :     t.join(LONG_DELAY_MS);
143 :     assertFalse(t.isAlive());
144 :     assertEquals(a.get(0), 3);
145 : dl 1.5 }
146 :    
147 :     /**
148 :     * repeated weakCompareAndSet succeeds in changing value when equal
149 : jsr166 1.11 * to expected
150 : dl 1.4 */
151 :     public void testWeakCompareAndSet() {
152 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
153 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
154 : dl 1.1 ai.set(i, 1);
155 : jsr166 1.12 while (!ai.weakCompareAndSet(i, 1,2));
156 :     while (!ai.weakCompareAndSet(i, 2,-4));
157 : dl 1.1 assertEquals(-4,ai.get(i));
158 : jsr166 1.12 while (!ai.weakCompareAndSet(i, -4,7));
159 : dl 1.1 assertEquals(7,ai.get(i));
160 :     }
161 :     }
162 :    
163 : dl 1.4 /**
164 : jsr166 1.19 * getAndSet returns previous value and sets to given value at given index
165 : dl 1.4 */
166 :     public void testGetAndSet() {
167 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
168 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
169 : dl 1.1 ai.set(i, 1);
170 :     assertEquals(1,ai.getAndSet(i,0));
171 :     assertEquals(0,ai.getAndSet(i,-10));
172 :     assertEquals(-10,ai.getAndSet(i,1));
173 :     }
174 :     }
175 :    
176 : dl 1.4 /**
177 : jsr166 1.19 * getAndAdd returns previous value and adds given value
178 : dl 1.4 */
179 :     public void testGetAndAdd() {
180 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
181 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
182 : dl 1.1 ai.set(i, 1);
183 :     assertEquals(1,ai.getAndAdd(i,2));
184 :     assertEquals(3,ai.get(i));
185 :     assertEquals(3,ai.getAndAdd(i,-4));
186 :     assertEquals(-1,ai.get(i));
187 :     }
188 :     }
189 :    
190 : dl 1.4 /**
191 : dl 1.5 * getAndDecrement returns previous value and decrements
192 : dl 1.4 */
193 :     public void testGetAndDecrement() {
194 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
195 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
196 : dl 1.1 ai.set(i, 1);
197 :     assertEquals(1,ai.getAndDecrement(i));
198 :     assertEquals(0,ai.getAndDecrement(i));
199 :     assertEquals(-1,ai.getAndDecrement(i));
200 :     }
201 :     }
202 :    
203 : dl 1.4 /**
204 : dl 1.5 * getAndIncrement returns previous value and increments
205 : dl 1.4 */
206 :     public void testGetAndIncrement() {
207 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
208 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
209 : dl 1.1 ai.set(i, 1);
210 :     assertEquals(1,ai.getAndIncrement(i));
211 :     assertEquals(2,ai.get(i));
212 :     ai.set(i,-2);
213 :     assertEquals(-2,ai.getAndIncrement(i));
214 :     assertEquals(-1,ai.getAndIncrement(i));
215 :     assertEquals(0,ai.getAndIncrement(i));
216 :     assertEquals(1,ai.get(i));
217 :     }
218 :     }
219 :    
220 : dl 1.4 /**
221 : jsr166 1.19 * addAndGet adds given value to current, and returns current value
222 : dl 1.4 */
223 : dl 1.1 public void testAddAndGet() {
224 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
225 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
226 : dl 1.1 ai.set(i, 1);
227 :     assertEquals(3,ai.addAndGet(i,2));
228 :     assertEquals(3,ai.get(i));
229 :     assertEquals(-1,ai.addAndGet(i,-4));
230 :     assertEquals(-1,ai.get(i));
231 :     }
232 :     }
233 :    
234 : dl 1.4 /**
235 : dl 1.5 * decrementAndGet decrements and returns current value
236 : dl 1.4 */
237 :     public void testDecrementAndGet() {
238 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
239 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
240 : dl 1.1 ai.set(i, 1);
241 :     assertEquals(0,ai.decrementAndGet(i));
242 :     assertEquals(-1,ai.decrementAndGet(i));
243 :     assertEquals(-2,ai.decrementAndGet(i));
244 :     assertEquals(-2,ai.get(i));
245 :     }
246 :     }
247 :    
248 : dl 1.4 /**
249 : jsr166 1.19 * incrementAndGet increments and returns current value
250 : dl 1.4 */
251 : dl 1.1 public void testIncrementAndGet() {
252 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
253 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
254 : dl 1.1 ai.set(i, 1);
255 :     assertEquals(2,ai.incrementAndGet(i));
256 :     assertEquals(2,ai.get(i));
257 :     ai.set(i, -2);
258 :     assertEquals(-1,ai.incrementAndGet(i));
259 :     assertEquals(0,ai.incrementAndGet(i));
260 :     assertEquals(1,ai.incrementAndGet(i));
261 :     assertEquals(1,ai.get(i));
262 : dl 1.2 }
263 :     }
264 :    
265 : dl 1.3 static final int COUNTDOWN = 100000;
266 : jsr166 1.11
267 : jsr166 1.18 class Counter extends CheckedRunnable {
268 : dl 1.3 final AtomicIntegerArray ai;
269 :     volatile int counts;
270 :     Counter(AtomicIntegerArray a) { ai = a; }
271 : jsr166 1.18 public void realRun() {
272 : dl 1.3 for (;;) {
273 :     boolean done = true;
274 :     for (int i = 0; i < ai.length(); ++i) {
275 :     int v = ai.get(i);
276 : jsr166 1.18 assertTrue(v >= 0);
277 : dl 1.3 if (v != 0) {
278 :     done = false;
279 :     if (ai.compareAndSet(i, v, v-1))
280 :     ++counts;
281 :     }
282 :     }
283 :     if (done)
284 :     break;
285 :     }
286 :     }
287 :     }
288 :    
289 : dl 1.4 /**
290 : dl 1.5 * Multiple threads using same array of counters successfully
291 :     * update a number of times equal to total count
292 : dl 1.4 */
293 : jsr166 1.14 public void testCountingInMultipleThreads() throws InterruptedException {
294 :     final AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
295 :     for (int i = 0; i < SIZE; ++i)
296 :     ai.set(i, COUNTDOWN);
297 :     Counter c1 = new Counter(ai);
298 :     Counter c2 = new Counter(ai);
299 :     Thread t1 = new Thread(c1);
300 :     Thread t2 = new Thread(c2);
301 :     t1.start();
302 :     t2.start();
303 :     t1.join();
304 :     t2.join();
305 :     assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN);
306 : dl 1.3 }
307 :    
308 : dl 1.4 /**
309 : dl 1.5 * a deserialized serialized array holds same values
310 : dl 1.4 */
311 : jsr166 1.14 public void testSerialization() throws Exception {
312 : jsr166 1.22 AtomicIntegerArray x = new AtomicIntegerArray(SIZE);
313 :     for (int i = 0; i < SIZE; i++)
314 :     x.set(i, -i);
315 :     AtomicIntegerArray y = serialClone(x);
316 :     assertTrue(x != y);
317 :     assertEquals(x.length(), y.length());
318 :     for (int i = 0; i < SIZE; i++) {
319 :     assertEquals(x.get(i), y.get(i));
320 : dl 1.1 }
321 :     }
322 :    
323 : dl 1.9 /**
324 :     * toString returns current value.
325 : jsr166 1.11 */
326 : dl 1.9 public void testToString() {
327 : jsr166 1.23 int[] a = { 17, 3, -42, 99, -7 };
328 : dl 1.9 AtomicIntegerArray ai = new AtomicIntegerArray(a);
329 :     assertEquals(Arrays.toString(a), ai.toString());
330 :     }
331 : dl 1.8
332 : dl 1.1 }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8