ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/AtomicReferenceArrayTest.java

Comparing jsr166/src/test/tck/AtomicReferenceArrayTest.java (file contents):
Revision 1.33 by dl, Thu Jun 16 23:35:25 2016 UTC vs.
Revision 1.40 by jsr166, Wed Jan 27 01:57:24 2021 UTC

#	Line 24 | 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> aa = new AtomicReferenceArray<Integer>(SIZE);
27	>	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<>(SIZE);
28		for (int i = 0; i < SIZE; i++) {
29		assertNull(aa.get(i));
30		}
#	Line 45 | Line 45 | public class AtomicReferenceArrayTest ex
45		* constructor with array is of same size and has all elements
46		*/
47		public void testConstructor2() {
48	<	Integer[] a = { two, one, three, four, seven };
49	<	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(a);
48	>	Item[] a = { two, one, three, four, seven };
49	>	AtomicReferenceArray<Item> 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));
#	Line 56 | Line 56 | public class AtomicReferenceArrayTest ex
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);
59	>	Item[] a = { two, one, three, four, seven };
60	>	AtomicReferenceArray<Number> aa = new AtomicReferenceArray<>(a);
61		assertEquals(a.length, aa.length());
62		for (int i = 0; i < a.length; i++) {
63		assertSame(a[i], aa.get(i));
#	Line 70 | Line 70 | public class AtomicReferenceArrayTest ex
70		/**
71		* get and set for out of bound indices throw IndexOutOfBoundsException
72		*/
73	+	@SuppressWarnings("deprecation")
74		public void testIndexing() {
75	<	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(SIZE);
75	>	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<>(SIZE);
76		for (int index : new int[] { -1, SIZE }) {
77		try {
78		aa.get(index);
#	Line 93 | Line 94 | public class AtomicReferenceArrayTest ex
94		aa.weakCompareAndSet(index, null, null);
95		shouldThrow();
96		} catch (IndexOutOfBoundsException success) {}
96	–	try {
97	–	aa.getPlain(index);
98	–	shouldThrow();
99	–	} catch (IndexOutOfBoundsException success) {}
100	–	try {
101	–	aa.getOpaque(index);
102	–	shouldThrow();
103	–	} catch (IndexOutOfBoundsException success) {}
104	–	try {
105	–	aa.getAcquire(index);
106	–	shouldThrow();
107	–	} catch (IndexOutOfBoundsException success) {}
108	–	try {
109	–	aa.setPlain(index, null);
110	–	shouldThrow();
111	–	} catch (IndexOutOfBoundsException success) {}
112	–	try {
113	–	aa.setOpaque(index, null);
114	–	shouldThrow();
115	–	} catch (IndexOutOfBoundsException success) {}
116	–	try {
117	–	aa.setRelease(index, null);
118	–	shouldThrow();
119	–	} catch (IndexOutOfBoundsException success) {}
120	–	try {
121	–	aa.compareAndExchange(index, null, null);
122	–	shouldThrow();
123	–	} catch (IndexOutOfBoundsException success) {}
124	–	try {
125	–	aa.compareAndExchangeAcquire(index, null, null);
126	–	shouldThrow();
127	–	} catch (IndexOutOfBoundsException success) {}
128	–	try {
129	–	aa.compareAndExchangeRelease(index, null, null);
130	–	shouldThrow();
131	–	} catch (IndexOutOfBoundsException success) {}
132	–	try {
133	–	aa.weakCompareAndSetVolatile(index, null, null);
134	–	shouldThrow();
135	–	} catch (IndexOutOfBoundsException success) {}
136	–	try {
137	–	aa.weakCompareAndSetAcquire(index, null, null);
138	–	shouldThrow();
139	–	} catch (IndexOutOfBoundsException success) {}
140	–	try {
141	–	aa.weakCompareAndSetRelease(index, null, null);
142	–	shouldThrow();
143	–	} catch (IndexOutOfBoundsException success) {}
97		}
98		}
99
#	Line 148 | Line 101 | public class AtomicReferenceArrayTest ex
101		* get returns the last value set at index
102		*/
103		public void testGetSet() {
104	<	AtomicReferenceArray aa = new AtomicReferenceArray(SIZE);
104	>	AtomicReferenceArray<Item> aa = new AtomicReferenceArray<>(SIZE);
105		for (int i = 0; i < SIZE; i++) {
106		aa.set(i, one);
107		assertSame(one, aa.get(i));
108		aa.set(i, two);
109		assertSame(two, aa.get(i));
110	<	aa.set(i, m3);
111	<	assertSame(m3, aa.get(i));
110	>	aa.set(i, minusThree);
111	>	assertSame(minusThree, aa.get(i));
112		}
113		}
114
#	Line 163 | Line 116 | public class AtomicReferenceArrayTest ex
116		* get returns the last value lazySet at index by same thread
117		*/
118		public void testGetLazySet() {
119	<	AtomicReferenceArray aa = new AtomicReferenceArray(SIZE);
119	>	AtomicReferenceArray<Item> aa = new AtomicReferenceArray<>(SIZE);
120		for (int i = 0; i < SIZE; i++) {
121		aa.lazySet(i, one);
122		assertSame(one, aa.get(i));
123		aa.lazySet(i, two);
124		assertSame(two, aa.get(i));
125	<	aa.lazySet(i, m3);
126	<	assertSame(m3, aa.get(i));
125	>	aa.lazySet(i, minusThree);
126	>	assertSame(minusThree, aa.get(i));
127		}
128		}
129
#	Line 178 | Line 131 | public class AtomicReferenceArrayTest ex
131		* compareAndSet succeeds in changing value if equal to expected else fails
132		*/
133		public void testCompareAndSet() {
134	<	AtomicReferenceArray aa = new AtomicReferenceArray(SIZE);
134	>	AtomicReferenceArray<Item> aa = new AtomicReferenceArray<>(SIZE);
135		for (int i = 0; i < SIZE; i++) {
136		aa.set(i, one);
137		assertTrue(aa.compareAndSet(i, one, two));
138	<	assertTrue(aa.compareAndSet(i, two, m4));
139	<	assertSame(m4, aa.get(i));
140	<	assertFalse(aa.compareAndSet(i, m5, seven));
141	<	assertSame(m4, aa.get(i));
142	<	assertTrue(aa.compareAndSet(i, m4, seven));
138	>	assertTrue(aa.compareAndSet(i, two, minusFour));
139	>	assertSame(minusFour, aa.get(i));
140	>	assertFalse(aa.compareAndSet(i, minusFive, seven));
141	>	assertSame(minusFour, aa.get(i));
142	>	assertTrue(aa.compareAndSet(i, minusFour, seven));
143		assertSame(seven, aa.get(i));
144		}
145		}
#	Line 196 | Line 149 | public class AtomicReferenceArrayTest ex
149		* to succeed
150		*/
151		public void testCompareAndSetInMultipleThreads() throws InterruptedException {
152	<	final AtomicReferenceArray a = new AtomicReferenceArray(1);
152	>	final AtomicReferenceArray<Item> a = new AtomicReferenceArray<>(1);
153		a.set(0, one);
154		Thread t = new Thread(new CheckedRunnable() {
155		public void realRun() {
#	Line 215 | Line 168 | public class AtomicReferenceArrayTest ex
168		* repeated weakCompareAndSet succeeds in changing value when equal
169		* to expected
170		*/
171	+	@SuppressWarnings("deprecation")
172		public void testWeakCompareAndSet() {
173	<	AtomicReferenceArray aa = new AtomicReferenceArray(SIZE);
173	>	AtomicReferenceArray<Item> aa = new AtomicReferenceArray<>(SIZE);
174		for (int i = 0; i < SIZE; i++) {
175		aa.set(i, one);
176		do {} while (!aa.weakCompareAndSet(i, one, two));
177	<	do {} while (!aa.weakCompareAndSet(i, two, m4));
178	<	assertSame(m4, aa.get(i));
179	<	do {} while (!aa.weakCompareAndSet(i, m4, seven));
177	>	do {} while (!aa.weakCompareAndSet(i, two, minusFour));
178	>	assertSame(minusFour, aa.get(i));
179	>	do {} while (!aa.weakCompareAndSet(i, minusFour, seven));
180		assertSame(seven, aa.get(i));
181		}
182		}
#	Line 231 | Line 185 | public class AtomicReferenceArrayTest ex
185		* getAndSet returns previous value and sets to given value at given index
186		*/
187		public void testGetAndSet() {
188	<	AtomicReferenceArray aa = new AtomicReferenceArray(SIZE);
188	>	AtomicReferenceArray<Item> aa = new AtomicReferenceArray<>(SIZE);
189		for (int i = 0; i < SIZE; i++) {
190		aa.set(i, one);
191		assertSame(one, aa.getAndSet(i, zero));
192	<	assertSame(zero, aa.getAndSet(i, m10));
193	<	assertSame(m10, aa.getAndSet(i, one));
192	>	assertSame(zero, aa.getAndSet(i, minusTen));
193	>	assertSame(minusTen, aa.getAndSet(i, one));
194		}
195		}
196
197		/**
198	<	* a deserialized serialized array holds same values
198	>	* a deserialized/reserialized array holds same values in same order
199		*/
200		public void testSerialization() throws Exception {
201	<	AtomicReferenceArray x = new AtomicReferenceArray(SIZE);
201	>	AtomicReferenceArray<Item> x = new AtomicReferenceArray<>(SIZE);
202		for (int i = 0; i < SIZE; i++) {
203	<	x.set(i, new Integer(-i));
203	>	x.set(i, minusOne);
204		}
205	<	AtomicReferenceArray y = serialClone(x);
205	>	AtomicReferenceArray<Item> y = serialClone(x);
206		assertNotSame(x, y);
207		assertEquals(x.length(), y.length());
208		for (int i = 0; i < SIZE; i++) {
#	Line 260 | Line 214 | public class AtomicReferenceArrayTest ex
214		* toString returns current value.
215		*/
216		public void testToString() {
217	<	Integer[] a = { two, one, three, four, seven };
218	<	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(a);
217	>	Item[] a = { two, one, three, four, seven };
218	>	AtomicReferenceArray<Item> aa = new AtomicReferenceArray<>(a);
219		assertEquals(Arrays.toString(a), aa.toString());
220		}
221
268	–	// jdk9
269	–
270	–	/**
271	–	* getPlain returns the last value set
272	–	*/
273	–	public void testGetPlainSet() {
274	–	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(SIZE);
275	–	for (int i = 0; i < SIZE; i++) {
276	–	aa.set(i, one);
277	–	assertEquals(one, aa.getPlain(i));
278	–	aa.set(i, two);
279	–	assertEquals(two, aa.getPlain(i));
280	–	aa.set(i, m3);
281	–	assertEquals(m3, aa.getPlain(i));
282	–	}
283	–	}
284	–
285	–	/**
286	–	* getOpaque returns the last value set
287	–	*/
288	–	public void testGetOpaqueSet() {
289	–	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(SIZE);
290	–	for (int i = 0; i < SIZE; i++) {
291	–	aa.set(i, one);
292	–	assertEquals(one, aa.getOpaque(i));
293	–	aa.set(i, two);
294	–	assertEquals(two, aa.getOpaque(i));
295	–	aa.set(i, m3);
296	–	assertEquals(m3, aa.getOpaque(i));
297	–	}
298	–	}
299	–
300	–	/**
301	–	* getAcquire returns the last value set
302	–	*/
303	–	public void testGetAcquireSet() {
304	–	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(SIZE);
305	–	for (int i = 0; i < SIZE; i++) {
306	–	aa.set(i, one);
307	–	assertEquals(one, aa.getAcquire(i));
308	–	aa.set(i, two);
309	–	assertEquals(two, aa.getAcquire(i));
310	–	aa.set(i, m3);
311	–	assertEquals(m3, aa.getAcquire(i));
312	–	}
313	–	}
314	–
315	–	/**
316	–	* get returns the last value setPlain
317	–	*/
318	–	public void testGetSetPlain() {
319	–	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(SIZE);
320	–	for (int i = 0; i < SIZE; i++) {
321	–	aa.setPlain(i, one);
322	–	assertEquals(one, aa.get(i));
323	–	aa.setPlain(i, two);
324	–	assertEquals(two, aa.get(i));
325	–	aa.setPlain(i, m3);
326	–	assertEquals(m3, aa.get(i));
327	–	}
328	–	}
329	–
330	–	/**
331	–	* get returns the last value setOpaque
332	–	*/
333	–	public void testGetSetOpaque() {
334	–	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(SIZE);
335	–	for (int i = 0; i < SIZE; i++) {
336	–	aa.setOpaque(i, one);
337	–	assertEquals(one, aa.get(i));
338	–	aa.setOpaque(i, two);
339	–	assertEquals(two, aa.get(i));
340	–	aa.setOpaque(i, m3);
341	–	assertEquals(m3, aa.get(i));
342	–	}
343	–	}
344	–
345	–	/**
346	–	* get returns the last value setRelease
347	–	*/
348	–	public void testGetSetRelease() {
349	–	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(SIZE);
350	–	for (int i = 0; i < SIZE; i++) {
351	–	aa.setRelease(i, one);
352	–	assertEquals(one, aa.get(i));
353	–	aa.setRelease(i, two);
354	–	assertEquals(two, aa.get(i));
355	–	aa.setRelease(i, m3);
356	–	assertEquals(m3, aa.get(i));
357	–	}
358	–	}
359	–
360	–	/**
361	–	* compareAndExchange succeeds in changing value if equal to
362	–	* expected else fails
363	–	*/
364	–	public void testCompareAndExchange() {
365	–	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(SIZE);
366	–	for (int i = 0; i < SIZE; i++) {
367	–	aa.set(i, one);
368	–	assertEquals(one, aa.compareAndExchange(i, one, two));
369	–	assertEquals(two, aa.compareAndExchange(i, two, m4));
370	–	assertEquals(m4, aa.get(i));
371	–	assertEquals(m4, aa.compareAndExchange(i,m5, seven));
372	–	assertEquals(m4, aa.get(i));
373	–	assertEquals(m4, aa.compareAndExchange(i, m4, seven));
374	–	assertEquals(seven, aa.get(i));
375	–	}
376	–	}
377	–
378	–	/**
379	–	* compareAndExchangeAcquire succeeds in changing value if equal to
380	–	* expected else fails
381	–	*/
382	–	public void testCompareAndExchangeAcquire() {
383	–	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(SIZE);
384	–	for (int i = 0; i < SIZE; i++) {
385	–	aa.set(i, one);
386	–	assertEquals(one, aa.compareAndExchangeAcquire(i, one, two));
387	–	assertEquals(two, aa.compareAndExchangeAcquire(i, two, m4));
388	–	assertEquals(m4, aa.get(i));
389	–	assertEquals(m4, aa.compareAndExchangeAcquire(i,m5, seven));
390	–	assertEquals(m4, aa.get(i));
391	–	assertEquals(m4, aa.compareAndExchangeAcquire(i, m4, seven));
392	–	assertEquals(seven, aa.get(i));
393	–	}
394	–	}
395	–
396	–	/**
397	–	* compareAndExchangeRelease succeeds in changing value if equal to
398	–	* expected else fails
399	–	*/
400	–	public void testCompareAndExchangeRelease() {
401	–	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(SIZE);
402	–	for (int i = 0; i < SIZE; i++) {
403	–	aa.set(i, one);
404	–	assertEquals(one, aa.compareAndExchangeRelease(i, one, two));
405	–	assertEquals(two, aa.compareAndExchangeRelease(i, two, m4));
406	–	assertEquals(m4, aa.get(i));
407	–	assertEquals(m4, aa.compareAndExchangeRelease(i,m5, seven));
408	–	assertEquals(m4, aa.get(i));
409	–	assertEquals(m4, aa.compareAndExchangeRelease(i, m4, seven));
410	–	assertEquals(seven, aa.get(i));
411	–	}
412	–	}
413	–
414	–	/**
415	–	* repeated weakCompareAndSetVolatile succeeds in changing value when equal
416	–	* to expected
417	–	*/
418	–	public void testWeakCompareAndSetVolatile() {
419	–	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(SIZE);
420	–	for (int i = 0; i < SIZE; i++) {
421	–	aa.set(i, one);
422	–	do {} while (!aa.weakCompareAndSetVolatile(i, one, two));
423	–	do {} while (!aa.weakCompareAndSetVolatile(i, two, m4));
424	–	assertEquals(m4, aa.get(i));
425	–	do {} while (!aa.weakCompareAndSetVolatile(i, m4, seven));
426	–	assertEquals(seven, aa.get(i));
427	–	}
428	–	}
429	–
430	–	/**
431	–	* repeated weakCompareAndSetAcquire succeeds in changing value when equal
432	–	* to expected
433	–	*/
434	–	public void testWeakCompareAndSetAcquire() {
435	–	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(SIZE);
436	–	for (int i = 0; i < SIZE; i++) {
437	–	aa.set(i, one);
438	–	do {} while (!aa.weakCompareAndSetAcquire(i, one, two));
439	–	do {} while (!aa.weakCompareAndSetAcquire(i, two, m4));
440	–	assertEquals(m4, aa.get(i));
441	–	do {} while (!aa.weakCompareAndSetAcquire(i, m4, seven));
442	–	assertEquals(seven, aa.get(i));
443	–	}
444	–	}
445	–
446	–	/**
447	–	* repeated weakCompareAndSetRelease succeeds in changing value when equal
448	–	* to expected
449	–	*/
450	–	public void testWeakCompareAndSetRelease() {
451	–	AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(SIZE);
452	–	for (int i = 0; i < SIZE; i++) {
453	–	aa.set(i, one);
454	–	do {} while (!aa.weakCompareAndSetRelease(i, one, two));
455	–	do {} while (!aa.weakCompareAndSetRelease(i, two, m4));
456	–	assertEquals(m4, aa.get(i));
457	–	do {} while (!aa.weakCompareAndSetRelease(i, m4, seven));
458	–	assertEquals(seven, aa.get(i));
459	–	}
460	–	}
461	–
222		}

Diff Legend

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