|
1
4 package com.tctest;
5
6 import com.tc.object.config.ConfigVisitor;
7 import com.tc.object.config.DSOClientConfigHelper;
8 import com.tc.object.tx.ReadOnlyException;
9 import com.tc.simulator.app.ApplicationConfig;
10 import com.tc.simulator.listener.ListenerProvider;
11 import com.tc.util.Assert;
12
13 import java.lang.reflect.Method  ;
14 import java.util.AbstractList ;
15 import java.util.ArrayList ;
16 import java.util.Arrays ;
17 import java.util.Iterator ;
18 import java.util.LinkedList ;
19 import java.util.List ;
20 import java.util.ListIterator ;
21 import java.util.Stack ;
22 import java.util.Vector ;
23
24
27 public class GenericList15TestApp extends GenericTestApp {
28
29 public GenericList15TestApp(String appId, ApplicationConfig cfg, ListenerProvider listenerProvider) {
30 super(appId, cfg, listenerProvider, List .class);
31 }
32
33 protected Object getTestObject(String testName) {
34 List lists = (List ) sharedMap.get("lists");
35 return lists.iterator();
36 }
37
38 protected void setupTestObject(String testName) {
39 List lists = new ArrayList ();
40 lists.add(new LinkedList ());
41 lists.add(new ArrayList ());
42 lists.add(new Vector ());
43 lists.add(new Stack ());
44
45 sharedMap.put("lists", lists);
46 sharedMap.put("arrayforLinkedList", new Object [2]);
47 sharedMap.put("arrayforArrayList", new Object [2]);
48 sharedMap.put("arrayforVector", new Object [2]);
49 sharedMap.put("arrayforStack", new Object [2]);
50 }
51
52 void testBasicAdd(List list, boolean validate) {
53 if (validate) {
54 assertSingleElement(list, "rollin in my 6-4");
55 } else {
56 synchronized (list) {
57 boolean added = list.add("rollin in my 6-4");
58 Assert.assertTrue(added);
59 }
60 }
61 }
62
63 void testVectorSetSizeGrow(List list, boolean validate) {
64 if (!(list instanceof Vector )) { return; }
65
66 int size = 5;
67 Vector v = (Vector ) list;
68
69 if (validate) {
70 Assert.assertEquals("start", v.get(0));
71 for (int i = 1; i < size; i++) {
72 Object val = v.get(i);
73 Assert.assertNull("element " + i + " is " + val, val);
74 }
75 Assert.assertEquals("end", v.get(size));
76 } else {
77 synchronized (v) {
78 v.add("start");
79 v.setSize(size);
80 v.add("end");
81 }
82 }
83 }
84
85 void testVectorSetSizeShrink(List list, boolean validate) {
86 if (!(list instanceof Vector )) { return; }
87
88 Vector v = (Vector ) list;
89
90 if (validate) {
91 Assert.assertEquals("start", v.get(0));
92 Assert.assertEquals("end", v.get(1));
93 } else {
94 synchronized (v) {
95 v.add("start");
96 v.add("ho hum");
97 v.add("ho hum2");
98 v.add("ho hum3");
99
100 v.setSize(1);
101 v.add("end");
102 }
103 }
104 }
105
106 void testVectorAddElement(List list, boolean validate) {
107 if (!(list instanceof Vector )) { return; }
108
109 Vector vector = (Vector ) list;
110
111 if (validate) {
112 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element" }), vector);
113 } else {
114 synchronized (vector) {
115 vector.addElement("first element");
116 vector.addElement("second element");
117 }
118 }
119 }
120
121 void testVectorRetainAll(List list, boolean validate) {
122 if (!(list instanceof Vector )) { return; }
123
124 Vector vector = (Vector ) list;
125
126 if (validate) {
127 assertListsEqual(Arrays.asList(new Object [] { "second element" }), vector);
128 } else {
129 synchronized (vector) {
130 vector.addElement("first element");
131 vector.addElement("second element");
132 vector.addElement("third element");
133
134 List retainList = new ArrayList (1);
135 retainList.add("second element");
136
137 vector.retainAll(retainList);
138 }
139 }
140 }
141
142 void testVectorRemoveAll(List list, boolean validate) {
143 if (!(list instanceof Vector )) { return; }
144
145 Vector vector = (Vector ) list;
146
147 if (validate) {
148 assertListsEqual(Arrays.asList(new Object [] { "first element", "third element" }), vector);
149 } else {
150 synchronized (vector) {
151 vector.addElement("first element");
152 vector.addElement("second element");
153 vector.addElement("third element");
154
155 List removeList = new ArrayList (1);
156 removeList.add("second element");
157 vector.removeAll(removeList);
158 }
159 }
160 }
161
162 void testVectorRemoveAllElements(List list, boolean validate) {
163 if (!(list instanceof Vector )) { return; }
164
165 Vector vector = (Vector ) list;
166
167 if (validate) {
168 assertEmptyList(vector);
169 } else {
170 synchronized (vector) {
171 vector.addElement("first element");
172 vector.addElement("second element");
173 vector.addElement("third element");
174
175 vector.removeAllElements();
176 }
177 }
178 }
179
180 void testVectorSetElementAt(List list, boolean validate) {
181 if (!(list instanceof Vector )) { return; }
182
183 Vector vector = (Vector ) list;
184
185 if (validate) {
186 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element", "third element" }), vector);
187 } else {
188 synchronized (vector) {
189 vector.addElement("first element");
190 vector.addElement(null);
191 vector.addElement("third element");
192
193 vector.setElementAt("second element", 1);
194 }
195 }
196 }
197
198 void testVectorInsertElementAt(List list, boolean validate) {
199 if (!(list instanceof Vector )) { return; }
200
201 Vector vector = (Vector ) list;
202
203 if (validate) {
204 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element", "third element" }), vector);
205 } else {
206 synchronized (vector) {
207 vector.addElement("first element");
208 vector.addElement("third element");
209
210 vector.insertElementAt("second element", 1);
211 }
212 }
213 }
214
215 void testLinkedListRemoveFirst(List list, boolean validate) {
216 if (!(list instanceof LinkedList )) { return; }
217
218 LinkedList linkedList = (LinkedList ) list;
219
220 if (validate) {
221 assertSingleElement(linkedList, "teck");
222 } else {
223 synchronized (linkedList) {
224 linkedList.add("timmy");
225 linkedList.add("teck");
226 }
227
228 synchronized (linkedList) {
229 linkedList.removeFirst();
230 }
231 }
232 }
233
234 void testLinkedListRemoveLast(List list, boolean validate) {
235 if (!(list instanceof LinkedList )) { return; }
236
237 LinkedList linkedList = (LinkedList ) list;
238
239 if (validate) {
240 assertSingleElement(linkedList, "timmy");
241 } else {
242 synchronized (linkedList) {
243 linkedList.add("timmy");
244 linkedList.add("teck");
245 }
246
247 synchronized (linkedList) {
248 linkedList.removeLast();
249 }
250 }
251 }
252
253 void testLinkedListAddFirst(List list, boolean validate) {
254 if (!(list instanceof LinkedList )) { return; }
255
256 LinkedList linkedList = (LinkedList ) list;
257
258 if (validate) {
259 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element" }), list);
260 } else {
261 synchronized (linkedList) {
262 linkedList.add("second element");
263 }
264
265 synchronized (linkedList) {
266 linkedList.addFirst("first element");
267 }
268 }
269 }
270
271 void testLinkedListAddLast(List list, boolean validate) {
272 if (!(list instanceof LinkedList )) { return; }
273
274 LinkedList linkedList = (LinkedList ) list;
275
276 if (validate) {
277 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element" }), list);
278 } else {
279 synchronized (linkedList) {
280 linkedList.add("first element");
281 }
282
283 synchronized (linkedList) {
284 linkedList.addLast("second element");
285 }
286 }
287 }
288
289 void testLinkedListPoll(List list, boolean validate) {
290 if (!(list instanceof LinkedList )) { return; }
291
292 LinkedList linkedList = (LinkedList ) list;
293
294 if (validate) {
295 assertListsEqual(Arrays.asList(new Object [] { "second element" }), list);
296 } else {
297 synchronized (linkedList) {
298 linkedList.add("first element");
299 linkedList.add("second element");
300 }
301
302 synchronized (linkedList) {
303 Object o = linkedList.poll();
304 Assert.assertEquals("first element", o);
305 }
306 }
307 }
308
309 void testLinkedListOffer(List list, boolean validate) {
310 if (!(list instanceof LinkedList )) { return; }
311
312 LinkedList linkedList = (LinkedList ) list;
313
314 if (validate) {
315 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element" }), list);
316 } else {
317 synchronized (linkedList) {
318 linkedList.add("first element");
319 }
320
321 synchronized (linkedList) {
322 linkedList.offer("second element");
323 }
324 }
325 }
326
327 void testBasicAddNull(List list, boolean validate) {
328 if (validate) {
329 assertListsEqual(Arrays.asList(new Object [] { null, null, "my cat hates you", null }), list);
330 } else {
331 synchronized (list) {
332 boolean added;
333 added = list.add(null);
334 Assert.assertTrue(added);
335 added = list.add(null);
336 Assert.assertTrue(added);
337 added = list.add("my cat hates you");
338 Assert.assertTrue(added);
339 added = list.add(null);
340 Assert.assertTrue(added);
341 }
342 }
343 }
344
345 void testBasicAddAt(List list, boolean validate) {
346 if (validate) {
347 assertListsEqual(Arrays.asList(new Object [] { "1", "2", "3", "4" }), list);
348 } else {
349 synchronized (list) {
350 list.add(0, "2");
351 }
352 synchronized (list) {
353 list.add(0, "1");
354 }
355 synchronized (list) {
356 list.add(2, "4");
357 }
358 synchronized (list) {
359 list.add(2, "3");
360 }
361 }
362 }
363
364 void testAdd(List list, boolean validate) {
365 if (validate) {
366 assertListsEqual(Arrays.asList(new Object [] { "element" }), list);
367 } else {
368 synchronized (list) {
369 list.add("element");
370 }
371 }
372 }
373
374 void testAddAll(List list, boolean validate) {
375 if (validate) {
376 assertListsEqual(Arrays.asList(new Object [] { "patty", "calahan", "was", "here" }), list);
377 } else {
378 List toAdd = new ArrayList ();
379 toAdd.add("patty");
380 toAdd.add("calahan");
381 toAdd.add("was");
382 toAdd.add("here");
383
384 synchronized (list) {
385 list.addAll(toAdd);
386 }
387 }
388 }
389
390 void testAddAllAt(List list, boolean validate) {
391 if (validate) {
392 assertListsEqual(Arrays.asList(new Object [] { "uno", "dos", "tres", "catorce?" }), list);
393 } else {
394 synchronized (list) {
395 list.add("uno");
396 }
397
398 List toAdd = new ArrayList ();
399 toAdd.add("dos");
400 toAdd.add("tres");
401 toAdd.add("catorce?");
402
403 synchronized (list) {
404 list.addAll(1, toAdd);
405 }
406 }
407 }
408
409 void testClear(List list, boolean validate) {
410 if (validate) {
411 assertEmptyList(list);
412 } else {
413 synchronized (list) {
414 list.add("clear me baby");
415 list.clear();
416 }
417
418 synchronized (list) {
419 list.add("clear me baby one more time");
420 }
421
422 synchronized (list) {
423 list.clear();
424 }
425 }
426 }
427
428 void testSetElementAt(List list, boolean validate) {
429 if (validate) {
430 assertSingleElement(list, "new");
431 } else {
432 synchronized (list) {
433 list.add("orig");
434 }
435
436 synchronized (list) {
437 list.set(0, "new");
438 }
439 }
440 }
441
442 void testRemoveAt(List list, boolean validate) {
443 if (validate) {
444 String item0 = (String ) list.get(0);
445 String item1 = (String ) list.get(1);
446 Assert.assertEquals("value", item0);
447 Assert.assertEquals("different value", item1);
448 } else {
449 synchronized (list) {
450 list.add("value");
451 list.add("different value");
452 list.add("value");
453 }
454
455 synchronized (list) {
456 Object prev = list.remove(2);
457 Assert.assertEquals("value", prev);
458 }
459 }
460 }
461
462 void testRemoveNull1(List list, boolean validate) {
463 if (validate) {
464 assertListsEqual(Arrays.asList(new Object [] { "first element", null, "third element" }), list);
465 } else {
466 synchronized (list) {
467 list.add("first element");
468 list.add(null);
469 list.add(null);
470 list.add("third element");
471 }
472 synchronized (list) {
473 list.remove(null);
474 }
475 }
476 }
477
478 void testRemoveNull2(List list, boolean validate) {
479 if (validate) {
480 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element" }), list);
481 } else {
482 synchronized (list) {
483 list.add("first element");
484 list.add(null);
485 list.add("second element");
486 list.add(null);
487 }
488 synchronized (list) {
489 list.remove(null);
490 list.remove(null);
491 }
492 }
493 }
494
495 void testSubList(List list, boolean validate) {
496 if (validate) {
497 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element", "third element",
498 "fourth element" }), list);
499 } else {
500 synchronized (list) {
501 list.add("first element");
502 list.add("third element");
503 list.add("fourth element");
504 }
505 List subList = list.subList(1, 2);
506 ListIterator listIterator = subList.listIterator();
507 synchronized (list) {
508 listIterator.add("second element");
509 }
510 }
511 }
512
513 void testRemoveAll(List list, boolean validate) {
514 if (validate) {
515 assertEmptyList(list);
516 } else {
517 synchronized (list) {
518 list.add("first element");
519 list.add("second element");
520 }
521 List removeList = new ArrayList (2);
522 removeList.add("first element");
523 removeList.add("second element");
524 synchronized (list) {
525 list.removeAll(removeList);
526 }
527 }
528 }
529
530 void testRemoveRange(List list, boolean validate) {
531 if (validate) {
532 assertListsEqual(Arrays.asList(new Object [] { "first element", "fourth element" }), list);
533 } else {
534 synchronized (list) {
535 list.add("first element");
536 list.add("second element");
537 list.add("third element");
538 list.add("fourth element");
539 }
540 Class listClass = AbstractList .class;
541 Class [] parameterType = new Class [2];
542 parameterType[0] = Integer.TYPE;
543 parameterType[1] = Integer.TYPE;
544
545 try {
546 synchronized (list) {
547 Method m = listClass.getDeclaredMethod("removeRange", parameterType);
548 m.setAccessible(true); m.invoke(list, new Object [] { new Integer (1), new Integer (3) });
551 }
552 } catch (Exception e) {
553 }
555 }
556 }
557
558 void testToArray(List list, boolean validate) {
559 Object [] array = getArray(list);
560
561 if (validate) {
562 assertListsEqual(Arrays.asList(array), list);
563 } else {
564 synchronized (list) {
565 list.add("first element");
566 list.add("second element");
567 }
568 synchronized (array) {
569 Object [] returnArray = list.toArray(array);
570 Assert.assertTrue(returnArray == array);
571 }
572 }
573 }
574
575 void testListIteratorSet1(List list, boolean validate) {
577 if (validate) {
578 assertListsEqual(Arrays.asList(new Object [] { "modified first element", "second element", "third element" }),
579 list);
580 } else {
581 synchronized (list) {
582 list.add("first element");
583 list.add("second element");
584 list.add("third element");
585 }
586 synchronized (list) {
587 ListIterator lIterator = list.listIterator();
588 lIterator.next();
589 lIterator.set("modified first element");
590 }
591 }
592 }
593
594 void testListIteratorSet2(List list, boolean validate) {
595 if (validate) {
596 assertListsEqual(Arrays.asList(new Object [] { "first element", "modified second element", "third element" }),
597 list);
598 } else {
599 synchronized (list) {
600 list.add("first element");
601 list.add("second element");
602 list.add("third element");
603 }
604 synchronized (list) {
605 ListIterator lIterator = list.listIterator();
606 lIterator.next();
607 lIterator.next();
608 lIterator.set("modified second element");
609 }
610 }
611 }
612
613 void testListIteratorSetRemove1(List list, boolean validate) {
614 if (validate) {
615 assertListsEqual(Arrays.asList(new Object [] { "modified first element", "third element" }), list);
616 } else {
617 synchronized (list) {
618 list.add("first element");
619 list.add("second element");
620 list.add("third element");
621 }
622 synchronized (list) {
623 ListIterator lIterator = list.listIterator();
624 lIterator.next();
625 lIterator.next();
626 lIterator.remove();
627 lIterator.previous();
628 lIterator.set("modified first element");
629 }
630 }
631 }
632
633 void testListIteratorSetRemove2(List list, boolean validate) {
634 if (validate) {
635 assertListsEqual(Arrays.asList(new Object [] { "first element", "modified second element" }), list);
636 } else {
637 synchronized (list) {
638 list.add("first element");
639 list.add("second element");
640 list.add("third element");
641 }
642 synchronized (list) {
643 ListIterator lIterator = list.listIterator();
644 lIterator.next();
645 lIterator.next();
646 lIterator.set("modified second element");
647 lIterator.next();
648 lIterator.remove();
649 }
650 }
651 }
652
653 void testListIteratorDuplicateElementRemove(List list, boolean validate) {
654 if (validate) {
655 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element" }), list);
656 } else {
657 synchronized (list) {
658 list.add("first element");
659 list.add("second element");
660 list.add("first element");
661 }
662 synchronized (list) {
663 ListIterator lIterator = list.listIterator();
664 lIterator.next();
665 lIterator.next();
666 lIterator.next();
667 lIterator.remove();
668 }
669 }
670 }
671
672 void testListIteratorAdd1(List list, boolean validate) {
673 if (validate) {
674 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element", "third element" }), list);
675 } else {
677 synchronized (list) {
678 list.add("second element");
679 list.add("third element");
680 }
681 synchronized (list) {
682 ListIterator lIterator = list.listIterator();
683 lIterator.add("first element");
684 }
685 }
686 }
687
688 void testListIteratorAdd2(List list, boolean validate) {
689 if (validate) {
690 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element", "third element" }), list);
691 } else {
692 synchronized (list) {
693 list.add("first element");
694 list.add("third element");
695 }
696 synchronized (list) {
697 ListIterator lIterator = list.listIterator();
698 lIterator.next();
699 lIterator.add("second element");
700 }
701 }
702 }
703
704 void testListIteratorAddSet1(List list, boolean validate) {
705 if (validate) {
706 assertListsEqual(Arrays.asList(new Object [] { "modified first element", "second element", "third element" }),
707 list);
708 } else {
709 synchronized (list) {
710 list.add("second element");
711 list.add("third element");
712 }
713 synchronized (list) {
714 ListIterator lIterator = list.listIterator();
715 lIterator.add("first element");
716 lIterator.previous();
717 lIterator.set("modified first element");
718 }
719 }
720 }
721
722 void testListIteratorAddSet2(List list, boolean validate) {
723 if (validate) {
724 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element", "modified third element" }),
725 list);
726 } else {
727 synchronized (list) {
728 list.add("first element");
729 list.add("third element");
730 }
731 synchronized (list) {
732 ListIterator lIterator = list.listIterator();
733 lIterator.next();
734 lIterator.add("second element");
735 lIterator.next();
736 lIterator.set("modified third element");
737 }
738 }
739 }
740
741 void testListIteratorAddSet3(List list, boolean validate) {
742 if (validate) {
743 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element", "modified third element",
744 "fourth element" }), list);
745 } else {
746 synchronized (list) {
747 list.add("first element");
748 list.add("second element");
749 list.add("fourth element");
750 }
751 synchronized (list) {
752 ListIterator lIterator = list.listIterator(1);
753 lIterator.next();
754 lIterator.add("third element");
755 lIterator.previous();
756 lIterator.set("modified third element");
757 }
758 }
759 }
760
761 void testListIteratorAddNull(List list, boolean validate) {
762 if (validate) {
763 assertListsEqual(Arrays.asList(new Object [] { null, null, "third element" }), list);
764 } else {
765 synchronized (list) {
766 ListIterator lIterator = list.listIterator();
767 lIterator.add(null);
768 lIterator.add(null);
769 lIterator.add("third element");
770 }
771 }
772 }
773
774 void testListIteratorAddRemove(List list, boolean validate) {
775 if (validate) {
776 assertListsEqual(Arrays.asList(new Object [] { "second element", "third element" }), list);
777 } else {
778 synchronized (list) {
779 list.add("second element");
780 list.add("third element");
781 }
782 synchronized (list) {
783 ListIterator lIterator = list.listIterator();
784 lIterator.add("first element");
785 lIterator.previous();
786 lIterator.remove();
787 }
788 }
789 }
790
791 void testListIteratorRemoveNull(List list, boolean validate) {
792 if (validate) {
793 assertListsEqual(Arrays.asList(new Object [] { "first element", null, "third element" }), list);
794 } else {
795 synchronized (list) {
796 list.add("first element");
797 list.add(null);
798 list.add(null);
799 list.add("third element");
800 }
801 synchronized (list) {
802 ListIterator lIterator = list.listIterator();
803 lIterator.next();
804 lIterator.next();
805 lIterator.remove();
806 }
807 }
808 }
809
810 void testReadOnlyAdd(List list, boolean validate) {
812 if (list instanceof Vector ) { return; }
813
814 if (validate) {
815 assertEmptyList(list);
816 } else {
817 synchronized (list) {
818 try {
819 list.add("first element");
820 throw new AssertionError ("Should have thrown a ReadOnlyException");
821 } catch (ReadOnlyException t) {
822 }
824 }
825 }
826 }
827
828 void testReadOnlySet(List list, boolean validate) {
829 if (list instanceof Vector ) { return; }
830
831 if (validate) {
832 assertEmptyList(list);
833 } else {
834 synchronized (list) {
835 try {
836 list.set(0, "first element");
837 throw new AssertionError ("Should have thrown a ReadOnlyException");
838 } catch (ReadOnlyException t) {
839 }
841 }
842 }
843 }
844
845 void testSetUpRemove(List list, boolean validate) {
847 if (list instanceof Vector ) { return; }
848
849 if (validate) {
850 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element" }), list);
851 } else {
852 synchronized (list) {
853 list.add("first element");
854 list.add("second element");
855 }
856 tryReadOnlyRemove(list);
857 }
858 }
859
860 private void tryReadOnlyRemove(List list) {
862 synchronized (list) {
863 try {
864 list.remove("second element");
865 throw new AssertionError ("Should have thrown a ReadOnlyException");
866 } catch (ReadOnlyException t) {
867 }
869 }
870 }
871
872 void testSetUpToArray(List list, boolean validate) {
873 if (list instanceof Vector ) { return; }
874
875 Object [] array = getArray(list);
876 if (validate) {
877 assertEmptyObjectArray(array);
878 } else {
879 synchronized (list) {
880 list.add("first element");
881 list.add("second element");
882 }
883 tryReadOnlyToArray(list);
884 }
885 }
886
887 void tryReadOnlyToArray(List list) {
888 Object [] array = getArray(list);
889 synchronized (array) {
890 try {
891 Object [] returnArray = list.toArray(array);
892 Assert.assertTrue(returnArray == array);
893 throw new AssertionError ("Should have thrown a ReadOnlyException");
894 } catch (ReadOnlyException t) {
895 }
897 }
898 }
899
900 void testSetUpIteratorRemove(List list, boolean validate) {
902 if (list instanceof Vector ) { return; }
903
904 if (validate) {
905 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element" }), list);
906 } else {
907 synchronized (list) {
908 list.add("first element");
909 list.add("second element");
910 }
911 tryReadOnlyIteratorRemove(list);
912 }
913 }
914
915 private void tryReadOnlyIteratorRemove(List list) {
917 synchronized (list) {
918 try {
919 Iterator iterator = list.iterator();
920 iterator.next();
921 iterator.remove();
922 throw new AssertionError ("Should have thrown a ReadOnlyException");
923 } catch (ReadOnlyException t) {
924 }
926 }
927 }
928
929 void testSetUpClear(List list, boolean validate) {
931 if (list instanceof Vector ) { return; }
932
933 if (validate) {
934 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element" }), list);
935 } else {
936 synchronized (list) {
937 list.add("first element");
938 list.add("second element");
939 }
940 tryReadOnlyClear(list);
941 }
942 }
943
944 private void tryReadOnlyClear(List list) {
946 synchronized (list) {
947 try {
948 list.clear();
949 throw new AssertionError ("Should have thrown a ReadOnlyException");
950 } catch (ReadOnlyException t) {
951 }
953 }
954 }
955
956 void testSetUpRetainAll(List list, boolean validate) {
958 if (list instanceof Vector ) { return; }
959
960 if (validate) {
961 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element" }), list);
962 } else {
963 synchronized (list) {
964 list.add("first element");
965 list.add("second element");
966 }
967 tryReadOnlyRetainAll(list);
968 }
969 }
970
971 private void tryReadOnlyRetainAll(List list) {
973 synchronized (list) {
974 List toRetain = new ArrayList ();
975 toRetain.add("first element");
976 try {
977 list.retainAll(toRetain);
978 throw new AssertionError ("Should have thrown a ReadOnlyException");
979 } catch (ReadOnlyException t) {
980 }
982 }
983 }
984
985 void testSetUpRemoveAll(List list, boolean validate) {
987 if (list instanceof Vector ) { return; }
988
989 if (validate) {
990 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element" }), list);
991 } else {
992 synchronized (list) {
993 list.add("first element");
994 list.add("second element");
995 }
996 tryReadOnlyRemoveAll(list);
997 }
998 }
999
1000 private void tryReadOnlyRemoveAll(List list) {
1002 synchronized (list) {
1003 List toRemove = new ArrayList ();
1004 toRemove.add("first element");
1005 try {
1006 list.removeAll(toRemove);
1007 throw new AssertionError ("Should have thrown a ReadOnlyException");
1008 } catch (ReadOnlyException e) {
1009 }
1011 }
1012 }
1013
1014 void testListIteratorReadOnlyAdd(List list, boolean validate) {
1015 if (list instanceof Vector ) { return; }
1016
1017 if (validate) {
1018 assertEmptyList(list);
1019 } else {
1020 synchronized (list) {
1021 ListIterator lIterator = list.listIterator();
1022 try {
1023 lIterator.add("first element");
1024 throw new AssertionError ("Should have thrown a ReadOnlyException");
1025 } catch (ReadOnlyException e) {
1026 }
1028 }
1029 }
1030 }
1031
1032 void testCollectionsAddAll(List list, boolean validate) {
1033 if (validate) {
1034 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element", "third element" }), list);
1035 } else {
1036 synchronized (list) {
1037 list.addAll(Arrays.asList(new Object [] { "first element", "second element", "third element" }));
1038 }
1039 }
1040 }
1041
1042 void testIteratorRemove(List list, boolean validate) {
1044 if (validate) {
1045 assertListsEqual(Arrays.asList(new Object [] { "second element" }), list);
1046 } else {
1047 synchronized (list) {
1048 list.add("first element");
1049 list.add("second element");
1050 }
1051 synchronized (list) {
1052 Iterator iterator = list.iterator();
1053 Assert.assertEquals(true, iterator.hasNext());
1054 iterator.next();
1055 iterator.remove();
1056 }
1057 }
1058 }
1059
1060 void testIteratorDuplicateElementRemove(List list, boolean validate) {
1061 if (validate) {
1062 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element" }), list);
1063 } else {
1064 synchronized (list) {
1065 list.add("first element");
1066 list.add("second element");
1067 list.add("first element");
1068 }
1069 synchronized (list) {
1070 Iterator iterator = list.iterator();
1071 Assert.assertEquals(true, iterator.hasNext());
1072 iterator.next();
1073 iterator.next();
1074 iterator.next();
1075 iterator.remove();
1076 }
1077 }
1078 }
1079
1080 void testIteratorRemoveNull(List list, boolean validate) {
1081 if (validate) {
1082 assertListsEqual(Arrays.asList(new Object [] { "first element", null, "second element" }), list);
1083 } else {
1084 synchronized (list) {
1085 list.add("first element");
1086 list.add(null);
1087 list.add(null);
1088 list.add("second element");
1089 }
1090 synchronized (list) {
1091 Iterator iterator = list.iterator();
1092 Assert.assertEquals(true, iterator.hasNext());
1093 iterator.next();
1094 iterator.next();
1095 iterator.remove();
1096 }
1097 }
1098 }
1099
1100 void testStackPush(List list, boolean validate) {
1102 if (!(list instanceof Stack )) { return; }
1103
1104 if (validate) {
1105 assertListsEqual(Arrays.asList(new Object [] { "first element", "second element" }), list);
1106 } else {
1107 synchronized (list) {
1108 Stack s = (Stack ) list;
1109 s.push("first element");
1110 s.push("second element");
1111 }
1112 }
1113 }
1114
1115 void testStackPop(List list, boolean validate) {
1116 if (!(list instanceof Stack )) { return; }
1117
1118 if (validate) {
1119 assertListsEqual(Arrays.asList(new Object [] { "first element" }), list);
1120 } else {
1121 Stack s = (Stack ) list;
1122 synchronized (list) {
1123 s.push("first element");
1124 s.push("second element");
1125 }
1126 synchronized (list) {
1127 Object o = s.pop();
1128 Assert.assertEquals("second element", o);
1129 }
1130 }
1131 }
1132
1133 private Object [] getArray(List list) {
1134 if (list instanceof LinkedList ) { return (Object []) sharedMap.get("arrayforLinkedList"); }
1135 if (list instanceof ArrayList ) { return (Object []) sharedMap.get("arrayforArrayList"); }
1136 if (list instanceof Stack ) { return (Object []) sharedMap.get("arrayforStack");
1139 }
1140 if (list instanceof Vector ) { return (Object []) sharedMap.get("arrayforVector"); }
1141 return null;
1142 }
1143
1144 private static void assertEmptyObjectArray(Object [] array) {
1145 for (int i = 0; i < array.length; i++) {
1146 Assert.assertNull(array[i]);
1147 }
1148 }
1149
1150 private static void assertEmptyList(List list) {
1151 Assert.assertEquals(0, list.size());
1152 Assert.assertTrue(list.isEmpty());
1153
1154 int count = 0;
1155 for (Iterator i = list.iterator(); i.hasNext();) {
1156 count++;
1157 }
1158 Assert.assertEquals(0, count);
1159 }
1160
1161 private static void assertListsEqual(List expect, List actual) {
1162 Assert.assertEquals(expect.size(), actual.size());
1163
1164 Assert.assertTrue(expect.containsAll(actual));
1165 Assert.assertTrue(actual.containsAll(expect));
1166
1167 for (int i = 0, n = expect.size(); i < n; i++) {
1168 Assert.assertEquals(expect.get(i), actual.get(i));
1169 }
1170
1171 if (expect.isEmpty()) {
1172 Assert.assertTrue(actual.isEmpty());
1173 } else {
1174 Assert.assertFalse(actual.isEmpty());
1175 }
1176
1177 for (Iterator iExpect = expect.iterator(), iActual = actual.iterator(); iExpect.hasNext();) {
1178 Assert.assertEquals(iExpect.next(), iActual.next());
1179 }
1180
1181 }
1182
1183 public static void visitL1DSOConfig(ConfigVisitor visitor, DSOClientConfigHelper config) {
1184 String testClass = GenericList15TestApp.class.getName();
1185 config.getOrCreateSpec(testClass);
1186 String writeAllowedMethodExpression = "* " + testClass + "*.*(..)";
1187 config.addWriteAutolock(writeAllowedMethodExpression);
1188 String readOnlyMethodExpression = "* " + testClass + "*.*ReadOnly*(..)";
1189 config.addReadAutolock(readOnlyMethodExpression);
1190 }
1191
1192 private static void assertSingleElement(List list, Object obj) {
1193 Assert.assertEquals(1, list.size());
1194 Assert.assertEquals(obj, list.get(0));
1195 Assert.assertFalse(list.isEmpty());
1196 Assert.assertTrue(list.contains(obj));
1197
1198 int count = 0;
1199 for (Iterator i = list.iterator(); i.hasNext();) {
1200 count++;
1201 Assert.assertEquals(obj, i.next());
1202 }
1203 Assert.assertEquals(1, count);
1204
1205 }
1206
1207}
1208 |
Popular Tags |
Java API By Example, From Geeks To Geeks.