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

Comparing jsr166/src/test/tck/AtomicReferenceArrayTest.java (file contents):
Revision 1.25 by jsr166, Fri Jun 10 20:17:11 2011 UTC vs.
Revision 1.36 by jsr166, Wed Jan 4 06:09:58 2017 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import junit.framework.*;
9   import java.util.Arrays;
10   import java.util.concurrent.atomic.AtomicReferenceArray;
11  
12 + import junit.framework.Test;
13 + import junit.framework.TestSuite;
14 +
15   public class AtomicReferenceArrayTest 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(AtomicReferenceArrayTest.class);
# Line 22 | Line 24 | public class AtomicReferenceArrayTest ex
24       * constructor creates array of given size with all elements null
25       */
26      public void testConstructor() {
27 <        AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(SIZE);
28 <        for (int i = 0; i < SIZE; ++i) {
29 <            assertNull(ai.get(i));
27 >        AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<>(SIZE);
28 >        for (int i = 0; i < SIZE; i++) {
29 >            assertNull(aa.get(i));
30          }
31      }
32  
# Line 34 | Line 36 | public class AtomicReferenceArrayTest ex
36      public void testConstructor2NPE() {
37          try {
38              Integer[] a = null;
39 <            AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(a);
39 >            new AtomicReferenceArray<Integer>(a);
40              shouldThrow();
41          } catch (NullPointerException success) {}
42      }
# Line 44 | Line 46 | public class AtomicReferenceArrayTest ex
46       */
47      public void testConstructor2() {
48          Integer[] a = { two, one, three, four, seven };
49 <        AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(a);
50 <        assertEquals(a.length, ai.length());
51 <        for (int i = 0; i < a.length; ++i)
52 <            assertEquals(a[i], ai.get(i));
49 >        AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<>(a);
50 >        assertEquals(a.length, aa.length());
51 >        for (int i = 0; i < a.length; i++)
52 >            assertEquals(a[i], aa.get(i));
53      }
54  
55      /**
56 <     * Initialize AtomicReference<Class> with SubClass[]
56 >     * Initialize AtomicReferenceArray<Class> with SubClass[]
57       */
58      public void testConstructorSubClassArray() {
59          Integer[] a = { two, one, three, four, seven };
60          AtomicReferenceArray<Number> aa = new AtomicReferenceArray<Number>(a);
61          assertEquals(a.length, aa.length());
62 <        for (int i = 0; i < a.length; ++i) {
62 >        for (int i = 0; i < a.length; i++) {
63              assertSame(a[i], aa.get(i));
64              Long x = Long.valueOf(i);
65              aa.set(i, x);
# Line 69 | Line 71 | public class AtomicReferenceArrayTest ex
71       * get and set for out of bound indices throw IndexOutOfBoundsException
72       */
73      public void testIndexing() {
74 <        AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(SIZE);
75 <        try {
76 <            ai.get(SIZE);
77 <            shouldThrow();
78 <        } catch (IndexOutOfBoundsException success) {
79 <        }
80 <        try {
81 <            ai.get(-1);
82 <            shouldThrow();
83 <        } catch (IndexOutOfBoundsException success) {
84 <        }
85 <        try {
86 <            ai.set(SIZE, null);
87 <            shouldThrow();
88 <        } catch (IndexOutOfBoundsException success) {
89 <        }
90 <        try {
91 <            ai.set(-1, null);
92 <            shouldThrow();
93 <        } catch (IndexOutOfBoundsException success) {
74 >        AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<>(SIZE);
75 >        for (int index : new int[] { -1, SIZE }) {
76 >            try {
77 >                aa.get(index);
78 >                shouldThrow();
79 >            } catch (IndexOutOfBoundsException success) {}
80 >            try {
81 >                aa.set(index, null);
82 >                shouldThrow();
83 >            } catch (IndexOutOfBoundsException success) {}
84 >            try {
85 >                aa.lazySet(index, null);
86 >                shouldThrow();
87 >            } catch (IndexOutOfBoundsException success) {}
88 >            try {
89 >                aa.compareAndSet(index, null, null);
90 >                shouldThrow();
91 >            } catch (IndexOutOfBoundsException success) {}
92 >            try {
93 >                aa.weakCompareAndSet(index, null, null);
94 >                shouldThrow();
95 >            } catch (IndexOutOfBoundsException success) {}
96          }
97      }
98  
# Line 96 | Line 100 | public class AtomicReferenceArrayTest ex
100       * get returns the last value set at index
101       */
102      public void testGetSet() {
103 <        AtomicReferenceArray ai = new AtomicReferenceArray(SIZE);
104 <        for (int i = 0; i < SIZE; ++i) {
105 <            ai.set(i, one);
106 <            assertSame(one, ai.get(i));
107 <            ai.set(i, two);
108 <            assertSame(two, ai.get(i));
109 <            ai.set(i, m3);
110 <            assertSame(m3, ai.get(i));
103 >        AtomicReferenceArray aa = new AtomicReferenceArray(SIZE);
104 >        for (int i = 0; i < SIZE; i++) {
105 >            aa.set(i, one);
106 >            assertSame(one, aa.get(i));
107 >            aa.set(i, two);
108 >            assertSame(two, aa.get(i));
109 >            aa.set(i, m3);
110 >            assertSame(m3, aa.get(i));
111          }
112      }
113  
# Line 111 | Line 115 | public class AtomicReferenceArrayTest ex
115       * get returns the last value lazySet at index by same thread
116       */
117      public void testGetLazySet() {
118 <        AtomicReferenceArray ai = new AtomicReferenceArray(SIZE);
119 <        for (int i = 0; i < SIZE; ++i) {
120 <            ai.lazySet(i, one);
121 <            assertSame(one, ai.get(i));
122 <            ai.lazySet(i, two);
123 <            assertSame(two, ai.get(i));
124 <            ai.lazySet(i, m3);
125 <            assertSame(m3, ai.get(i));
118 >        AtomicReferenceArray aa = new AtomicReferenceArray(SIZE);
119 >        for (int i = 0; i < SIZE; i++) {
120 >            aa.lazySet(i, one);
121 >            assertSame(one, aa.get(i));
122 >            aa.lazySet(i, two);
123 >            assertSame(two, aa.get(i));
124 >            aa.lazySet(i, m3);
125 >            assertSame(m3, aa.get(i));
126          }
127      }
128  
# Line 126 | Line 130 | public class AtomicReferenceArrayTest ex
130       * compareAndSet succeeds in changing value if equal to expected else fails
131       */
132      public void testCompareAndSet() {
133 <        AtomicReferenceArray ai = new AtomicReferenceArray(SIZE);
134 <        for (int i = 0; i < SIZE; ++i) {
135 <            ai.set(i, one);
136 <            assertTrue(ai.compareAndSet(i, one, two));
137 <            assertTrue(ai.compareAndSet(i, two, m4));
138 <            assertSame(m4, ai.get(i));
139 <            assertFalse(ai.compareAndSet(i, m5, seven));
140 <            assertSame(m4, ai.get(i));
141 <            assertTrue(ai.compareAndSet(i, m4, seven));
142 <            assertSame(seven, ai.get(i));
133 >        AtomicReferenceArray aa = new AtomicReferenceArray(SIZE);
134 >        for (int i = 0; i < SIZE; i++) {
135 >            aa.set(i, one);
136 >            assertTrue(aa.compareAndSet(i, one, two));
137 >            assertTrue(aa.compareAndSet(i, two, m4));
138 >            assertSame(m4, aa.get(i));
139 >            assertFalse(aa.compareAndSet(i, m5, seven));
140 >            assertSame(m4, aa.get(i));
141 >            assertTrue(aa.compareAndSet(i, m4, seven));
142 >            assertSame(seven, aa.get(i));
143          }
144      }
145  
# Line 164 | Line 168 | public class AtomicReferenceArrayTest ex
168       * to expected
169       */
170      public void testWeakCompareAndSet() {
171 <        AtomicReferenceArray ai = new AtomicReferenceArray(SIZE);
172 <        for (int i = 0; i < SIZE; ++i) {
173 <            ai.set(i, one);
174 <            while (!ai.weakCompareAndSet(i, one, two));
175 <            while (!ai.weakCompareAndSet(i, two, m4));
176 <            assertSame(m4, ai.get(i));
177 <            while (!ai.weakCompareAndSet(i, m4, seven));
178 <            assertSame(seven, ai.get(i));
171 >        AtomicReferenceArray aa = new AtomicReferenceArray(SIZE);
172 >        for (int i = 0; i < SIZE; i++) {
173 >            aa.set(i, one);
174 >            do {} while (!aa.weakCompareAndSet(i, one, two));
175 >            do {} while (!aa.weakCompareAndSet(i, two, m4));
176 >            assertSame(m4, aa.get(i));
177 >            do {} while (!aa.weakCompareAndSet(i, m4, seven));
178 >            assertSame(seven, aa.get(i));
179          }
180      }
181  
# Line 179 | Line 183 | public class AtomicReferenceArrayTest ex
183       * getAndSet returns previous value and sets to given value at given index
184       */
185      public void testGetAndSet() {
186 <        AtomicReferenceArray ai = new AtomicReferenceArray(SIZE);
187 <        for (int i = 0; i < SIZE; ++i) {
188 <            ai.set(i, one);
189 <            assertSame(one, ai.getAndSet(i, zero));
190 <            assertSame(zero, ai.getAndSet(i, m10));
191 <            assertSame(m10, ai.getAndSet(i, one));
186 >        AtomicReferenceArray aa = new AtomicReferenceArray(SIZE);
187 >        for (int i = 0; i < SIZE; i++) {
188 >            aa.set(i, one);
189 >            assertSame(one, aa.getAndSet(i, zero));
190 >            assertSame(zero, aa.getAndSet(i, m10));
191 >            assertSame(m10, aa.getAndSet(i, one));
192          }
193      }
194  
# Line 197 | Line 201 | public class AtomicReferenceArrayTest ex
201              x.set(i, new Integer(-i));
202          }
203          AtomicReferenceArray y = serialClone(x);
204 <        assertTrue(x != y);
204 >        assertNotSame(x, y);
205          assertEquals(x.length(), y.length());
206          for (int i = 0; i < SIZE; i++) {
207              assertEquals(x.get(i), y.get(i));
# Line 209 | Line 213 | public class AtomicReferenceArrayTest ex
213       */
214      public void testToString() {
215          Integer[] a = { two, one, three, four, seven };
216 <        AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(a);
217 <        assertEquals(Arrays.toString(a), ai.toString());
216 >        AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<>(a);
217 >        assertEquals(Arrays.toString(a), aa.toString());
218      }
219 +
220   }

Diff Legend

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