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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.25, Fri Jun 10 20:17:11 2011 UTC revision 1.26, Wed Aug 10 07:14:48 2011 UTC
# Line 23  Line 23 
23       * constructor creates array of given size with all elements zero       * constructor creates array of given size with all elements zero
24       */       */
25      public void testConstructor() {      public void testConstructor() {
26          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);          AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
27          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; i++)
28              assertEquals(0, ai.get(i));              assertEquals(0, aa.get(i));
29      }      }
30    
31      /**      /**
# Line 34  Line 34 
34      public void testConstructor2NPE() {      public void testConstructor2NPE() {
35          try {          try {
36              int[] a = null;              int[] a = null;
37              AtomicIntegerArray ai = new AtomicIntegerArray(a);              AtomicIntegerArray aa = new AtomicIntegerArray(a);
38              shouldThrow();              shouldThrow();
39          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
40      }      }
# Line 44  Line 44 
44       */       */
45      public void testConstructor2() {      public void testConstructor2() {
46          int[] a = { 17, 3, -42, 99, -7 };          int[] a = { 17, 3, -42, 99, -7 };
47          AtomicIntegerArray ai = new AtomicIntegerArray(a);          AtomicIntegerArray aa = new AtomicIntegerArray(a);
48          assertEquals(a.length, ai.length());          assertEquals(a.length, aa.length());
49          for (int i = 0; i < a.length; ++i)          for (int i = 0; i < a.length; i++)
50              assertEquals(a[i], ai.get(i));              assertEquals(a[i], aa.get(i));
51      }      }
52    
53      /**      /**
54       * get and set for out of bound indices throw IndexOutOfBoundsException       * get and set for out of bound indices throw IndexOutOfBoundsException
55       */       */
56      public void testIndexing() {      public void testIndexing() {
57          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);          AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
58            for (int index : new int[] { -1, SIZE }) {
59          try {          try {
60              ai.get(SIZE);                  aa.get(index);
61              shouldThrow();              shouldThrow();
62          } catch (IndexOutOfBoundsException success) {              } catch (IndexOutOfBoundsException success) {}
         }  
63          try {          try {
64              ai.get(-1);                  aa.set(index, 1);
65              shouldThrow();              shouldThrow();
66          } catch (IndexOutOfBoundsException success) {              } catch (IndexOutOfBoundsException success) {}
         }  
67          try {          try {
68              ai.set(SIZE, 0);                  aa.lazySet(index, 1);
69              shouldThrow();              shouldThrow();
70          } catch (IndexOutOfBoundsException success) {              } catch (IndexOutOfBoundsException success) {}
71          }              try {
72                    aa.compareAndSet(index, 1, 2);
73                    shouldThrow();
74                } catch (IndexOutOfBoundsException success) {}
75          try {          try {
76              ai.set(-1, 0);                  aa.weakCompareAndSet(index, 1, 2);
77              shouldThrow();              shouldThrow();
78          } catch (IndexOutOfBoundsException success) {              } catch (IndexOutOfBoundsException success) {}
79                try {
80                    aa.getAndAdd(index, 1);
81                    shouldThrow();
82                } catch (IndexOutOfBoundsException success) {}
83                try {
84                    aa.addAndGet(index, 1);
85                    shouldThrow();
86                } catch (IndexOutOfBoundsException success) {}
87          }          }
88      }      }
89    
# Line 81  Line 91 
91       * get returns the last value set at index       * get returns the last value set at index
92       */       */
93      public void testGetSet() {      public void testGetSet() {
94          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);          AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
95          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; i++) {
96              ai.set(i, 1);              aa.set(i, 1);
97              assertEquals(1, ai.get(i));              assertEquals(1, aa.get(i));
98              ai.set(i, 2);              aa.set(i, 2);
99              assertEquals(2, ai.get(i));              assertEquals(2, aa.get(i));
100              ai.set(i, -3);              aa.set(i, -3);
101              assertEquals(-3, ai.get(i));              assertEquals(-3, aa.get(i));
102          }          }
103      }      }
104    
# Line 96  Line 106 
106       * get returns the last value lazySet at index by same thread       * get returns the last value lazySet at index by same thread
107       */       */
108      public void testGetLazySet() {      public void testGetLazySet() {
109          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);          AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
110          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; i++) {
111              ai.lazySet(i, 1);              aa.lazySet(i, 1);
112              assertEquals(1, ai.get(i));              assertEquals(1, aa.get(i));
113              ai.lazySet(i, 2);              aa.lazySet(i, 2);
114              assertEquals(2, ai.get(i));              assertEquals(2, aa.get(i));
115              ai.lazySet(i, -3);              aa.lazySet(i, -3);
116              assertEquals(-3, ai.get(i));              assertEquals(-3, aa.get(i));
117          }          }
118      }      }
119    
# Line 111  Line 121 
121       * compareAndSet succeeds in changing value if equal to expected else fails       * compareAndSet succeeds in changing value if equal to expected else fails
122       */       */
123      public void testCompareAndSet() {      public void testCompareAndSet() {
124          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);          AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
125          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; i++) {
126              ai.set(i, 1);              aa.set(i, 1);
127              assertTrue(ai.compareAndSet(i, 1, 2));              assertTrue(aa.compareAndSet(i, 1, 2));
128              assertTrue(ai.compareAndSet(i, 2, -4));              assertTrue(aa.compareAndSet(i, 2, -4));
129              assertEquals(-4, ai.get(i));              assertEquals(-4, aa.get(i));
130              assertFalse(ai.compareAndSet(i, -5, 7));              assertFalse(aa.compareAndSet(i, -5, 7));
131              assertEquals(-4, ai.get(i));              assertEquals(-4, aa.get(i));
132              assertTrue(ai.compareAndSet(i, -4, 7));              assertTrue(aa.compareAndSet(i, -4, 7));
133              assertEquals(7, ai.get(i));              assertEquals(7, aa.get(i));
134          }          }
135      }      }
136    
# Line 149  Line 159 
159       * to expected       * to expected
160       */       */
161      public void testWeakCompareAndSet() {      public void testWeakCompareAndSet() {
162          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);          AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
163          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; i++) {
164              ai.set(i, 1);              aa.set(i, 1);
165              while (!ai.weakCompareAndSet(i, 1, 2));              while (!aa.weakCompareAndSet(i, 1, 2));
166              while (!ai.weakCompareAndSet(i, 2, -4));              while (!aa.weakCompareAndSet(i, 2, -4));
167              assertEquals(-4, ai.get(i));              assertEquals(-4, aa.get(i));
168              while (!ai.weakCompareAndSet(i, -4, 7));              while (!aa.weakCompareAndSet(i, -4, 7));
169              assertEquals(7, ai.get(i));              assertEquals(7, aa.get(i));
170          }          }
171      }      }
172    
# Line 164  Line 174 
174       * getAndSet returns previous value and sets to given value at given index       * getAndSet returns previous value and sets to given value at given index
175       */       */
176      public void testGetAndSet() {      public void testGetAndSet() {
177          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);          AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
178          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; i++) {
179              ai.set(i, 1);              aa.set(i, 1);
180              assertEquals(1, ai.getAndSet(i, 0));              assertEquals(1, aa.getAndSet(i, 0));
181              assertEquals(0, ai.getAndSet(i, -10));              assertEquals(0, aa.getAndSet(i, -10));
182              assertEquals(-10, ai.getAndSet(i, 1));              assertEquals(-10, aa.getAndSet(i, 1));
183          }          }
184      }      }
185    
# Line 177  Line 187 
187       * getAndAdd returns previous value and adds given value       * getAndAdd returns previous value and adds given value
188       */       */
189      public void testGetAndAdd() {      public void testGetAndAdd() {
190          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);          AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
191          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; i++) {
192              ai.set(i, 1);              aa.set(i, 1);
193              assertEquals(1, ai.getAndAdd(i, 2));              assertEquals(1, aa.getAndAdd(i, 2));
194              assertEquals(3, ai.get(i));              assertEquals(3, aa.get(i));
195              assertEquals(3, ai.getAndAdd(i, -4));              assertEquals(3, aa.getAndAdd(i, -4));
196              assertEquals(-1, ai.get(i));              assertEquals(-1, aa.get(i));
197          }          }
198      }      }
199    
# Line 191  Line 201 
201       * getAndDecrement returns previous value and decrements       * getAndDecrement returns previous value and decrements
202       */       */
203      public void testGetAndDecrement() {      public void testGetAndDecrement() {
204          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);          AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
205          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; i++) {
206              ai.set(i, 1);              aa.set(i, 1);
207              assertEquals(1, ai.getAndDecrement(i));              assertEquals(1, aa.getAndDecrement(i));
208              assertEquals(0, ai.getAndDecrement(i));              assertEquals(0, aa.getAndDecrement(i));
209              assertEquals(-1, ai.getAndDecrement(i));              assertEquals(-1, aa.getAndDecrement(i));
210          }          }
211      }      }
212    
# Line 204  Line 214 
214       * getAndIncrement returns previous value and increments       * getAndIncrement returns previous value and increments
215       */       */
216      public void testGetAndIncrement() {      public void testGetAndIncrement() {
217          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);          AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
218          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; i++) {
219              ai.set(i, 1);              aa.set(i, 1);
220              assertEquals(1, ai.getAndIncrement(i));              assertEquals(1, aa.getAndIncrement(i));
221              assertEquals(2, ai.get(i));              assertEquals(2, aa.get(i));
222              ai.set(i, -2);              aa.set(i, -2);
223              assertEquals(-2, ai.getAndIncrement(i));              assertEquals(-2, aa.getAndIncrement(i));
224              assertEquals(-1, ai.getAndIncrement(i));              assertEquals(-1, aa.getAndIncrement(i));
225              assertEquals(0, ai.getAndIncrement(i));              assertEquals(0, aa.getAndIncrement(i));
226              assertEquals(1, ai.get(i));              assertEquals(1, aa.get(i));
227          }          }
228      }      }
229    
# Line 221  Line 231 
231       * addAndGet adds given value to current, and returns current value       * addAndGet adds given value to current, and returns current value
232       */       */
233      public void testAddAndGet() {      public void testAddAndGet() {
234          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);          AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
235          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; i++) {
236              ai.set(i, 1);              aa.set(i, 1);
237              assertEquals(3, ai.addAndGet(i, 2));              assertEquals(3, aa.addAndGet(i, 2));
238              assertEquals(3, ai.get(i));              assertEquals(3, aa.get(i));
239              assertEquals(-1, ai.addAndGet(i, -4));              assertEquals(-1, aa.addAndGet(i, -4));
240              assertEquals(-1, ai.get(i));              assertEquals(-1, aa.get(i));
241          }          }
242      }      }
243    
# Line 235  Line 245 
245       * decrementAndGet decrements and returns current value       * decrementAndGet decrements and returns current value
246       */       */
247      public void testDecrementAndGet() {      public void testDecrementAndGet() {
248          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);          AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
249          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; i++) {
250              ai.set(i, 1);              aa.set(i, 1);
251              assertEquals(0, ai.decrementAndGet(i));              assertEquals(0, aa.decrementAndGet(i));
252              assertEquals(-1, ai.decrementAndGet(i));              assertEquals(-1, aa.decrementAndGet(i));
253              assertEquals(-2, ai.decrementAndGet(i));              assertEquals(-2, aa.decrementAndGet(i));
254              assertEquals(-2, ai.get(i));              assertEquals(-2, aa.get(i));
255          }          }
256      }      }
257    
# Line 249  Line 259 
259       * incrementAndGet increments and returns current value       * incrementAndGet increments and returns current value
260       */       */
261      public void testIncrementAndGet() {      public void testIncrementAndGet() {
262          AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);          AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
263          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; i++) {
264              ai.set(i, 1);              aa.set(i, 1);
265              assertEquals(2, ai.incrementAndGet(i));              assertEquals(2, aa.incrementAndGet(i));
266              assertEquals(2, ai.get(i));              assertEquals(2, aa.get(i));
267              ai.set(i, -2);              aa.set(i, -2);
268              assertEquals(-1, ai.incrementAndGet(i));              assertEquals(-1, aa.incrementAndGet(i));
269              assertEquals(0, ai.incrementAndGet(i));              assertEquals(0, aa.incrementAndGet(i));
270              assertEquals(1, ai.incrementAndGet(i));              assertEquals(1, aa.incrementAndGet(i));
271              assertEquals(1, ai.get(i));              assertEquals(1, aa.get(i));
272          }          }
273      }      }
274    
275      static final int COUNTDOWN = 100000;      static final int COUNTDOWN = 100000;
276    
277      class Counter extends CheckedRunnable {      class Counter extends CheckedRunnable {
278          final AtomicIntegerArray ai;          final AtomicIntegerArray aa;
279          volatile int counts;          volatile int counts;
280          Counter(AtomicIntegerArray a) { ai = a; }          Counter(AtomicIntegerArray a) { aa = a; }
281          public void realRun() {          public void realRun() {
282              for (;;) {              for (;;) {
283                  boolean done = true;                  boolean done = true;
284                  for (int i = 0; i < ai.length(); ++i) {                  for (int i = 0; i < aa.length(); i++) {
285                      int v = ai.get(i);                      int v = aa.get(i);
286                      assertTrue(v >= 0);                      assertTrue(v >= 0);
287                      if (v != 0) {                      if (v != 0) {
288                          done = false;                          done = false;
289                          if (ai.compareAndSet(i, v, v-1))                          if (aa.compareAndSet(i, v, v-1))
290                              ++counts;                              ++counts;
291                      }                      }
292                  }                  }
# Line 291  Line 301 
301       * update a number of times equal to total count       * update a number of times equal to total count
302       */       */
303      public void testCountingInMultipleThreads() throws InterruptedException {      public void testCountingInMultipleThreads() throws InterruptedException {
304          final AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);          final AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
305          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; i++)
306              ai.set(i, COUNTDOWN);              aa.set(i, COUNTDOWN);
307          Counter c1 = new Counter(ai);          Counter c1 = new Counter(aa);
308          Counter c2 = new Counter(ai);          Counter c2 = new Counter(aa);
309          Thread t1 = new Thread(c1);          Thread t1 = new Thread(c1);
310          Thread t2 = new Thread(c2);          Thread t2 = new Thread(c2);
311          t1.start();          t1.start();
# Line 325  Line 335 
335       */       */
336      public void testToString() {      public void testToString() {
337          int[] a = { 17, 3, -42, 99, -7 };          int[] a = { 17, 3, -42, 99, -7 };
338          AtomicIntegerArray ai = new AtomicIntegerArray(a);          AtomicIntegerArray aa = new AtomicIntegerArray(a);
339          assertEquals(Arrays.toString(a), ai.toString());          assertEquals(Arrays.toString(a), aa.toString());
340      }      }
341    
342  }  }

Legend:
Removed from v.1.25  
changed lines
  Added in v.1.26

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8