[cvs] / jsr166 / src / test / tck / LinkedListTest.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/LinkedListTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.2, Sun Sep 7 20:39:11 2003 UTC revision 1.3, Sun Sep 14 20:42:40 2003 UTC
# Line 9  Line 9 
9  import java.util.*;  import java.util.*;
10  import java.util.concurrent.*;  import java.util.concurrent.*;
11    
12  public class LinkedListTest extends TestCase {  public class LinkedListTest extends JSR166TestCase {
   
     private static final int N = 10;  
     private static final long SHORT_DELAY_MS = 100;  
     private static final long MEDIUM_DELAY_MS = 1000;  
     private static final long LONG_DELAY_MS = 10000;  
   
13      public static void main(String[] args) {      public static void main(String[] args) {
14          junit.textui.TestRunner.run (suite());          junit.textui.TestRunner.run (suite());
15      }      }
# Line 28  Line 22 
22       * Create a queue of given size containing consecutive       * Create a queue of given size containing consecutive
23       * Integers 0 ... n.       * Integers 0 ... n.
24       */       */
25      private LinkedList fullQueue(int n) {      private LinkedList populatedQueue(int n) {
26          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
27          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
28          for(int i = 0; i < n; ++i)          for(int i = 0; i < n; ++i)
# Line 52  Line 46 
46    
47      public void testConstructor6(){      public void testConstructor6(){
48          try {          try {
49              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
50              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
51                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
52              LinkedList q = new LinkedList(Arrays.asList(ints));              LinkedList q = new LinkedList(Arrays.asList(ints));
53              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
54                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
55          }          }
56          finally {}          finally {}
# Line 74  Line 68 
68      }      }
69    
70      public void testSize() {      public void testSize() {
71          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
72          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
73              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
74              q.remove();              q.remove();
75          }          }
76          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
77              assertEquals(i, q.size());              assertEquals(i, q.size());
78              q.add(new Integer(i));              q.add(new Integer(i));
79          }          }
# Line 102  Line 96 
96    
97      public void testAdd(){      public void testAdd(){
98          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
99          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
100              assertEquals(i, q.size());              assertEquals(i, q.size());
101              assertTrue(q.add(new Integer(i)));              assertTrue(q.add(new Integer(i)));
102          }          }
# Line 120  Line 114 
114      public void testAddAll5(){      public void testAddAll5(){
115          try {          try {
116              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
117              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
118              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
119                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
120              LinkedList q = new LinkedList();              LinkedList q = new LinkedList();
121              assertFalse(q.addAll(Arrays.asList(empty)));              assertFalse(q.addAll(Arrays.asList(empty)));
122              assertTrue(q.addAll(Arrays.asList(ints)));              assertTrue(q.addAll(Arrays.asList(ints)));
123              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
124                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
125          }          }
126          finally {}          finally {}
127      }      }
128    
129      public void testPoll(){      public void testPoll(){
130          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
131          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
132              assertEquals(i, ((Integer)q.poll()).intValue());              assertEquals(i, ((Integer)q.poll()).intValue());
133          }          }
134          assertNull(q.poll());          assertNull(q.poll());
135      }      }
136    
137      public void testPeek(){      public void testPeek(){
138          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
139          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
140              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, ((Integer)q.peek()).intValue());
141              q.poll();              q.poll();
142              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
# Line 152  Line 146 
146      }      }
147    
148      public void testElement(){      public void testElement(){
149          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
150          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
151              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, ((Integer)q.element()).intValue());
152              q.poll();              q.poll();
153          }          }
# Line 165  Line 159 
159      }      }
160    
161      public void testRemove(){      public void testRemove(){
162          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
163          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
164              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, ((Integer)q.remove()).intValue());
165          }          }
166          try {          try {
# Line 177  Line 171 
171      }      }
172    
173      public void testRemoveElement(){      public void testRemoveElement(){
174          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
175          for (int i = 1; i < N; i+=2) {          for (int i = 1; i < SIZE; i+=2) {
176              assertTrue(q.remove(new Integer(i)));              assertTrue(q.remove(new Integer(i)));
177          }          }
178          for (int i = 0; i < N; i+=2) {          for (int i = 0; i < SIZE; i+=2) {
179              assertTrue(q.remove(new Integer(i)));              assertTrue(q.remove(new Integer(i)));
180              assertFalse(q.remove(new Integer(i+1)));              assertFalse(q.remove(new Integer(i+1)));
181          }          }
# Line 189  Line 183 
183      }      }
184    
185      public void testContains(){      public void testContains(){
186          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
187          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
188              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
189              q.poll();              q.poll();
190              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
# Line 198  Line 192 
192      }      }
193    
194      public void testClear(){      public void testClear(){
195          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
196          q.clear();          q.clear();
197          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
198          assertEquals(0, q.size());          assertEquals(0, q.size());
# Line 209  Line 203 
203      }      }
204    
205      public void testContainsAll(){      public void testContainsAll(){
206          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
207          LinkedList p = new LinkedList();          LinkedList p = new LinkedList();
208          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
209              assertTrue(q.containsAll(p));              assertTrue(q.containsAll(p));
210              assertFalse(p.containsAll(q));              assertFalse(p.containsAll(q));
211              p.add(new Integer(i));              p.add(new Integer(i));
# Line 220  Line 214 
214      }      }
215    
216      public void testRetainAll(){      public void testRetainAll(){
217          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
218          LinkedList p = fullQueue(N);          LinkedList p = populatedQueue(SIZE);
219          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
220              boolean changed = q.retainAll(p);              boolean changed = q.retainAll(p);
221              if (i == 0)              if (i == 0)
222                  assertFalse(changed);                  assertFalse(changed);
# Line 230  Line 224 
224                  assertTrue(changed);                  assertTrue(changed);
225    
226              assertTrue(q.containsAll(p));              assertTrue(q.containsAll(p));
227              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
228              p.remove();              p.remove();
229          }          }
230      }      }
231    
232      public void testRemoveAll(){      public void testRemoveAll(){
233          for (int i = 1; i < N; ++i) {          for (int i = 1; i < SIZE; ++i) {
234              LinkedList q = fullQueue(N);              LinkedList q = populatedQueue(SIZE);
235              LinkedList p = fullQueue(i);              LinkedList p = populatedQueue(i);
236              assertTrue(q.removeAll(p));              assertTrue(q.removeAll(p));
237              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
238              for (int j = 0; j < i; ++j) {              for (int j = 0; j < i; ++j) {
239                  Integer I = (Integer)(p.remove());                  Integer I = (Integer)(p.remove());
240                  assertFalse(q.contains(I));                  assertFalse(q.contains(I));
# Line 249  Line 243 
243      }      }
244    
245      public void testToArray(){      public void testToArray(){
246          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
247          Object[] o = q.toArray();          Object[] o = q.toArray();
248          Arrays.sort(o);          Arrays.sort(o);
249          for(int i = 0; i < o.length; i++)          for(int i = 0; i < o.length; i++)
# Line 257  Line 251 
251      }      }
252    
253      public void testToArray2(){      public void testToArray2(){
254          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
255          Integer[] ints = new Integer[N];          Integer[] ints = new Integer[SIZE];
256          ints = (Integer[])q.toArray(ints);          ints = (Integer[])q.toArray(ints);
257          Arrays.sort(ints);          Arrays.sort(ints);
258          for(int i = 0; i < ints.length; i++)          for(int i = 0; i < ints.length; i++)
# Line 266  Line 260 
260      }      }
261    
262      public void testIterator(){      public void testIterator(){
263          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
264          int i = 0;          int i = 0;
265          Iterator it = q.iterator();          Iterator it = q.iterator();
266          while(it.hasNext()) {          while(it.hasNext()) {
267              assertTrue(q.contains(it.next()));              assertTrue(q.contains(it.next()));
268              ++i;              ++i;
269          }          }
270          assertEquals(i, N);          assertEquals(i, SIZE);
271      }      }
272    
273      public void testIteratorOrdering() {      public void testIteratorOrdering() {
# Line 312  Line 306 
306    
307    
308      public void testToString(){      public void testToString(){
309          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
310          String s = q.toString();          String s = q.toString();
311          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
312              assertTrue(s.indexOf(String.valueOf(i)) >= 0);              assertTrue(s.indexOf(String.valueOf(i)) >= 0);
313          }          }
314      }      }
315    
316      public void testAddFirst(){      public void testAddFirst(){
317          LinkedList q = fullQueue(3);          LinkedList q = populatedQueue(3);
318          q.addFirst(new Integer(4));          q.addFirst(new Integer(4));
319          assertEquals(new Integer(4),q.get(0));          assertEquals(new Integer(4),q.get(0));
320      }      }
321    
322      public void testAddLast(){      public void testAddLast(){
323          LinkedList q = fullQueue(3);          LinkedList q = populatedQueue(3);
324          q.addLast(new Integer(3));          q.addLast(new Integer(3));
325          assertEquals(new Integer(3),q.get(3));          assertEquals(new Integer(3),q.get(3));
326      }      }
327    
328      public void testGetFirst() {      public void testGetFirst() {
329          LinkedList q = fullQueue(3);          LinkedList q = populatedQueue(3);
330          assertEquals(new Integer(0),q.getFirst());          assertEquals(new Integer(0),q.getFirst());
331      }      }
332    
333      public void testGetLast() {      public void testGetLast() {
334          LinkedList q = fullQueue(3);          LinkedList q = populatedQueue(3);
335          assertEquals(new Integer(2),q.getLast());          assertEquals(new Integer(2),q.getLast());
336      }      }
337    
338      public void testIndexOf(){      public void testIndexOf(){
339          LinkedList q = fullQueue(3);          LinkedList q = populatedQueue(3);
340          assertEquals(0,q.indexOf(new Integer(0)));          assertEquals(0,q.indexOf(new Integer(0)));
341          assertEquals(1,q.indexOf(new Integer(1)));          assertEquals(1,q.indexOf(new Integer(1)));
342          assertEquals(2,q.indexOf(new Integer(2)));          assertEquals(2,q.indexOf(new Integer(2)));
# Line 350  Line 344 
344      }      }
345    
346      public void testLastIndexOf(){      public void testLastIndexOf(){
347          LinkedList q = fullQueue(3);          LinkedList q = populatedQueue(3);
348          q.add(new Integer(2));          q.add(new Integer(2));
349          assertEquals(3,q.lastIndexOf(new Integer(2)));          assertEquals(3,q.lastIndexOf(new Integer(2)));
350          assertEquals(-1, q.lastIndexOf("not there"));          assertEquals(-1, q.lastIndexOf("not there"));
351      }      }
352    
353      public void testSet(){      public void testSet(){
354          LinkedList q = fullQueue(3);          LinkedList q = populatedQueue(3);
355          q.set(0,(new Integer(1)));          q.set(0,(new Integer(1)));
356          assertFalse(q.contains(new Integer(0)));          assertFalse(q.contains(new Integer(0)));
357          assertEquals(new Integer(1), q.get(0));          assertEquals(new Integer(1), q.get(0));

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8