[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.13 - (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 :     * http://creativecommons.org/licenses/publicdomain
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 :     import java.util.concurrent.atomic.*;
11 : dl 1.2 import java.io.*;
12 : dl 1.9 import java.util.*;
13 : dl 1.1
14 : dl 1.3 public class AtomicIntegerArrayTest extends JSR166TestCase {
15 : dl 1.1
16 :     public static void main (String[] args) {
17 :     junit.textui.TestRunner.run (suite());
18 :     }
19 :     public static Test suite() {
20 :     return new TestSuite(AtomicIntegerArrayTest.class);
21 :     }
22 :    
23 : dl 1.3
24 : dl 1.4 /**
25 : dl 1.5 * constructor creates array of given size with all elements zero
26 : dl 1.4 */
27 :     public void testConstructor() {
28 : dl 1.3 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
29 : jsr166 1.11 for (int i = 0; i < SIZE; ++i)
30 : dl 1.1 assertEquals(0,ai.get(i));
31 :     }
32 :    
33 : dl 1.4 /**
34 : dl 1.7 * constructor with null array throws NPE
35 :     */
36 :     public void testConstructor2NPE() {
37 :     try {
38 :     int[] a = null;
39 :     AtomicIntegerArray ai = new AtomicIntegerArray(a);
40 :     } catch (NullPointerException success) {
41 :     } catch (Exception ex) {
42 :     unexpectedException();
43 :     }
44 :     }
45 :    
46 :     /**
47 :     * constructor with array is of same size and has all elements
48 :     */
49 :     public void testConstructor2() {
50 :     int[] a = { 17, 3, -42, 99, -7};
51 :     AtomicIntegerArray ai = new AtomicIntegerArray(a);
52 :     assertEquals(a.length, ai.length());
53 : jsr166 1.11 for (int i = 0; i < a.length; ++i)
54 : dl 1.7 assertEquals(a[i], ai.get(i));
55 :     }
56 :    
57 :     /**
58 : dl 1.5 * get and set for out of bound indices throw IndexOutOfBoundsException
59 :     */
60 : jsr166 1.13 public void testIndexing() {
61 : dl 1.5 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
62 :     try {
63 :     ai.get(SIZE);
64 : jsr166 1.13 } catch (IndexOutOfBoundsException success) {
65 : dl 1.5 }
66 :     try {
67 :     ai.get(-1);
68 : jsr166 1.13 } catch (IndexOutOfBoundsException success) {
69 : dl 1.5 }
70 :     try {
71 :     ai.set(SIZE, 0);
72 : jsr166 1.13 } catch (IndexOutOfBoundsException success) {
73 : dl 1.5 }
74 :     try {
75 :     ai.set(-1, 0);
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 :     assertFalse((7 == ai.get(i)));
122 :     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 :     public void testCompareAndSetInMultipleThreads() {
132 :     final AtomicIntegerArray a = new AtomicIntegerArray(1);
133 :     a.set(0, 1);
134 :     Thread t = new Thread(new Runnable() {
135 :     public void run() {
136 : jsr166 1.12 while (!a.compareAndSet(0, 2, 3)) Thread.yield();
137 : dl 1.5 }});
138 :     try {
139 :     t.start();
140 :     assertTrue(a.compareAndSet(0, 1, 2));
141 :     t.join(LONG_DELAY_MS);
142 :     assertFalse(t.isAlive());
143 :     assertEquals(a.get(0), 3);
144 :     }
145 : jsr166 1.12 catch (Exception e) {
146 : dl 1.5 unexpectedException();
147 :     }
148 :     }
149 :    
150 :     /**
151 :     * repeated weakCompareAndSet succeeds in changing value when equal
152 : jsr166 1.11 * to expected
153 : dl 1.4 */
154 :     public void testWeakCompareAndSet() {
155 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
156 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
157 : dl 1.1 ai.set(i, 1);
158 : jsr166 1.12 while (!ai.weakCompareAndSet(i, 1,2));
159 :     while (!ai.weakCompareAndSet(i, 2,-4));
160 : dl 1.1 assertEquals(-4,ai.get(i));
161 : jsr166 1.12 while (!ai.weakCompareAndSet(i, -4,7));
162 : dl 1.1 assertEquals(7,ai.get(i));
163 :     }
164 :     }
165 :    
166 : dl 1.4 /**
167 : dl 1.5 * getAndSet returns previous value and sets to given value at given index
168 : dl 1.4 */
169 :     public void testGetAndSet() {
170 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
171 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
172 : dl 1.1 ai.set(i, 1);
173 :     assertEquals(1,ai.getAndSet(i,0));
174 :     assertEquals(0,ai.getAndSet(i,-10));
175 :     assertEquals(-10,ai.getAndSet(i,1));
176 :     }
177 :     }
178 :    
179 : dl 1.4 /**
180 : dl 1.5 * getAndAdd returns previous value and adds given value
181 : dl 1.4 */
182 :     public void testGetAndAdd() {
183 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
184 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
185 : dl 1.1 ai.set(i, 1);
186 :     assertEquals(1,ai.getAndAdd(i,2));
187 :     assertEquals(3,ai.get(i));
188 :     assertEquals(3,ai.getAndAdd(i,-4));
189 :     assertEquals(-1,ai.get(i));
190 :     }
191 :     }
192 :    
193 : dl 1.4 /**
194 : dl 1.5 * getAndDecrement returns previous value and decrements
195 : dl 1.4 */
196 :     public void testGetAndDecrement() {
197 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
198 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
199 : dl 1.1 ai.set(i, 1);
200 :     assertEquals(1,ai.getAndDecrement(i));
201 :     assertEquals(0,ai.getAndDecrement(i));
202 :     assertEquals(-1,ai.getAndDecrement(i));
203 :     }
204 :     }
205 :    
206 : dl 1.4 /**
207 : dl 1.5 * getAndIncrement returns previous value and increments
208 : dl 1.4 */
209 :     public void testGetAndIncrement() {
210 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
211 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
212 : dl 1.1 ai.set(i, 1);
213 :     assertEquals(1,ai.getAndIncrement(i));
214 :     assertEquals(2,ai.get(i));
215 :     ai.set(i,-2);
216 :     assertEquals(-2,ai.getAndIncrement(i));
217 :     assertEquals(-1,ai.getAndIncrement(i));
218 :     assertEquals(0,ai.getAndIncrement(i));
219 :     assertEquals(1,ai.get(i));
220 :     }
221 :     }
222 :    
223 : dl 1.4 /**
224 : dl 1.5 * addAndGet adds given value to current, and returns current value
225 : dl 1.4 */
226 : dl 1.1 public void testAddAndGet() {
227 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
228 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
229 : dl 1.1 ai.set(i, 1);
230 :     assertEquals(3,ai.addAndGet(i,2));
231 :     assertEquals(3,ai.get(i));
232 :     assertEquals(-1,ai.addAndGet(i,-4));
233 :     assertEquals(-1,ai.get(i));
234 :     }
235 :     }
236 :    
237 : dl 1.4 /**
238 : dl 1.5 * decrementAndGet decrements and returns current value
239 : dl 1.4 */
240 :     public void testDecrementAndGet() {
241 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
242 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
243 : dl 1.1 ai.set(i, 1);
244 :     assertEquals(0,ai.decrementAndGet(i));
245 :     assertEquals(-1,ai.decrementAndGet(i));
246 :     assertEquals(-2,ai.decrementAndGet(i));
247 :     assertEquals(-2,ai.get(i));
248 :     }
249 :     }
250 :    
251 : dl 1.4 /**
252 : dl 1.5 * incrementAndGet increments and returns current value
253 : dl 1.4 */
254 : dl 1.1 public void testIncrementAndGet() {
255 : jsr166 1.11 AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
256 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
257 : dl 1.1 ai.set(i, 1);
258 :     assertEquals(2,ai.incrementAndGet(i));
259 :     assertEquals(2,ai.get(i));
260 :     ai.set(i, -2);
261 :     assertEquals(-1,ai.incrementAndGet(i));
262 :     assertEquals(0,ai.incrementAndGet(i));
263 :     assertEquals(1,ai.incrementAndGet(i));
264 :     assertEquals(1,ai.get(i));
265 : dl 1.2 }
266 :     }
267 :    
268 : dl 1.3 static final int COUNTDOWN = 100000;
269 : jsr166 1.11
270 : dl 1.3 class Counter implements Runnable {
271 :     final AtomicIntegerArray ai;
272 :     volatile int counts;
273 :     Counter(AtomicIntegerArray a) { ai = a; }
274 :     public void run() {
275 :     for (;;) {
276 :     boolean done = true;
277 :     for (int i = 0; i < ai.length(); ++i) {
278 :     int v = ai.get(i);
279 :     threadAssertTrue(v >= 0);
280 :     if (v != 0) {
281 :     done = false;
282 :     if (ai.compareAndSet(i, v, v-1))
283 :     ++counts;
284 :     }
285 :     }
286 :     if (done)
287 :     break;
288 :     }
289 :     }
290 :     }
291 :    
292 : dl 1.4 /**
293 : dl 1.5 * Multiple threads using same array of counters successfully
294 :     * update a number of times equal to total count
295 : dl 1.4 */
296 : dl 1.3 public void testCountingInMultipleThreads() {
297 :     try {
298 : jsr166 1.11 final AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
299 :     for (int i = 0; i < SIZE; ++i)
300 : dl 1.3 ai.set(i, COUNTDOWN);
301 :     Counter c1 = new Counter(ai);
302 :     Counter c2 = new Counter(ai);
303 :     Thread t1 = new Thread(c1);
304 :     Thread t2 = new Thread(c2);
305 :     t1.start();
306 :     t2.start();
307 :     t1.join();
308 :     t2.join();
309 :     assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN);
310 :     }
311 : jsr166 1.12 catch (InterruptedException ie) {
312 : dl 1.4 unexpectedException();
313 : dl 1.3 }
314 :     }
315 :    
316 :    
317 : dl 1.4 /**
318 : dl 1.5 * a deserialized serialized array holds same values
319 : dl 1.4 */
320 : dl 1.2 public void testSerialization() {
321 : jsr166 1.11 AtomicIntegerArray l = new AtomicIntegerArray(SIZE);
322 :     for (int i = 0; i < SIZE; ++i)
323 : dl 1.2 l.set(i, -i);
324 :    
325 :     try {
326 :     ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
327 :     ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
328 :     out.writeObject(l);
329 :     out.close();
330 :    
331 :     ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
332 :     ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
333 :     AtomicIntegerArray r = (AtomicIntegerArray) in.readObject();
334 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
335 : dl 1.2 assertEquals(l.get(i), r.get(i));
336 :     }
337 : jsr166 1.13 } catch (Exception e) {
338 : dl 1.2 e.printStackTrace();
339 : dl 1.4 unexpectedException();
340 : dl 1.1 }
341 :     }
342 :    
343 : dl 1.8
344 : dl 1.9 /**
345 :     * toString returns current value.
346 : jsr166 1.11 */
347 : dl 1.9 public void testToString() {
348 :     int[] a = { 17, 3, -42, 99, -7};
349 :     AtomicIntegerArray ai = new AtomicIntegerArray(a);
350 :     assertEquals(Arrays.toString(a), ai.toString());
351 :     }
352 : dl 1.8
353 : dl 1.1 }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8