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

Comparing jsr166/src/test/tck/AtomicReferenceArrayTest.java (file contents):
Revision 1.4 by dl, Sat Sep 20 18:20:07 2003 UTC vs.
Revision 1.8 by dl, Fri Jan 9 20:07:36 2004 UTC

# Line 1 | Line 1
1   /*
2 < * Written by members of JCP JSR-166 Expert Group and released to the
3 < * public domain. Use, modify, and redistribute this code in any way
4 < * without acknowledgement. Other contributors include Andrew Wright,
5 < * Jeffrey Hayes, Pat Fischer, Mike Judd.
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
5 > * Other contributors include Andrew Wright, Jeffrey Hayes,
6 > * Pat Fisher, Mike Judd.
7   */
8  
9   import junit.framework.*;
# Line 19 | Line 20 | public class AtomicReferenceArrayTest ex
20      }
21  
22      /**
23 <     *
23 >     * constructor creates array of given size with all elements null
24       */
25      public void testConstructor(){
26          AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(SIZE);
# Line 29 | Line 30 | public class AtomicReferenceArrayTest ex
30      }
31  
32      /**
33 <     *
33 >     * constructor with null array throws NPE
34 >     */
35 >    public void testConstructor2NPE() {
36 >        try {
37 >            Integer[] a = null;
38 >            AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(a);
39 >        } catch (NullPointerException success) {
40 >        } catch (Exception ex) {
41 >            unexpectedException();
42 >        }
43 >    }
44 >
45 >    /**
46 >     * constructor with array is of same size and has all elements
47 >     */
48 >    public void testConstructor2() {
49 >        Integer[] a = { two, one, three, four, seven};
50 >        AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(a);
51 >        assertEquals(a.length, ai.length());
52 >        for (int i = 0; i < a.length; ++i)
53 >            assertEquals(a[i], ai.get(i));
54 >    }
55 >
56 >
57 >    /**
58 >     * get and set for out of bound indices throw IndexOutOfBoundsException
59 >     */
60 >    public void testIndexing(){
61 >        AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(SIZE);
62 >        try {
63 >            ai.get(SIZE);
64 >        } catch(IndexOutOfBoundsException success){
65 >        }
66 >        try {
67 >            ai.get(-1);
68 >        } catch(IndexOutOfBoundsException success){
69 >        }
70 >        try {
71 >            ai.set(SIZE, null);
72 >        } catch(IndexOutOfBoundsException success){
73 >        }
74 >        try {
75 >            ai.set(-1, null);
76 >        } catch(IndexOutOfBoundsException success){
77 >        }
78 >    }
79 >
80 >    /**
81 >     * get returns the last value set at index
82       */
83      public void testGetSet(){
84          AtomicReferenceArray ai = new AtomicReferenceArray(SIZE);
# Line 44 | Line 93 | public class AtomicReferenceArrayTest ex
93      }
94  
95      /**
96 <     *
96 >     * compareAndSet succeeds in changing value if equal to expected else fails
97       */
98      public void testCompareAndSet(){
99          AtomicReferenceArray ai = new AtomicReferenceArray(SIZE);
# Line 61 | Line 110 | public class AtomicReferenceArrayTest ex
110      }
111  
112      /**
113 <     *
113 >     * compareAndSet in one thread enables another waiting for value
114 >     * to succeed
115 >     */
116 >    public void testCompareAndSetInMultipleThreads() {
117 >        final AtomicReferenceArray a = new AtomicReferenceArray(1);
118 >        a.set(0, one);
119 >        Thread t = new Thread(new Runnable() {
120 >                public void run() {
121 >                    while(!a.compareAndSet(0, two, three)) Thread.yield();
122 >                }});
123 >        try {
124 >            t.start();
125 >            assertTrue(a.compareAndSet(0, one, two));
126 >            t.join(LONG_DELAY_MS);
127 >            assertFalse(t.isAlive());
128 >            assertEquals(a.get(0), three);
129 >        }
130 >        catch(Exception e) {
131 >            unexpectedException();
132 >        }
133 >    }
134 >
135 >    /**
136 >     * repeated weakCompareAndSet succeeds in changing value when equal
137 >     * to expected
138       */
139      public void testWeakCompareAndSet(){
140          AtomicReferenceArray ai = new AtomicReferenceArray(SIZE);
# Line 76 | Line 149 | public class AtomicReferenceArrayTest ex
149      }
150  
151      /**
152 <     *
152 >     * getAndSet returns previous value and sets to given value at given index
153       */
154      public void testGetAndSet(){
155          AtomicReferenceArray ai = new AtomicReferenceArray(SIZE);
# Line 89 | Line 162 | public class AtomicReferenceArrayTest ex
162      }
163  
164      /**
165 <     *
165 >     * a deserialized serialized array holds same values
166       */
167      public void testSerialization() {
168          AtomicReferenceArray l = new AtomicReferenceArray(SIZE);
# Line 115 | Line 188 | public class AtomicReferenceArrayTest ex
188          }
189      }
190  
191 +
192   }

Diff Legend

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