ViewVC Help

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

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

Comparing jsr166/src/test/tck/Atomic8Test.java (file contents):
Revision 1.3 by jsr166, Wed Dec 31 19:05:42 2014 UTC vs.
Revision 1.9 by jsr166, Wed Jan 4 06:09:58 2017 UTC

#	Line 18 | Line 18 | import java.util.concurrent.atomic.Atomi
18		import junit.framework.Test;
19		import junit.framework.TestSuite;
20
21	+	/**
22	+	* Tests of atomic class methods accepting lambdas introduced in JDK8.
23	+	*/
24		public class Atomic8Test extends JSR166TestCase {
25
26		public static void main(String[] args) {
27	<	junit.textui.TestRunner.run(suite());
27	>	main(suite(), args);
28		}
29		public static Test suite() {
30		return new TestSuite(Atomic8Test.class);
31		}
32
30	–	/*
31	–	* Tests of atomic class methods accepting lambdas
32	–	* introduced in JDK8.
33	–	*/
34	–
33		static long addLong17(long x) { return x + 17; }
34		static int addInt17(int x) { return x + 17; }
35		static Integer addInteger17(Integer x) {
36	<	return new Integer(x.intValue() + 17);
36	>	return x.intValue() + 17;
37		}
38		static Integer sumInteger(Integer x, Integer y) {
39	<	return new Integer(x.intValue() + y.intValue());
39	>	return x.intValue() + y.intValue();
40		}
41
42		volatile long aLongField;
43		volatile int anIntField;
44		volatile Integer anIntegerField;
45
46	<	AtomicLongFieldUpdater aLongFieldUpdater() {
46	>	AtomicLongFieldUpdater<Atomic8Test> aLongFieldUpdater() {
47		return AtomicLongFieldUpdater.newUpdater
48		(Atomic8Test.class, "aLongField");
49		}
50
51	<	AtomicIntegerFieldUpdater anIntFieldUpdater() {
51	>	AtomicIntegerFieldUpdater<Atomic8Test> anIntFieldUpdater() {
52		return AtomicIntegerFieldUpdater.newUpdater
53		(Atomic8Test.class, "anIntField");
54		}
#	Line 152 | Line 150 | public class Atomic8Test extends JSR166T
150		* result of supplied function
151		*/
152		public void testReferenceGetAndUpdate() {
153	<	AtomicReference<Integer> a = new AtomicReference<Integer>(one);
154	<	assertEquals(new Integer(1), a.getAndUpdate(Atomic8Test::addInteger17));
155	<	assertEquals(new Integer(18), a.getAndUpdate(Atomic8Test::addInteger17));
156	<	assertEquals(new Integer(35), a.get());
153	>	AtomicReference<Integer> a = new AtomicReference<>(one);
154	>	assertEquals((Integer) 1, a.getAndUpdate(Atomic8Test::addInteger17));
155	>	assertEquals((Integer) 18, a.getAndUpdate(Atomic8Test::addInteger17));
156	>	assertEquals((Integer) 35, a.get());
157		}
158
159		/**
#	Line 163 | Line 161 | public class Atomic8Test extends JSR166T
161		* returns result.
162		*/
163		public void testReferenceUpdateAndGet() {
164	<	AtomicReference<Integer> a = new AtomicReference<Integer>(one);
165	<	assertEquals(new Integer(18), a.updateAndGet(Atomic8Test::addInteger17));
166	<	assertEquals(new Integer(35), a.updateAndGet(Atomic8Test::addInteger17));
167	<	assertEquals(new Integer(35), a.get());
164	>	AtomicReference<Integer> a = new AtomicReference<>(one);
165	>	assertEquals((Integer) 18, a.updateAndGet(Atomic8Test::addInteger17));
166	>	assertEquals((Integer) 35, a.updateAndGet(Atomic8Test::addInteger17));
167	>	assertEquals((Integer) 35, a.get());
168		}
169
170		/**
#	Line 174 | Line 172 | public class Atomic8Test extends JSR166T
172		* with supplied function.
173		*/
174		public void testReferenceGetAndAccumulate() {
175	<	AtomicReference<Integer> a = new AtomicReference<Integer>(one);
176	<	assertEquals(new Integer(1), a.getAndAccumulate(2, Atomic8Test::sumInteger));
177	<	assertEquals(new Integer(3), a.getAndAccumulate(3, Atomic8Test::sumInteger));
178	<	assertEquals(new Integer(6), a.get());
175	>	AtomicReference<Integer> a = new AtomicReference<>(one);
176	>	assertEquals((Integer) 1, a.getAndAccumulate(2, Atomic8Test::sumInteger));
177	>	assertEquals((Integer) 3, a.getAndAccumulate(3, Atomic8Test::sumInteger));
178	>	assertEquals((Integer) 6, a.get());
179		}
180
181		/**
#	Line 185 | Line 183 | public class Atomic8Test extends JSR166T
183		* returns result.
184		*/
185		public void testReferenceAccumulateAndGet() {
186	<	AtomicReference<Integer> a = new AtomicReference<Integer>(one);
187	<	assertEquals(new Integer(7), a.accumulateAndGet(6, Atomic8Test::sumInteger));
188	<	assertEquals(new Integer(10), a.accumulateAndGet(3, Atomic8Test::sumInteger));
189	<	assertEquals(new Integer(10), a.get());
186	>	AtomicReference<Integer> a = new AtomicReference<>(one);
187	>	assertEquals((Integer) 7, a.accumulateAndGet(6, Atomic8Test::sumInteger));
188	>	assertEquals((Integer) 10, a.accumulateAndGet(3, Atomic8Test::sumInteger));
189	>	assertEquals((Integer) 10, a.get());
190		}
191
194	–
192		/**
193		* AtomicLongArray getAndUpdate returns previous value and updates
194		* result of supplied function
#	Line 292 | Line 289 | public class Atomic8Test extends JSR166T
289		* result of supplied function
290		*/
291		public void testReferenceArrayGetAndUpdate() {
292	<	AtomicReferenceArray<Integer> a = new AtomicReferenceArray<Integer>(1);
292	>	AtomicReferenceArray<Integer> a = new AtomicReferenceArray<>(1);
293		a.set(0, one);
294	<	assertEquals(new Integer(1), a.getAndUpdate(0, Atomic8Test::addInteger17));
295	<	assertEquals(new Integer(18), a.getAndUpdate(0, Atomic8Test::addInteger17));
296	<	assertEquals(new Integer(35), a.get(0));
294	>	assertEquals((Integer) 1, a.getAndUpdate(0, Atomic8Test::addInteger17));
295	>	assertEquals((Integer) 18, a.getAndUpdate(0, Atomic8Test::addInteger17));
296	>	assertEquals((Integer) 35, a.get(0));
297		}
298
299		/**
#	Line 304 | Line 301 | public class Atomic8Test extends JSR166T
301		* returns result.
302		*/
303		public void testReferenceArrayUpdateAndGet() {
304	<	AtomicReferenceArray<Integer> a = new AtomicReferenceArray<Integer>(1);
304	>	AtomicReferenceArray<Integer> a = new AtomicReferenceArray<>(1);
305		a.set(0, one);
306	<	assertEquals(new Integer(18), a.updateAndGet(0, Atomic8Test::addInteger17));
307	<	assertEquals(new Integer(35), a.updateAndGet(0, Atomic8Test::addInteger17));
306	>	assertEquals((Integer) 18, a.updateAndGet(0, Atomic8Test::addInteger17));
307	>	assertEquals((Integer) 35, a.updateAndGet(0, Atomic8Test::addInteger17));
308		}
309
310		/**
#	Line 315 | Line 312 | public class Atomic8Test extends JSR166T
312		* with supplied function.
313		*/
314		public void testReferenceArrayGetAndAccumulate() {
315	<	AtomicReferenceArray<Integer> a = new AtomicReferenceArray<Integer>(1);
315	>	AtomicReferenceArray<Integer> a = new AtomicReferenceArray<>(1);
316		a.set(0, one);
317	<	assertEquals(new Integer(1), a.getAndAccumulate(0, 2, Atomic8Test::sumInteger));
318	<	assertEquals(new Integer(3), a.getAndAccumulate(0, 3, Atomic8Test::sumInteger));
319	<	assertEquals(new Integer(6), a.get(0));
317	>	assertEquals((Integer) 1, a.getAndAccumulate(0, 2, Atomic8Test::sumInteger));
318	>	assertEquals((Integer) 3, a.getAndAccumulate(0, 3, Atomic8Test::sumInteger));
319	>	assertEquals((Integer) 6, a.get(0));
320		}
321
322		/**
#	Line 327 | Line 324 | public class Atomic8Test extends JSR166T
324		* returns result.
325		*/
326		public void testReferenceArrayAccumulateAndGet() {
327	<	AtomicReferenceArray<Integer> a = new AtomicReferenceArray<Integer>(1);
327	>	AtomicReferenceArray<Integer> a = new AtomicReferenceArray<>(1);
328		a.set(0, one);
329	<	assertEquals(new Integer(7), a.accumulateAndGet(0, 6, Atomic8Test::sumInteger));
330	<	assertEquals(new Integer(10), a.accumulateAndGet(0, 3, Atomic8Test::sumInteger));
329	>	assertEquals((Integer) 7, a.accumulateAndGet(0, 6, Atomic8Test::sumInteger));
330	>	assertEquals((Integer) 10, a.accumulateAndGet(0, 3, Atomic8Test::sumInteger));
331		}
332
333		/**
#	Line 437 | Line 434 | public class Atomic8Test extends JSR166T
434		assertEquals(10, anIntField);
435		}
436
440	–
437		/**
438		* AtomicReferenceFieldUpdater getAndUpdate returns previous value
439		* and updates result of supplied function
#	Line 445 | Line 441 | public class Atomic8Test extends JSR166T
441		public void testReferenceFieldUpdaterGetAndUpdate() {
442		AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
443		a.set(this, one);
444	<	assertEquals(new Integer(1), a.getAndUpdate(this, Atomic8Test::addInteger17));
445	<	assertEquals(new Integer(18), a.getAndUpdate(this, Atomic8Test::addInteger17));
446	<	assertEquals(new Integer(35), a.get(this));
447	<	assertEquals(new Integer(35), anIntegerField);
444	>	assertEquals((Integer) 1, a.getAndUpdate(this, Atomic8Test::addInteger17));
445	>	assertEquals((Integer) 18, a.getAndUpdate(this, Atomic8Test::addInteger17));
446	>	assertEquals((Integer) 35, a.get(this));
447	>	assertEquals((Integer) 35, anIntegerField);
448		}
449
450		/**
#	Line 458 | Line 454 | public class Atomic8Test extends JSR166T
454		public void testReferenceFieldUpdaterUpdateAndGet() {
455		AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
456		a.set(this, one);
457	<	assertEquals(new Integer(18), a.updateAndGet(this, Atomic8Test::addInteger17));
458	<	assertEquals(new Integer(35), a.updateAndGet(this, Atomic8Test::addInteger17));
459	<	assertEquals(new Integer(35), a.get(this));
460	<	assertEquals(new Integer(35), anIntegerField);
457	>	assertEquals((Integer) 18, a.updateAndGet(this, Atomic8Test::addInteger17));
458	>	assertEquals((Integer) 35, a.updateAndGet(this, Atomic8Test::addInteger17));
459	>	assertEquals((Integer) 35, a.get(this));
460	>	assertEquals((Integer) 35, anIntegerField);
461		}
462
463		/**
#	Line 471 | Line 467 | public class Atomic8Test extends JSR166T
467		public void testReferenceFieldUpdaterGetAndAccumulate() {
468		AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
469		a.set(this, one);
470	<	assertEquals(new Integer(1), a.getAndAccumulate(this, 2, Atomic8Test::sumInteger));
471	<	assertEquals(new Integer(3), a.getAndAccumulate(this, 3, Atomic8Test::sumInteger));
472	<	assertEquals(new Integer(6), a.get(this));
473	<	assertEquals(new Integer(6), anIntegerField);
470	>	assertEquals((Integer) 1, a.getAndAccumulate(this, 2, Atomic8Test::sumInteger));
471	>	assertEquals((Integer) 3, a.getAndAccumulate(this, 3, Atomic8Test::sumInteger));
472	>	assertEquals((Integer) 6, a.get(this));
473	>	assertEquals((Integer) 6, anIntegerField);
474		}
475
476		/**
#	Line 484 | Line 480 | public class Atomic8Test extends JSR166T
480		public void testReferenceFieldUpdaterAccumulateAndGet() {
481		AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
482		a.set(this, one);
483	<	assertEquals(new Integer(7), a.accumulateAndGet(this, 6, Atomic8Test::sumInteger));
484	<	assertEquals(new Integer(10), a.accumulateAndGet(this, 3, Atomic8Test::sumInteger));
485	<	assertEquals(new Integer(10), a.get(this));
486	<	assertEquals(new Integer(10), anIntegerField);
483	>	assertEquals((Integer) 7, a.accumulateAndGet(this, 6, Atomic8Test::sumInteger));
484	>	assertEquals((Integer) 10, a.accumulateAndGet(this, 3, Atomic8Test::sumInteger));
485	>	assertEquals((Integer) 10, a.get(this));
486	>	assertEquals((Integer) 10, anIntegerField);
487		}
488
489		/**
#	Line 505 | Line 501 | public class Atomic8Test extends JSR166T
501		() -> aLongFieldUpdater().getAndUpdate(this, null),
502		() -> anIntFieldUpdater().getAndUpdate(this, null),
503		() -> anIntegerFieldUpdater().getAndUpdate(this, null),
508	–	////() -> aLongFieldUpdater().getAndUpdate(null, Atomic8Test::addLong17),
509	–	////() -> anIntFieldUpdater().getAndUpdate(null, Atomic8Test::addInt17),
510	–	////() -> anIntegerFieldUpdater().getAndUpdate(null, Atomic8Test::addInteger17),
504		};
505		assertThrows(NullPointerException.class, throwingActions);
506		}
#	Line 568 | Line 561 | public class Atomic8Test extends JSR166T
561		assertThrows(NullPointerException.class, throwingActions);
562		}
563
564	+	/**
565	+	* Object arguments for parameters of type T that are not
566	+	* instances of the class passed to the newUpdater call will
567	+	* result in a ClassCastException being thrown.
568	+	*/
569	+	public void testFieldUpdaters_ClassCastException() {
570	+	// Use raw types to allow passing wrong object type, provoking CCE
571	+	final AtomicLongFieldUpdater longUpdater = aLongFieldUpdater();
572	+	final AtomicIntegerFieldUpdater intUpdater = anIntFieldUpdater();
573	+	final AtomicReferenceFieldUpdater refUpdater = anIntegerFieldUpdater();
574	+	final Object obj = new Object();
575	+	for (Object x : new Object[]{ new Object(), null }) {
576	+	Runnable[] throwingActions = {
577	+	() -> longUpdater.get(x),
578	+	() -> intUpdater.get(x),
579	+	() -> refUpdater.get(x),
580	+
581	+	() -> longUpdater.set(x, 17L),
582	+	() -> intUpdater.set(x, 17),
583	+	() -> refUpdater.set(x, (Integer) 17),
584	+
585	+	() -> longUpdater.addAndGet(x, 17L),
586	+	() -> intUpdater.addAndGet(x, 17),
587	+
588	+	() -> longUpdater.getAndUpdate(x, y -> y),
589	+	() -> intUpdater.getAndUpdate(x, y -> y),
590	+	() -> refUpdater.getAndUpdate(x, y -> y),
591	+
592	+	() -> longUpdater.compareAndSet(x, 17L, 42L),
593	+	() -> intUpdater.compareAndSet(x, 17, 42),
594	+	() -> refUpdater.compareAndSet(x, (Integer) 17, (Integer) 42),
595	+	};
596	+	assertThrows(ClassCastException.class, throwingActions);
597	+	}
598	+	}
599	+
600		}

Diff Legend

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