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.3 by dl, Sun Sep 14 20:42:40 2003 UTC vs.
Revision 1.7 by dl, Thu Jan 8 01:29:46 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 18 | Line 19 | public class AtomicReferenceArrayTest ex
19          return new TestSuite(AtomicReferenceArrayTest.class);
20      }
21  
22 +    /**
23 +     * constructor creates array of given size with all elements null
24 +     */
25      public void testConstructor(){
26          AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(SIZE);
27          for (int i = 0; i < SIZE; ++i) {
# Line 25 | Line 29 | public class AtomicReferenceArrayTest ex
29          }
30      }
31  
32 +    /**
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);
85          for (int i = 0; i < SIZE; ++i) {
# Line 37 | Line 92 | public class AtomicReferenceArrayTest ex
92          }
93      }
94  
95 +    /**
96 +     * compareAndSet succeeds in changing value if equal to expected else fails
97 +     */
98      public void testCompareAndSet(){
99          AtomicReferenceArray ai = new AtomicReferenceArray(SIZE);
100          for (int i = 0; i < SIZE; ++i) {
# Line 51 | Line 109 | public class AtomicReferenceArrayTest ex
109          }
110      }
111  
112 +    /**
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);
141          for (int i = 0; i < SIZE; ++i) {
# Line 63 | Line 148 | public class AtomicReferenceArrayTest ex
148          }
149      }
150  
151 +    /**
152 +     * getAndSet returns previous value and sets to given value at given index
153 +     */
154      public void testGetAndSet(){
155          AtomicReferenceArray ai = new AtomicReferenceArray(SIZE);
156          for (int i = 0; i < SIZE; ++i) {
# Line 73 | Line 161 | public class AtomicReferenceArrayTest ex
161          }
162      }
163  
164 +    /**
165 +     * a deserialized serialized array holds same values
166 +     */
167      public void testSerialization() {
168          AtomicReferenceArray l = new AtomicReferenceArray(SIZE);
169          for (int i = 0; i < SIZE; ++i) {
# Line 93 | Line 184 | public class AtomicReferenceArrayTest ex
184                  assertEquals(r.get(i), l.get(i));
185              }
186          } catch(Exception e){
187 <            e.printStackTrace();
97 <            fail("unexpected exception");
187 >            unexpectedException();
188          }
189      }
190  

Diff Legend

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