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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8