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.18 by jsr166, Tue Dec 1 09:56:28 2009 UTC vs.
Revision 1.36 by jsr166, Wed Sep 20 00:41:13 2017 UTC

# Line 1 | Line 1
1   /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import java.util.concurrent.atomic.*;
10 < import junit.framework.*;
11 < import java.util.*;
9 > import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
10 >
11 > import junit.framework.Test;
12 > import junit.framework.TestSuite;
13  
14   public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase {
15      volatile Integer x = null;
16 +    protected volatile Integer protectedField;
17 +    private volatile Integer privateField;
18      Object z;
19      Integer w;
20 +    volatile int i;
21  
22      public static void main(String[] args) {
23 <        junit.textui.TestRunner.run(suite());
23 >        main(suite(), args);
24      }
25      public static Test suite() {
26          return new TestSuite(AtomicReferenceFieldUpdaterTest.class);
27      }
28  
29 +    static AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> updaterFor(String fieldName) {
30 +        return AtomicReferenceFieldUpdater.newUpdater
31 +            (AtomicReferenceFieldUpdaterTest.class, Integer.class, fieldName);
32 +    }
33 +
34      /**
35       * Construction with non-existent field throws RuntimeException
36       */
37      public void testConstructor() {
38          try {
39 <            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>
31 <                a = AtomicReferenceFieldUpdater.newUpdater
32 <                (AtomicReferenceFieldUpdaterTest.class, Integer.class, "y");
39 >            updaterFor("y");
40              shouldThrow();
41 <        } catch (RuntimeException success) {}
41 >        } catch (RuntimeException success) {
42 >            assertNotNull(success.getCause());
43 >        }
44      }
45  
37 –
46      /**
47 <     * construction with field not of given type throws RuntimeException
47 >     * construction with field not of given type throws ClassCastException
48       */
49      public void testConstructor2() {
50          try {
51 <            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>
44 <                a = AtomicReferenceFieldUpdater.newUpdater
45 <                (AtomicReferenceFieldUpdaterTest.class, Integer.class, "z");
51 >            updaterFor("z");
52              shouldThrow();
53 <        } catch (RuntimeException success) {}
53 >        } catch (ClassCastException success) {}
54      }
55  
56      /**
57 <     * Constructor with non-volatile field throws exception
57 >     * Constructor with non-volatile field throws IllegalArgumentException
58       */
59      public void testConstructor3() {
60          try {
61 <            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>
56 <                a = AtomicReferenceFieldUpdater.newUpdater
57 <                (AtomicReferenceFieldUpdaterTest.class, Integer.class, "w");
61 >            updaterFor("w");
62              shouldThrow();
63 <        } catch (RuntimeException success) {}
63 >        } catch (IllegalArgumentException success) {}
64      }
65  
66      /**
67 <     *  get returns the last value set or assigned
67 >     * Constructor with non-reference field throws ClassCastException
68       */
69 <    public void testGetSet() {
66 <        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
69 >    public void testConstructor4() {
70          try {
71 <            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
72 <        } catch (RuntimeException ok) {
73 <            return;
74 <        }
71 >            updaterFor("i");
72 >            shouldThrow();
73 >        } catch (ClassCastException success) {}
74 >    }
75 >
76 >    /**
77 >     * construction using private field from subclass throws RuntimeException
78 >     */
79 >    public void testPrivateFieldInSubclass() {
80 >        new NonNestmates.AtomicReferenceFieldUpdaterTestSubclass()
81 >            .checkPrivateAccess();
82 >    }
83 >
84 >    /**
85 >     * construction from unrelated class; package access is allowed,
86 >     * private access is not
87 >     */
88 >    public void testUnrelatedClassAccess() {
89 >        new NonNestmates().checkPackageAccess(this);
90 >        new NonNestmates().checkPrivateAccess(this);
91 >    }
92 >
93 >    /**
94 >     * get returns the last value set or assigned
95 >     */
96 >    public void testGetSet() {
97 >        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
98 >        a = updaterFor("x");
99          x = one;
100 <        assertSame(one,a.get(this));
101 <        a.set(this,two);
102 <        assertSame(two,a.get(this));
103 <        a.set(this,m3);
104 <        assertSame(m3,a.get(this));
100 >        assertSame(one, a.get(this));
101 >        a.set(this, two);
102 >        assertSame(two, a.get(this));
103 >        a.set(this, m3);
104 >        assertSame(m3, a.get(this));
105      }
106  
107      /**
108 <     *  get returns the last value lazySet by same thread
108 >     * get returns the last value lazySet by same thread
109       */
110      public void testGetLazySet() {
111 <        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
112 <        try {
86 <            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
87 <        } catch (RuntimeException ok) {
88 <            return;
89 <        }
111 >        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
112 >        a = updaterFor("x");
113          x = one;
114 <        assertSame(one,a.get(this));
115 <        a.lazySet(this,two);
116 <        assertSame(two,a.get(this));
117 <        a.lazySet(this,m3);
118 <        assertSame(m3,a.get(this));
114 >        assertSame(one, a.get(this));
115 >        a.lazySet(this, two);
116 >        assertSame(two, a.get(this));
117 >        a.lazySet(this, m3);
118 >        assertSame(m3, a.get(this));
119      }
120  
121      /**
122       * compareAndSet succeeds in changing value if equal to expected else fails
123       */
124      public void testCompareAndSet() {
125 <        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
126 <        try {
104 <            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
105 <        } catch (RuntimeException ok) {
106 <            return;
107 <        }
125 >        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
126 >        a = updaterFor("x");
127          x = one;
128 <        assertTrue(a.compareAndSet(this,one,two));
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));
133 <        assertTrue(a.compareAndSet(this,m4,seven));
134 <        assertSame(seven,a.get(this));
128 >        assertTrue(a.compareAndSet(this, one, two));
129 >        assertTrue(a.compareAndSet(this, two, m4));
130 >        assertSame(m4, a.get(this));
131 >        assertFalse(a.compareAndSet(this, m5, seven));
132 >        assertNotSame(seven, a.get(this));
133 >        assertTrue(a.compareAndSet(this, m4, seven));
134 >        assertSame(seven, a.get(this));
135      }
136  
137      /**
# Line 121 | Line 140 | public class AtomicReferenceFieldUpdater
140       */
141      public void testCompareAndSetInMultipleThreads() throws Exception {
142          x = one;
143 <        final AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
144 <        try {
126 <            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
127 <        } catch (RuntimeException ok) {
128 <            return;
129 <        }
143 >        final AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
144 >        a = updaterFor("x");
145  
146          Thread t = new Thread(new CheckedRunnable() {
147              public void realRun() {
# Line 138 | Line 153 | public class AtomicReferenceFieldUpdater
153          assertTrue(a.compareAndSet(this, one, two));
154          t.join(LONG_DELAY_MS);
155          assertFalse(t.isAlive());
156 <        assertSame(a.get(this), three);
156 >        assertSame(three, a.get(this));
157      }
158  
159      /**
# Line 146 | Line 161 | public class AtomicReferenceFieldUpdater
161       * to expected
162       */
163      public void testWeakCompareAndSet() {
164 <        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
165 <        try {
151 <            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
152 <        } catch (RuntimeException ok) {
153 <            return;
154 <        }
164 >        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
165 >        a = updaterFor("x");
166          x = one;
167 <        while (!a.weakCompareAndSet(this,one,two));
168 <        while (!a.weakCompareAndSet(this,two,m4));
169 <        assertSame(m4,a.get(this));
170 <        while (!a.weakCompareAndSet(this,m4,seven));
171 <        assertSame(seven,a.get(this));
167 >        do {} while (!a.weakCompareAndSet(this, one, two));
168 >        do {} while (!a.weakCompareAndSet(this, two, m4));
169 >        assertSame(m4, a.get(this));
170 >        do {} while (!a.weakCompareAndSet(this, m4, seven));
171 >        assertSame(seven, a.get(this));
172      }
173  
174      /**
175       * getAndSet returns previous value and sets to given value
176       */
177      public void testGetAndSet() {
178 <        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
179 <        try {
169 <            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
170 <        } catch (RuntimeException ok) {
171 <            return;
172 <        }
178 >        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
179 >        a = updaterFor("x");
180          x = one;
181 <        assertSame(one,a.getAndSet(this, zero));
182 <        assertSame(zero,a.getAndSet(this,m10));
183 <        assertSame(m10,a.getAndSet(this,1));
181 >        assertSame(one, a.getAndSet(this, zero));
182 >        assertSame(zero, a.getAndSet(this, m10));
183 >        assertSame(m10, a.getAndSet(this, 1));
184      }
185  
186   }

Diff Legend

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