ViewVC Help

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

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

Comparing jsr166/src/test/tck/AtomicIntegerArrayTest.java (file contents):
Revision 1.33 by jsr166, Sun May 24 01:42:14 2015 UTC vs.
Revision 1.34 by dl, Thu Jun 16 23:35:25 2016 UTC

#	Line 86 | Line 86 | public class AtomicIntegerArrayTest exte
86		aa.addAndGet(index, 1);
87		shouldThrow();
88		} catch (IndexOutOfBoundsException success) {}
89	+	try {
90	+	aa.getPlain(index);
91	+	shouldThrow();
92	+	} catch (IndexOutOfBoundsException success) {}
93	+	try {
94	+	aa.getOpaque(index);
95	+	shouldThrow();
96	+	} catch (IndexOutOfBoundsException success) {}
97	+	try {
98	+	aa.getAcquire(index);
99	+	shouldThrow();
100	+	} catch (IndexOutOfBoundsException success) {}
101	+	try {
102	+	aa.setPlain(index, 1);
103	+	shouldThrow();
104	+	} catch (IndexOutOfBoundsException success) {}
105	+	try {
106	+	aa.setOpaque(index, 1);
107	+	shouldThrow();
108	+	} catch (IndexOutOfBoundsException success) {}
109	+	try {
110	+	aa.setRelease(index, 1);
111	+	shouldThrow();
112	+	} catch (IndexOutOfBoundsException success) {}
113	+	try {
114	+	aa.compareAndExchange(index, 1, 2);
115	+	shouldThrow();
116	+	} catch (IndexOutOfBoundsException success) {}
117	+	try {
118	+	aa.compareAndExchangeAcquire(index, 1, 2);
119	+	shouldThrow();
120	+	} catch (IndexOutOfBoundsException success) {}
121	+	try {
122	+	aa.compareAndExchangeRelease(index, 1, 2);
123	+	shouldThrow();
124	+	} catch (IndexOutOfBoundsException success) {}
125	+	try {
126	+	aa.weakCompareAndSetVolatile(index, 1, 2);
127	+	shouldThrow();
128	+	} catch (IndexOutOfBoundsException success) {}
129	+	try {
130	+	aa.weakCompareAndSetAcquire(index, 1, 2);
131	+	shouldThrow();
132	+	} catch (IndexOutOfBoundsException success) {}
133	+	try {
134	+	aa.weakCompareAndSetRelease(index, 1, 2);
135	+	shouldThrow();
136	+	} catch (IndexOutOfBoundsException success) {}
137		}
138		}
139
#	Line 340 | Line 388 | public class AtomicIntegerArrayTest exte
388		assertEquals(Arrays.toString(a), aa.toString());
389		}
390
391	+	// jdk9
392	+
393	+	/**
394	+	* getPlain returns the last value set
395	+	*/
396	+	public void testGetPlainSet() {
397	+	AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
398	+	for (int i = 0; i < SIZE; i++) {
399	+	aa.set(i, 1);
400	+	assertEquals(1, aa.getPlain(i));
401	+	aa.set(i, 2);
402	+	assertEquals(2, aa.getPlain(i));
403	+	aa.set(i, -3);
404	+	assertEquals(-3, aa.getPlain(i));
405	+	}
406	+	}
407	+
408	+	/**
409	+	* getOpaque returns the last value set
410	+	*/
411	+	public void testGetOpaqueSet() {
412	+	AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
413	+	for (int i = 0; i < SIZE; i++) {
414	+	aa.set(i, 1);
415	+	assertEquals(1, aa.getOpaque(i));
416	+	aa.set(i, 2);
417	+	assertEquals(2, aa.getOpaque(i));
418	+	aa.set(i, -3);
419	+	assertEquals(-3, aa.getOpaque(i));
420	+	}
421	+	}
422	+
423	+	/**
424	+	* getAcquire returns the last value set
425	+	*/
426	+	public void testGetAcquireSet() {
427	+	AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
428	+	for (int i = 0; i < SIZE; i++) {
429	+	aa.set(i, 1);
430	+	assertEquals(1, aa.getAcquire(i));
431	+	aa.set(i, 2);
432	+	assertEquals(2, aa.getAcquire(i));
433	+	aa.set(i, -3);
434	+	assertEquals(-3, aa.getAcquire(i));
435	+	}
436	+	}
437	+
438	+	/**
439	+	* get returns the last value setPlain
440	+	*/
441	+	public void testGetSetPlain() {
442	+	AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
443	+	for (int i = 0; i < SIZE; i++) {
444	+	aa.setPlain(i, 1);
445	+	assertEquals(1, aa.get(i));
446	+	aa.setPlain(i, 2);
447	+	assertEquals(2, aa.get(i));
448	+	aa.setPlain(i, -3);
449	+	assertEquals(-3, aa.get(i));
450	+	}
451	+	}
452	+
453	+	/**
454	+	* get returns the last value setOpaque
455	+	*/
456	+	public void testGetSetOpaque() {
457	+	AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
458	+	for (int i = 0; i < SIZE; i++) {
459	+	aa.setOpaque(i, 1);
460	+	assertEquals(1, aa.get(i));
461	+	aa.setOpaque(i, 2);
462	+	assertEquals(2, aa.get(i));
463	+	aa.setOpaque(i, -3);
464	+	assertEquals(-3, aa.get(i));
465	+	}
466	+	}
467	+
468	+	/**
469	+	* get returns the last value setRelease
470	+	*/
471	+	public void testGetSetRelease() {
472	+	AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
473	+	for (int i = 0; i < SIZE; i++) {
474	+	aa.setRelease(i, 1);
475	+	assertEquals(1, aa.get(i));
476	+	aa.setRelease(i, 2);
477	+	assertEquals(2, aa.get(i));
478	+	aa.setRelease(i, -3);
479	+	assertEquals(-3, aa.get(i));
480	+	}
481	+	}
482	+
483	+	/**
484	+	* compareAndExchange succeeds in changing value if equal to
485	+	* expected else fails
486	+	*/
487	+	public void testCompareAndExchange() {
488	+	AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
489	+	for (int i = 0; i < SIZE; i++) {
490	+	aa.set(i, 1);
491	+	assertEquals(1, aa.compareAndExchange(i, 1, 2));
492	+	assertEquals(2, aa.compareAndExchange(i, 2, -4));
493	+	assertEquals(-4, aa.get(i));
494	+	assertEquals(-4, aa.compareAndExchange(i,-5, 7));
495	+	assertEquals(-4, aa.get(i));
496	+	assertEquals(-4, aa.compareAndExchange(i, -4, 7));
497	+	assertEquals(7, aa.get(i));
498	+	}
499	+	}
500	+
501	+	/**
502	+	* compareAndExchangeAcquire succeeds in changing value if equal to
503	+	* expected else fails
504	+	*/
505	+	public void testCompareAndExchangeAcquire() {
506	+	AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
507	+	for (int i = 0; i < SIZE; i++) {
508	+	aa.set(i, 1);
509	+	assertEquals(1, aa.compareAndExchangeAcquire(i, 1, 2));
510	+	assertEquals(2, aa.compareAndExchangeAcquire(i, 2, -4));
511	+	assertEquals(-4, aa.get(i));
512	+	assertEquals(-4, aa.compareAndExchangeAcquire(i,-5, 7));
513	+	assertEquals(-4, aa.get(i));
514	+	assertEquals(-4, aa.compareAndExchangeAcquire(i, -4, 7));
515	+	assertEquals(7, aa.get(i));
516	+	}
517	+	}
518	+
519	+	/**
520	+	* compareAndExchangeRelease succeeds in changing value if equal to
521	+	* expected else fails
522	+	*/
523	+	public void testCompareAndExchangeRelease() {
524	+	AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
525	+	for (int i = 0; i < SIZE; i++) {
526	+	aa.set(i, 1);
527	+	assertEquals(1, aa.compareAndExchangeRelease(i, 1, 2));
528	+	assertEquals(2, aa.compareAndExchangeRelease(i, 2, -4));
529	+	assertEquals(-4, aa.get(i));
530	+	assertEquals(-4, aa.compareAndExchangeRelease(i,-5, 7));
531	+	assertEquals(-4, aa.get(i));
532	+	assertEquals(-4, aa.compareAndExchangeRelease(i, -4, 7));
533	+	assertEquals(7, aa.get(i));
534	+	}
535	+	}
536	+
537	+	/**
538	+	* repeated weakCompareAndSetVolatile succeeds in changing value when equal
539	+	* to expected
540	+	*/
541	+	public void testWeakCompareAndSetVolatile() {
542	+	AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
543	+	for (int i = 0; i < SIZE; i++) {
544	+	aa.set(i, 1);
545	+	do {} while (!aa.weakCompareAndSetVolatile(i, 1, 2));
546	+	do {} while (!aa.weakCompareAndSetVolatile(i, 2, -4));
547	+	assertEquals(-4, aa.get(i));
548	+	do {} while (!aa.weakCompareAndSetVolatile(i, -4, 7));
549	+	assertEquals(7, aa.get(i));
550	+	}
551	+	}
552	+
553	+	/**
554	+	* repeated weakCompareAndSetAcquire succeeds in changing value when equal
555	+	* to expected
556	+	*/
557	+	public void testWeakCompareAndSetAcquire() {
558	+	AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
559	+	for (int i = 0; i < SIZE; i++) {
560	+	aa.set(i, 1);
561	+	do {} while (!aa.weakCompareAndSetAcquire(i, 1, 2));
562	+	do {} while (!aa.weakCompareAndSetAcquire(i, 2, -4));
563	+	assertEquals(-4, aa.get(i));
564	+	do {} while (!aa.weakCompareAndSetAcquire(i, -4, 7));
565	+	assertEquals(7, aa.get(i));
566	+	}
567	+	}
568	+
569	+	/**
570	+	* repeated weakCompareAndSetRelease succeeds in changing value when equal
571	+	* to expected
572	+	*/
573	+	public void testWeakCompareAndSetRelease() {
574	+	AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
575	+	for (int i = 0; i < SIZE; i++) {
576	+	aa.set(i, 1);
577	+	do {} while (!aa.weakCompareAndSetRelease(i, 1, 2));
578	+	do {} while (!aa.weakCompareAndSetRelease(i, 2, -4));
579	+	assertEquals(-4, aa.get(i));
580	+	do {} while (!aa.weakCompareAndSetRelease(i, -4, 7));
581	+	assertEquals(7, aa.get(i));
582	+	}
583	+	}
584	+
585		}

Diff Legend

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