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.35 by jsr166, Fri Jun 17 01:38:28 2016 UTC vs.
Revision 1.36 by jsr166, Fri Jun 17 19:00:48 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) {}
89		}
90		}
91
#	Line 388 | Line 340 | public class AtomicIntegerArrayTest exte
340		assertEquals(Arrays.toString(a), aa.toString());
341		}
342
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	–
343		}

Diff Legend

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