ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/AtomicReferenceFieldUpdaterTest.java
(Generate patch)

Comparing jsr166/src/test/tck/AtomicReferenceFieldUpdaterTest.java (file contents):
Revision 1.34 by jsr166, Mon Nov 9 18:42:41 2015 UTC vs.
Revision 1.37 by jsr166, Wed Sep 20 00:59:17 2017 UTC

# Line 26 | Line 26 | public class AtomicReferenceFieldUpdater
26          return new TestSuite(AtomicReferenceFieldUpdaterTest.class);
27      }
28  
29 –    // for testing subclass access
30 –    static class AtomicReferenceFieldUpdaterTestSubclass extends AtomicReferenceFieldUpdaterTest {
31 –        public void checkPrivateAccess() {
32 –            try {
33 –                AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest,Integer> a =
34 –                    AtomicReferenceFieldUpdater.newUpdater
35 –                    (AtomicReferenceFieldUpdaterTest.class, Integer.class, "privateField");
36 –                shouldThrow();
37 –            } catch (RuntimeException success) {
38 –                assertNotNull(success.getCause());
39 –            }
40 –        }
41 –
42 –        public void checkCompareAndSetProtectedSub() {
43 –            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest,Integer> a =
44 –                AtomicReferenceFieldUpdater.newUpdater
45 –                (AtomicReferenceFieldUpdaterTest.class, Integer.class, "protectedField");
46 –            this.protectedField = one;
47 –            assertTrue(a.compareAndSet(this, one, two));
48 –            assertTrue(a.compareAndSet(this, two, m4));
49 –            assertSame(m4, a.get(this));
50 –            assertFalse(a.compareAndSet(this, m5, seven));
51 –            assertFalse(seven == a.get(this));
52 –            assertTrue(a.compareAndSet(this, m4, seven));
53 –            assertSame(seven, a.get(this));
54 –        }
55 –    }
56 –
57 –    static class UnrelatedClass {
58 –        public void checkPackageAccess(AtomicReferenceFieldUpdaterTest obj) {
59 –            obj.x = one;
60 –            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest,Integer> a =
61 –                AtomicReferenceFieldUpdater.newUpdater
62 –                (AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
63 –            assertSame(one, a.get(obj));
64 –            assertTrue(a.compareAndSet(obj, one, two));
65 –            assertSame(two, a.get(obj));
66 –        }
67 –
68 –        public void checkPrivateAccess(AtomicReferenceFieldUpdaterTest obj) {
69 –            try {
70 –                AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest,Integer> a =
71 –                    AtomicReferenceFieldUpdater.newUpdater
72 –                    (AtomicReferenceFieldUpdaterTest.class, Integer.class, "privateField");
73 –                throw new AssertionError("should throw");
74 –            } catch (RuntimeException success) {
75 –                assertNotNull(success.getCause());
76 –            }
77 –        }
78 –    }
79 –
29      static AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> updaterFor(String fieldName) {
30          return AtomicReferenceFieldUpdater.newUpdater
31              (AtomicReferenceFieldUpdaterTest.class, Integer.class, fieldName);
# Line 128 | Line 77 | public class AtomicReferenceFieldUpdater
77       * construction using private field from subclass throws RuntimeException
78       */
79      public void testPrivateFieldInSubclass() {
80 <        AtomicReferenceFieldUpdaterTestSubclass s =
81 <            new AtomicReferenceFieldUpdaterTestSubclass();
133 <        s.checkPrivateAccess();
80 >        new NonNestmates.AtomicReferenceFieldUpdaterTestSubclass()
81 >            .checkPrivateAccess();
82      }
83  
84      /**
# Line 138 | Line 86 | public class AtomicReferenceFieldUpdater
86       * private access is not
87       */
88      public void testUnrelatedClassAccess() {
89 <        new UnrelatedClass().checkPackageAccess(this);
90 <        new UnrelatedClass().checkPrivateAccess(this);
89 >        new NonNestmates().checkPackageAccess(this);
90 >        new NonNestmates().checkPrivateAccess(this);
91      }
92  
93      /**
# Line 171 | Line 119 | public class AtomicReferenceFieldUpdater
119      }
120  
121      /**
122 <     * compareAndSet succeeds in changing value if equal to expected else fails
122 >     * compareAndSet succeeds in changing value if same as expected else fails
123       */
124      public void testCompareAndSet() {
125          AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
# Line 181 | Line 129 | public class AtomicReferenceFieldUpdater
129          assertTrue(a.compareAndSet(this, two, m4));
130          assertSame(m4, a.get(this));
131          assertFalse(a.compareAndSet(this, m5, seven));
132 <        assertFalse(seven == a.get(this));
132 >        assertNotSame(seven, a.get(this));
133          assertTrue(a.compareAndSet(this, m4, seven));
134          assertSame(seven, a.get(this));
135      }
136  
137      /**
138 +     * compareAndSet succeeds in changing protected field value if
139 +     * same as expected else fails
140 +     */
141 +    public void testCompareAndSetProtectedInSubclass() {
142 +        new NonNestmates.AtomicReferenceFieldUpdaterTestSubclass()
143 +            .checkCompareAndSetProtectedSub();
144 +    }
145 +
146 +    /**
147       * compareAndSet in one thread enables another waiting for value
148       * to succeed
149       */
# Line 209 | Line 166 | public class AtomicReferenceFieldUpdater
166      }
167  
168      /**
169 <     * repeated weakCompareAndSet succeeds in changing value when equal
213 <     * to expected
169 >     * repeated weakCompareAndSet succeeds in changing value when same as expected
170       */
171      public void testWeakCompareAndSet() {
172          AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;

Diff Legend

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