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

Comparing jsr166/src/test/tck/CopyOnWriteArraySetTest.java (file contents):
Revision 1.2 by dl, Sun Sep 7 20:39:11 2003 UTC vs.
Revision 1.3 by dl, Sun Sep 14 20:42:40 2003 UTC

# Line 10 | Line 10 | import java.util.*;
10   import java.util.concurrent.*;
11   import java.io.*;
12  
13 < public class CopyOnWriteArraySetTest extends TestCase{
13 > public class CopyOnWriteArraySetTest extends JSR166TestCase {
14      
15      public static void main(String[] args) {
16          junit.textui.TestRunner.run (suite());  
# Line 20 | Line 20 | public class CopyOnWriteArraySetTest ext
20          return new TestSuite(CopyOnWriteArraySetTest.class);
21      }
22  
23 <    static CopyOnWriteArraySet fullSet(int n){
23 >    static CopyOnWriteArraySet populatedSet(int n){
24          CopyOnWriteArraySet a = new CopyOnWriteArraySet();
25          assertTrue(a.isEmpty());
26          for (int i = 0; i < n; ++i)
# Line 30 | Line 30 | public class CopyOnWriteArraySetTest ext
30          return a;
31      }
32  
33 +    public void testConstructor() {
34 +        CopyOnWriteArraySet a = new CopyOnWriteArraySet();
35 +        assertTrue(a.isEmpty());
36 +    }
37 +
38 +    public void testConstructor3() {
39 +        Integer[] ints = new Integer[SIZE];
40 +        for (int i = 0; i < SIZE-1; ++i)
41 +            ints[i] = new Integer(i);
42 +        CopyOnWriteArraySet a = new CopyOnWriteArraySet(Arrays.asList(ints));
43 +        for (int i = 0; i < SIZE; ++i)
44 +            assertTrue(a.contains(ints[i]));
45 +    }
46 +        
47 +
48      /**
49 <     *  Test to verify addAll correctly adds each element from the given collection
49 >     *   addAll correctly adds each element from the given collection
50       */
51      public void testAddAll(){
52 <        CopyOnWriteArraySet full = fullSet(3);
52 >        CopyOnWriteArraySet full = populatedSet(3);
53          Vector v = new Vector();
54 <        v.add(new Integer(3));
55 <        v.add(new Integer(4));
56 <        v.add(new Integer(5));
54 >        v.add(three);
55 >        v.add(four);
56 >        v.add(five);
57          full.addAll(v);
58          assertEquals(6, full.size());
59      }
60  
61      /**
62 <     *  Test to verify addAllAbsent adds each element from the given collection that did not
62 >     *   addAllAbsent adds each element from the given collection that did not
63       *  already exist in the List
64       */
65      public void testAddAll2(){
66 <        CopyOnWriteArraySet full = fullSet(3);
66 >        CopyOnWriteArraySet full = populatedSet(3);
67          Vector v = new Vector();
68 <        v.add(new Integer(3));
69 <        v.add(new Integer(4));
70 <        v.add(new Integer(1)); // will not add this element
68 >        v.add(three);
69 >        v.add(four);
70 >        v.add(one); // will not add this element
71          full.addAll(v);
72          assertEquals(5, full.size());
73      }
74  
75      /**
76 <     *  Test to verify addIfAbsent will not add the element if it already exists in the list
76 >     *   addIfAbsent will not add the element if it already exists in the list
77       */
78      public void testAdd2(){
79 <        CopyOnWriteArraySet full = fullSet(3);
80 <        full.add(new Integer(1));
79 >        CopyOnWriteArraySet full = populatedSet(3);
80 >        full.add(one);
81          assertEquals(3, full.size());
82      }
83  
84      /**
85 <     *  test to verify addIfAbsent correctly adds the element when it does not exist in the list
85 >     *   addIfAbsent correctly adds the element when it does not exist in the list
86       */
87      public void testAdd3(){
88 <        CopyOnWriteArraySet full = fullSet(3);
89 <        full.add(new Integer(3));
90 <        assertTrue(full.contains(new Integer(3)));
88 >        CopyOnWriteArraySet full = populatedSet(3);
89 >        full.add(three);
90 >        assertTrue(full.contains(three));
91      }
92  
93      /**
94 <     *  Test to verify clear correctly removes all elements from the list
94 >     *   clear correctly removes all elements from the list
95       */
96      public void testClear(){
97 <        CopyOnWriteArraySet full = fullSet(3);
97 >        CopyOnWriteArraySet full = populatedSet(3);
98          full.clear();
99          assertEquals(0, full.size());
100      }
101  
102      /**
103 <     *  Test to verify contains returns the correct values
103 >     *   contains returns the correct values
104       */
105      public void testContains(){
106 <        CopyOnWriteArraySet full = fullSet(3);
107 <        assertTrue(full.contains(new Integer(1)));
108 <        assertFalse(full.contains(new Integer(5)));
106 >        CopyOnWriteArraySet full = populatedSet(3);
107 >        assertTrue(full.contains(one));
108 >        assertFalse(full.contains(five));
109      }
110  
111      public void testEquals() {
112 <        CopyOnWriteArraySet a = fullSet(3);
113 <        CopyOnWriteArraySet b = fullSet(3);
112 >        CopyOnWriteArraySet a = populatedSet(3);
113 >        CopyOnWriteArraySet b = populatedSet(3);
114          assertTrue(a.equals(b));
115          assertTrue(b.equals(a));
116          assertEquals(a.hashCode(), b.hashCode());
117 <        a.add(new Integer(-1));
117 >        a.add(m1);
118          assertFalse(a.equals(b));
119          assertFalse(b.equals(a));
120 <        b.add(new Integer(-1));
120 >        b.add(m1);
121          assertTrue(a.equals(b));
122          assertTrue(b.equals(a));
123          assertEquals(a.hashCode(), b.hashCode());
# Line 110 | Line 125 | public class CopyOnWriteArraySetTest ext
125  
126      
127      /**
128 <     *  Test to verify containsAll returns the correct values
128 >     *   containsAll returns the correct values
129       */
130      public void testContainsAll(){
131 <        CopyOnWriteArraySet full = fullSet(3);
131 >        CopyOnWriteArraySet full = populatedSet(3);
132          Vector v = new Vector();
133 <        v.add(new Integer(1));
134 <        v.add(new Integer(2));
133 >        v.add(one);
134 >        v.add(two);
135          assertTrue(full.containsAll(v));
136 <        v.add(new Integer(6));
136 >        v.add(six);
137          assertFalse(full.containsAll(v));
138      }
139  
140      /**
141 <     *  Test to verify isEmpty returns the correct values
141 >     *   isEmpty returns the correct values
142       */
143      public void testIsEmpty(){
144          CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
145 <        CopyOnWriteArraySet full = fullSet(3);
145 >        CopyOnWriteArraySet full = populatedSet(3);
146          assertTrue(empty.isEmpty());
147          assertFalse(full.isEmpty());
148      }
149  
150      /**
151 <     *  Test to verify iterator() returns an iterator containing the elements of the list
151 >     *   iterator() returns an iterator containing the elements of the list
152       */
153      public void testIterator(){
154 <        CopyOnWriteArraySet full = fullSet(3);
154 >        CopyOnWriteArraySet full = populatedSet(3);
155          Iterator i = full.iterator();
156          int j;
157          for(j = 0; i.hasNext(); j++)
# Line 145 | Line 160 | public class CopyOnWriteArraySetTest ext
160      }
161  
162      public void testIteratorRemove () {
163 <        CopyOnWriteArraySet full = fullSet(3);
163 >        CopyOnWriteArraySet full = populatedSet(3);
164          Iterator it = full.iterator();
165          it.next();
166          try {
# Line 156 | Line 171 | public class CopyOnWriteArraySetTest ext
171      }
172  
173      public void testToString(){
174 <        CopyOnWriteArraySet full = fullSet(3);
174 >        CopyOnWriteArraySet full = populatedSet(3);
175          String s = full.toString();
176          for (int i = 0; i < 3; ++i) {
177              assertTrue(s.indexOf(String.valueOf(i)) >= 0);
# Line 165 | Line 180 | public class CopyOnWriteArraySetTest ext
180  
181  
182      /**
183 <     *  Test to verify removeAll correctly removes all elements from the given collection
183 >     *   removeAll correctly removes all elements from the given collection
184       */
185      public void testRemoveAll(){
186 <        CopyOnWriteArraySet full = fullSet(3);
186 >        CopyOnWriteArraySet full = populatedSet(3);
187          Vector v = new Vector();
188 <        v.add(new Integer(1));
189 <        v.add(new Integer(2));
188 >        v.add(one);
189 >        v.add(two);
190          full.removeAll(v);
191          assertEquals(1, full.size());
192      }
193  
194  
195      public void testRemove(){
196 <        CopyOnWriteArraySet full = fullSet(3);
197 <        full.remove(new Integer(1));
198 <        assertFalse(full.contains(new Integer(1)));
196 >        CopyOnWriteArraySet full = populatedSet(3);
197 >        full.remove(one);
198 >        assertFalse(full.contains(one));
199          assertEquals(2, full.size());
200      }
201  
202      /**
203 <     *  Test to verify size returns the correct values
203 >     *   size returns the correct values
204       */
205      public void testSize(){
206          CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
207 <        CopyOnWriteArraySet full = fullSet(3);
207 >        CopyOnWriteArraySet full = populatedSet(3);
208          assertEquals(3, full.size());
209          assertEquals(0, empty.size());
210      }
211  
212      /**
213 <     *  Test to verify toArray returns an Object array containing all elements from the list
213 >     *   toArray returns an Object array containing all elements from the list
214       */
215      public void testToArray(){
216 <        CopyOnWriteArraySet full = fullSet(3);
216 >        CopyOnWriteArraySet full = populatedSet(3);
217          Object[] o = full.toArray();
218          assertEquals(3, o.length);
219          assertEquals(0, ((Integer)o[0]).intValue());
# Line 207 | Line 222 | public class CopyOnWriteArraySetTest ext
222      }
223  
224      /**
225 <     *  test to verify toArray returns an Integer array containing all elements from the list
225 >     *   toArray returns an Integer array containing all elements from the list
226       */
227      public void testToArray2(){
228 <        CopyOnWriteArraySet full = fullSet(3);
228 >        CopyOnWriteArraySet full = populatedSet(3);
229          Integer[] i = new Integer[3];
230          i = (Integer[])full.toArray(i);
231          assertEquals(3, i.length);
# Line 224 | Line 239 | public class CopyOnWriteArraySetTest ext
239      // Exception tests
240  
241      /**
242 <     *  Test to verify toArray throws an ArrayStoreException when the given array
242 >     *   toArray throws an ArrayStoreException when the given array
243       *  can not store the objects inside the list
244       */
245      public void testToArray_ArrayStoreException(){
# Line 238 | Line 253 | public class CopyOnWriteArraySetTest ext
253      }
254  
255      public void testSerialization() {
256 <        CopyOnWriteArraySet q = fullSet(10);
256 >        CopyOnWriteArraySet q = populatedSet(SIZE);
257  
258          try {
259              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);

Diff Legend

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