|
1
4 package com.tctest;
5
6 import com.tc.object.config.ConfigVisitor;
7 import com.tc.object.config.DSOClientConfigHelper;
8 import com.tc.simulator.app.ApplicationConfig;
9 import com.tc.simulator.listener.ListenerProvider;
10 import com.tc.util.Assert;
11
12 import java.util.ArrayList  ;
13 import java.util.Arrays ;
14 import java.util.Enumeration ;
15 import java.util.Iterator ;
16 import java.util.List ;
17 import java.util.ListIterator ;
18 import java.util.Stack ;
19 import java.util.Vector ;
20
21 public class AutoLockVectorTestApp extends GenericTestApp {
22
23 public AutoLockVectorTestApp(String appId, ApplicationConfig cfg, ListenerProvider listenerProvider) {
24 super(appId, cfg, listenerProvider, Vector .class);
25 }
26
27 protected Object getTestObject(String testName) {
28 List lists = (List ) sharedMap.get("lists");
29 return lists.iterator();
30 }
31
32 protected void setupTestObject(String testName) {
33 List lists = new ArrayList ();
34 lists.add(new Vector ());
35 lists.add(new Stack ());
36
37 sharedMap.put("lists", lists);
38 sharedMap.put("arrayforVector", new Object [4]);
39 sharedMap.put("arrayforStack", new Object [4]);
40 }
41
42 private void initialize(Vector vector) {
43 vector.addAll(getInitialData());
44 }
45
46 private List getInitialData() {
47 List data = new ArrayList ();
48 data.add("January");
49 data.add("February");
50 data.add("March");
51 data.add("April");
52 return data;
53 }
54
55 void testAddAll(Vector vector, boolean validate) {
56 if (validate) {
57 assertListsEqual(getInitialData(), vector);
58 } else {
59 initialize(vector);
60 }
61 }
62
63 void testAdd(Vector vector, boolean validate) {
64 if (validate) {
65 assertListsEqual(getInitialData(), vector);
66 } else {
67 vector.add("January");
68 vector.add("February");
69 vector.add("March");
70 vector.add("April");
71 }
72 }
73
74 void testClear(Vector vector, boolean validate) {
75 if (validate) {
76 Assert.assertEquals(0, vector.size());
77 } else {
78 initialize(vector);
79 assertListsEqual(getInitialData(), vector);
80 vector.clear();
81 }
82 }
83
84 void testIteratorRemove(Vector vector, boolean validate) {
85 if (validate) {
86 List expect = getInitialData();
87 Iterator expectIterator = expect.iterator();
88 expectIterator.next();
89 expectIterator.next();
90 expectIterator.remove();
91 assertListsEqual(expect, vector);
92 } else {
93 initialize(vector);
94 Iterator iterator = vector.iterator();
95 iterator.next();
96 iterator.next();
97 iterator.remove();
98 }
99 }
100
101 void testListIteratorAdd(Vector vector, boolean validate) {
102 if (validate) {
103 List expect = getInitialData();
104 expect.add(2, "May");
105 assertListsEqual(expect, vector);
106 } else {
107 initialize(vector);
108 ListIterator iterator = vector.listIterator();
109 iterator.next();
110 iterator.next();
111 iterator.add("May");
112 }
113 }
114
115 void testListIteratorRemove(Vector vector, boolean validate) {
116 if (validate) {
117 List expect = getInitialData();
118 expect.remove(1);
119 assertListsEqual(expect, vector);
120 } else {
121 initialize(vector);
122 ListIterator iterator = vector.listIterator();
123 iterator.next();
124 iterator.next();
125 iterator.remove();
126 }
127 }
128
129 void testRemove(Vector vector, boolean validate) {
130 if (validate) {
131 List expect = getInitialData();
132 expect.remove("February");
133 assertListsEqual(expect, vector);
134 } else {
135 initialize(vector);
136 vector.remove("February");
137 }
138 }
139
140 void testRemoveAt(Vector vector, boolean validate) {
141 if (validate) {
142 List expect = getInitialData();
143 expect.remove("February");
144 assertListsEqual(expect, vector);
145 } else {
146 initialize(vector);
147 vector.remove(1);
148 }
149 }
150
151 void testSetSizeGrow(Vector vector, boolean validate) {
152 int size = 5;
153
154 if (validate) {
155 Assert.assertEquals("January", vector.get(0));
156 for (int i = 1; i < size; i++) {
157 Object val = vector.get(i);
158 Assert.assertNull("element " + i + " is " + val, val);
159 }
160 Assert.assertEquals("July", vector.get(size));
161 } else {
162 vector.add("January");
163 vector.setSize(size);
164 vector.add("July");
165 }
166 }
167
168 void testSetSizeShrink(Vector vector, boolean validate) {
169 if (validate) {
170 Assert.assertEquals("January", vector.get(0));
171 Assert.assertEquals("February", vector.get(1));
172 } else {
173 vector.add("January");
174 vector.add("ho hum");
175 vector.add("ho hum2");
176 vector.add("ho hum3");
177 vector.setSize(1);
178 vector.add("February");
179 }
180 }
181
182 void testAddElement(Vector vector, boolean validate) {
183 if (validate) {
184 assertListsEqual(Arrays.asList(new Object [] { "January", "February" }), vector);
185 } else {
186 vector.addElement("January");
187 vector.addElement("February");
188 }
189 }
190
191 void testRetainAll(Vector vector, boolean validate) {
192 if (validate) {
193 assertListsEqual(Arrays.asList(new Object [] { "February", "April" }), vector);
194 } else {
195 initialize(vector);
196 List toRetain = new ArrayList ();
197 toRetain.add("February");
198 toRetain.add("April");
199 vector.retainAll(toRetain);
200 }
201 }
202
203 void testRemoveAll(Vector vector, boolean validate) {
204 if (validate) {
205 assertListsEqual(Arrays.asList(new Object [] { "January", "March" }), vector);
206 } else {
207 initialize(vector);
208 List toRemove = new ArrayList ();
209 toRemove.add("February");
210 toRemove.add("April");
211 vector.removeAll(toRemove);
212 }
213 }
214
215 void testListIteratorSet(Vector vector, boolean validate) {
216 if (validate) {
217 List expect = getInitialData();
218 expect.set(1, "February modified");
219 assertListsEqual(expect, vector);
220 } else {
221 initialize(vector);
222 ListIterator iterator = vector.listIterator();
223 iterator.next();
224 iterator.next();
225 iterator.set("February modified");
226 }
227 }
228
229 void testToArray(Vector vector, boolean validate) {
230 Object [] array = getArray(vector);
231
232 if (validate) {
233 assertListsEqual(Arrays.asList(array), vector);
234 } else {
235 initialize(vector);
236 synchronized (array) {
237 Object [] returnArray = vector.toArray(array);
238 Assert.assertTrue(returnArray == array);
239 }
240 }
241 }
242
243 void testCopyInto(Vector vector, boolean validate) {
244 Object [] array = getArray(vector);
245
246 if (validate) {
247 assertListsEqual(Arrays.asList(array), vector);
248 } else {
249 initialize(vector);
250 synchronized (array) {
251 vector.copyInto(array);
252 }
253 }
254 }
255
256 void testSetElementAt(Vector vector, boolean validate) {
257 if (validate) {
258 assertListsEqual(Arrays.asList(new Object [] { "January", "February Modified", "March", "April" }), vector);
259 } else {
260 initialize(vector);
261 vector.setElementAt("February Modified", 1);
262 }
263 }
264
265 void testSubList(Vector vector, boolean validate) {
266 if (validate) {
267 assertListsEqual(Arrays.asList(new Object [] { "January", "May", "February", "March", "April" }), vector);
268 } else {
269 initialize(vector);
270 List subList = vector.subList(1, 2);
271 ListIterator listIterator = subList.listIterator();
272 listIterator.add("May");
273 }
274 }
275
276 void testElements(Vector vector, boolean validate) {
277 if (validate) {
278 List expect = getInitialData();
279 int i = 0;
280 Enumeration elements = vector.elements();
281 while (elements.hasMoreElements()) {
282 Object expectObj = expect.get(i++);
283 Object actualObj = elements.nextElement();
284 Assert.assertEquals(expectObj, actualObj);
285 }
286 } else {
287 initialize(vector);
288 }
289 }
290
291 void testStackPush(Vector vector, boolean validate) {
292 if (!(vector instanceof Stack )) { return; }
293
294 if (validate) {
295 assertListsEqual(Arrays.asList(new Object [] { "January", "February" }), vector);
296 } else {
297 Stack s = (Stack ) vector;
298 s.push("January");
299 s.push("February");
300 }
301 }
302
303 void testStackPop(Vector vector, boolean validate) {
304 if (!(vector instanceof Stack )) { return; }
305
306 if (validate) {
307 assertListsEqual(Arrays.asList(new Object [] { "January" }), vector);
308 } else {
309 Stack s = (Stack ) vector;
310 s.push("January");
311 s.push("February");
312
313 Object o = s.pop();
314 Assert.assertEquals("February", o);
315 }
316 }
317
318 private Object [] getArray(Vector vector) {
319 if (vector instanceof Stack ) { return (Object []) sharedMap.get("arrayforStack"); }
320 return (Object []) sharedMap.get("arrayforVector");
321 }
322
323 private void assertListsEqual(List expect, List actual) {
324 Assert.assertEquals(expect.size(), actual.size());
325
326 Assert.assertTrue(expect.containsAll(actual));
327 Assert.assertTrue(actual.containsAll(expect));
328
329 for (int i = 0, n = expect.size(); i < n; i++) {
330 Assert.assertEquals(expect.get(i), actual.get(i));
331 }
332
333 if (expect.isEmpty()) {
334 Assert.assertTrue(actual.isEmpty());
335 } else {
336 Assert.assertFalse(actual.isEmpty());
337 }
338
339 for (Iterator iExpect = expect.iterator(), iActual = actual.iterator(); iExpect.hasNext();) {
340 Assert.assertEquals(iExpect.next(), iActual.next());
341 }
342 }
343
344 public static void visitL1DSOConfig(ConfigVisitor visitor, DSOClientConfigHelper config) {
345 String testClass = AutoLockVectorTestApp.class.getName();
346 config.getOrCreateSpec(testClass);
347 }
348
349 }
350
|
Popular Tags
|
Java API By Example, From Geeks To Geeks.