--- jsr166/src/test/tck/AtomicReferenceFieldUpdaterTest.java 2003/12/29 19:05:40 1.7 +++ jsr166/src/test/tck/AtomicReferenceFieldUpdaterTest.java 2021/01/26 13:33:05 1.38 @@ -1,142 +1,194 @@ /* * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at - * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * http://creativecommons.org/publicdomain/zero/1.0/ + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -import java.util.concurrent.atomic.*; -import junit.framework.*; -import java.util.*; +import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; -public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase{ - volatile Integer x = null; +import junit.framework.Test; +import junit.framework.TestSuite; + +public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase { + volatile Item x = null; + protected volatile Item protectedField; + private volatile Item privateField; Object z; - Integer w; + Item w; + volatile int i; - public static void main(String[] args){ - junit.textui.TestRunner.run(suite()); + public static void main(String[] args) { + main(suite(), args); } public static Test suite() { return new TestSuite(AtomicReferenceFieldUpdaterTest.class); } + static AtomicReferenceFieldUpdater updaterFor(String fieldName) { + return AtomicReferenceFieldUpdater.newUpdater + (AtomicReferenceFieldUpdaterTest.class, Item.class, fieldName); + } + /** * Construction with non-existent field throws RuntimeException */ - public void testConstructor(){ - try{ - AtomicReferenceFieldUpdater - a = AtomicReferenceFieldUpdater.newUpdater - (AtomicReferenceFieldUpdaterTest.class, Integer.class, "y"); + public void testConstructor() { + try { + updaterFor("y"); shouldThrow(); + } catch (RuntimeException success) { + assertNotNull(success.getCause()); } - catch (RuntimeException rt) {} } + /** + * construction with field not of given type throws ClassCastException + */ + public void testConstructor2() { + try { + updaterFor("z"); + shouldThrow(); + } catch (ClassCastException success) {} + } /** - * construction with field not of given type throws RuntimeException + * Constructor with non-volatile field throws IllegalArgumentException */ - public void testConstructor2(){ - try{ - AtomicReferenceFieldUpdater - a = AtomicReferenceFieldUpdater.newUpdater - (AtomicReferenceFieldUpdaterTest.class, Integer.class, "z"); + public void testConstructor3() { + try { + updaterFor("w"); shouldThrow(); - } - catch (RuntimeException rt) {} + } catch (IllegalArgumentException success) {} } /** - * Constructor with non-volatile field throws exception + * Constructor with non-reference field throws ClassCastException */ - public void testConstructor3(){ - try{ - AtomicReferenceFieldUpdater - a = AtomicReferenceFieldUpdater.newUpdater - (AtomicReferenceFieldUpdaterTest.class, Integer.class, "w"); + public void testConstructor4() { + try { + updaterFor("i"); shouldThrow(); - } - catch (RuntimeException rt) {} + } catch (ClassCastException success) {} + } + + /** + * construction using private field from subclass throws RuntimeException + */ + public void testPrivateFieldInSubclass() { + new NonNestmates.AtomicReferenceFieldUpdaterTestSubclass() + .checkPrivateAccess(); } /** - * get returns the last value set or assigned + * construction from unrelated class; package access is allowed, + * private access is not */ - public void testGetSet(){ - AtomicReferenceFieldUpdatera = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x"); + public void testUnrelatedClassAccess() { + new NonNestmates().checkPackageAccess(this); + new NonNestmates().checkPrivateAccess(this); + } + + /** + * get returns the last value set or assigned + */ + public void testGetSet() { + AtomicReferenceFieldUpdater a; + a = updaterFor("x"); x = one; - assertEquals(one,a.get(this)); - a.set(this,two); - assertEquals(two,a.get(this)); - a.set(this,-3); - assertEquals(-3,a.get(this)); - + assertSame(one, a.get(this)); + a.set(this, two); + assertSame(two, a.get(this)); + a.set(this, minusThree); + assertSame(minusThree, a.get(this)); } + /** - * compareAndSet succeeds in changing value if equal to expected else fails + * get returns the last value lazySet by same thread */ - public void testCompareAndSet(){ - AtomicReferenceFieldUpdatera = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x"); + public void testGetLazySet() { + AtomicReferenceFieldUpdater a; + a = updaterFor("x"); x = one; - assertTrue(a.compareAndSet(this,one,two)); - assertTrue(a.compareAndSet(this,two,m4)); - assertEquals(m4,a.get(this)); - assertFalse(a.compareAndSet(this,m5,seven)); - assertFalse((seven == a.get(this))); - assertTrue(a.compareAndSet(this,m4,seven)); - assertEquals(seven,a.get(this)); + assertSame(one, a.get(this)); + a.lazySet(this, two); + assertSame(two, a.get(this)); + a.lazySet(this, minusThree); + assertSame(minusThree, a.get(this)); + } + + /** + * compareAndSet succeeds in changing value if same as expected else fails + */ + public void testCompareAndSet() { + AtomicReferenceFieldUpdater a; + a = updaterFor("x"); + x = one; + assertTrue(a.compareAndSet(this, one, two)); + assertTrue(a.compareAndSet(this, two, minusFour)); + assertSame(minusFour, a.get(this)); + assertFalse(a.compareAndSet(this, minusFive, seven)); + assertNotSame(seven, a.get(this)); + assertTrue(a.compareAndSet(this, minusFour, seven)); + assertSame(seven, a.get(this)); + } + + /** + * compareAndSet succeeds in changing protected field value if + * same as expected else fails + */ + public void testCompareAndSetProtectedInSubclass() { + new NonNestmates.AtomicReferenceFieldUpdaterTestSubclass() + .checkCompareAndSetProtectedSub(); } /** * compareAndSet in one thread enables another waiting for value * to succeed */ - public void testCompareAndSetInMultipleThreads() { + public void testCompareAndSetInMultipleThreads() throws Exception { x = one; - final AtomicReferenceFieldUpdatera = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x"); + final AtomicReferenceFieldUpdater a; + a = updaterFor("x"); - Thread t = new Thread(new Runnable() { - public void run() { - while(!a.compareAndSet(AtomicReferenceFieldUpdaterTest.this, two, three)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(a.compareAndSet(this, one, two)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - assertEquals(a.get(this), three); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!a.compareAndSet(AtomicReferenceFieldUpdaterTest.this, two, three)) + Thread.yield(); + }}); + + t.start(); + assertTrue(a.compareAndSet(this, one, two)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertSame(three, a.get(this)); } /** - * repeated weakCompareAndSet succeeds in changing value when equal - * to expected + * repeated weakCompareAndSet succeeds in changing value when same as expected */ - public void testWeakCompareAndSet(){ - AtomicReferenceFieldUpdatera = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x"); + public void testWeakCompareAndSet() { + AtomicReferenceFieldUpdater a; + a = updaterFor("x"); x = one; - while(!a.weakCompareAndSet(this,one,two)); - while(!a.weakCompareAndSet(this,two,m4)); - assertEquals(m4,a.get(this)); - while(!a.weakCompareAndSet(this,m4,seven)); - assertEquals(seven,a.get(this)); + do {} while (!a.weakCompareAndSet(this, one, two)); + do {} while (!a.weakCompareAndSet(this, two, minusFour)); + assertSame(minusFour, a.get(this)); + do {} while (!a.weakCompareAndSet(this, minusFour, seven)); + assertSame(seven, a.get(this)); } /** * getAndSet returns previous value and sets to given value */ - public void testGetAndSet(){ - AtomicReferenceFieldUpdatera = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x"); + public void testGetAndSet() { + AtomicReferenceFieldUpdater a; + a = updaterFor("x"); x = one; - assertEquals(one,a.getAndSet(this, zero)); - assertEquals(zero,a.getAndSet(this,m10)); - assertEquals(m10,a.getAndSet(this,1)); + assertSame(one, a.getAndSet(this, zero)); + assertSame(zero, a.getAndSet(this, minusTen)); + assertSame(minusTen, a.getAndSet(this, one)); } }