|
1
4 package com.tctest;
5
6 import EDU.oswego.cs.dl.util.concurrent.CyclicBarrier;
7
8 import com.tc.object.config.ConfigVisitor;
9 import com.tc.object.config.DSOClientConfigHelper;
10 import com.tc.object.config.TransparencyClassSpec;
11 import com.tc.simulator.app.ApplicationConfig;
12 import com.tc.simulator.listener.ListenerProvider;
13 import com.tc.util.Assert;
14 import com.tctest.runner.AbstractTransparentApp;
15
16 import java.util.Comparator  ;
17 import java.util.Set ;
18 import java.util.SortedSet ;
19 import java.util.TreeSet ;
20
21 public class TreeSetTestApp extends AbstractTransparentApp {
22
23 private final TreeSet set = new TreeSet ();
25
26 private final TreeSet set2 = new TreeSet (new WrappedStringComparator());
29
30 private final CyclicBarrier barrier;
31
32 private final SubSetSharedObject subSetSharedRoot = new SubSetSharedObject(0);
33
34 public TreeSetTestApp(String appId, ApplicationConfig cfg, ListenerProvider listenerProvider) {
35 super(appId, cfg, listenerProvider);
36 barrier = new CyclicBarrier(getParticipantCount());
37 }
38
39 public void run() {
40 try {
41 subSetTesting();
42 headSetTesting();
43 tailSetTesting();
44 viewSetSharedTesting();
45 } catch (Throwable t) {
46 notifyError(t);
47 }
48 }
49
50 private int getKey() throws Exception {
51 int key = -1;
52 synchronized (subSetSharedRoot) {
53 if (subSetSharedRoot.getKey() != 0) {
54 subSetSharedRoot.setKey(0);
55 }
56 }
57 barrier.barrier();
58
59 synchronized (subSetSharedRoot) {
60 key = subSetSharedRoot.getKey();
61 if (key == 0) {
62 subSetSharedRoot.setKey(1);
63 }
64 }
65 return key;
66 }
67
68 private void subSetTesting() throws Exception {
69 clear();
70 initializeSets();
71
72
74 int key = getKey();
75 barrier.barrier();
76
77 if (key == 0) {
78 synchronized (set) {
79 Object fromKey = new Integer (0);
80 Object toKey = new Integer (10);
81 Set subSet = set.subSet(fromKey, toKey);
82 subSet.add(new Integer (1));
83 }
84 }
85 barrier.barrier();
86
87 Assert.assertEquals(getParticipantCount() + 1, set.size());
88 Assert.assertTrue(set.contains(new Integer (1)));
89
90 barrier.barrier();
91 key = getKey();
92 barrier.barrier();
93
94 if (key == 0) {
95 synchronized (set2) {
96 Object fromKey = new WrappedString(0);
97 Object toKey = new WrappedString(10);
98 Set subSet = set2.subSet(fromKey, toKey);
99 subSet.add(new WrappedString(1));
100 }
101 }
102 barrier.barrier();
103
104 Assert.assertEquals(getParticipantCount() + 1, set2.size());
105 Assert.assertTrue(set2.contains(new WrappedString(1)));
106 barrier.barrier();
107 }
108
109 private void headSetTesting() throws Exception {
110 clear();
111 initializeSets();
112
113 int key = getKey();
114 barrier.barrier();
115
116 if (key == 0) {
118 synchronized (set) {
119 Object toKey = new Integer (2);
120 Set headSet = set.headSet(toKey);
121 headSet.add(new Integer (1));
122 }
123 }
124 barrier.barrier();
125
126 Assert.assertEquals(getParticipantCount() + 1, set.size());
127 Assert.assertTrue(set.contains(new Integer (1)));
128
129 barrier.barrier();
130
131 key = getKey();
132 barrier.barrier();
133
134 if (key == 0) {
135 synchronized (set2) {
136 Object toKey = new WrappedString(2);
137 Set headSet = set2.headSet(toKey);
138 headSet.add(new WrappedString(1));
139 }
140 }
141
142 barrier.barrier();
143
144 Assert.assertEquals(getParticipantCount() + 1, set2.size());
145 Assert.assertTrue(set2.contains(new WrappedString(1)));
146
147 barrier.barrier();
148 }
149
150 private void tailSetTesting() throws Exception {
151 clear();
152 initializeSets();
153
154 int key = getKey();
156 barrier.barrier();
157
158 if (key == 0) {
159 synchronized (set) {
160 Object fromKey = new Integer (0);
161 Set tailSet = set.tailSet(fromKey);
162 tailSet.add(new Integer (1));
163 }
164 }
165
166 barrier.barrier();
167
168 Assert.assertEquals(getParticipantCount() + 1, set.size());
169 Assert.assertTrue(set.contains(new Integer (1)));
170
171 barrier.barrier();
172
173 key = getKey();
174 barrier.barrier();
175
176 if (key == 0) {
177 synchronized (set2) {
178 Object fromKey = new WrappedString(0);
179 Set tailSet = set2.tailSet(fromKey);
180 tailSet.add(new WrappedString(1));
181 }
182 }
183
184 barrier.barrier();
185
186 Assert.assertEquals(getParticipantCount() + 1, set2.size());
187 Assert.assertTrue(set2.contains(new WrappedString(1)));
188 barrier.barrier();
189
190 clear();
191 initializeSets();
192
193 key = getKey();
194 barrier.barrier();
195
196 if (key == 0) {
198 synchronized (set) {
199 Object fromKey = new Integer (0);
200 Set tailSet = set.tailSet(fromKey);
201 tailSet.clear();
202 }
203 }
204 barrier.barrier();
205
206 Assert.assertEquals(0, set.size());
207
208 barrier.barrier();
209
210 key = getKey();
211 barrier.barrier();
212
213 if (key == 0) {
214 synchronized (set2) {
215 Object fromKey = new WrappedString(0);
216 Set tailSet = set2.tailSet(fromKey);
217 tailSet.clear();
218 }
219 }
220 barrier.barrier();
221
222 Assert.assertEquals(0, set2.size());
223 barrier.barrier();
224 }
225
226 private void viewSetSharedTesting() throws Exception {
227 clear();
228 initializeSets();
229
230 int key = getKey();
231 barrier.barrier();
232
233 if (key == 0) {
235 Object fromKey = new Integer (0);
236 Object toKey = new Integer (10);
237 Set subSet = set.subSet(fromKey, toKey);
238 synchronized (subSetSharedRoot) {
239 subSetSharedRoot.setSet(subSet);
240 }
241 synchronized (subSetSharedRoot.getSet()) {
242 subSetSharedRoot.getSet().add(new Integer (1));
243 }
244 }
245
246 barrier.barrier();
247
248 Assert.assertEquals(getParticipantCount() + 1, set.size());
249 Assert.assertTrue(set.contains(new Integer (1)));
250
251 barrier.barrier();
252
253 key = getKey();
254 barrier.barrier();
255
256 if (key == 0) {
257 Object fromKey = new WrappedString(0);
258 Object toKey = new WrappedString(10);
259 Set subSet = set2.subSet(fromKey, toKey);
260 synchronized (subSetSharedRoot) {
261 subSetSharedRoot.setSet(subSet);
262 }
263 synchronized (subSetSharedRoot.getSet()) {
264 subSetSharedRoot.getSet().add(new WrappedString(1));
265 }
266 }
267
268 barrier.barrier();
269
270 Assert.assertEquals(getParticipantCount() + 1, set2.size());
271 Assert.assertTrue(set2.contains(new WrappedString(1)));
272
273 barrier.barrier();
274
275 clear();
276 initializeSets();
277
278 key = getKey();
279 barrier.barrier();
280
281 if (key == 0) {
283 Object toKey = new Integer (10);
284 Set headSet = set.headSet(toKey);
285 synchronized (subSetSharedRoot) {
286 subSetSharedRoot.setSet(headSet);
287 }
288 synchronized (subSetSharedRoot.getSet()) {
289 subSetSharedRoot.getSet().add(new Integer (1));
290 }
291 }
292
293 barrier.barrier();
294
295 Assert.assertEquals(getParticipantCount() + 1, set.size());
296 Assert.assertTrue(set.contains(new Integer (1)));
297
298 barrier.barrier();
299
300 key = getKey();
301 barrier.barrier();
302
303 if (key == 0) {
304 Object toKey = new WrappedString(10);
305 Set headSet = set2.headSet(toKey);
306 synchronized (subSetSharedRoot) {
307 subSetSharedRoot.setSet(headSet);
308 }
309 synchronized (subSetSharedRoot.getSet()) {
310 subSetSharedRoot.getSet().add(new WrappedString(1));
311 }
312 }
313
314 barrier.barrier();
315
316 Assert.assertEquals(getParticipantCount() + 1, set2.size());
317 Assert.assertTrue(set2.contains(new WrappedString(1)));
318
319 barrier.barrier();
320
321 clear();
322 initializeSets();
323
324 key = getKey();
325 barrier.barrier();
326
327 if (key == 0) {
329 Object fromKey = new Integer (0);
330 Set tailSet = set.tailSet(fromKey);
331 synchronized (subSetSharedRoot) {
332 subSetSharedRoot.setSet(tailSet);
333 }
334
335 synchronized (subSetSharedRoot.getSet()) {
336 subSetSharedRoot.getSet().add(new Integer (1));
337 }
338 }
339
340 barrier.barrier();
341
342 Assert.assertEquals(getParticipantCount() + 1, set.size());
343 Assert.assertTrue(set.contains(new Integer (1)));
344
345 barrier.barrier();
346
347 key = getKey();
348 barrier.barrier();
349
350 if (key == 0) {
351 Object fromKey = new WrappedString(0);
352 Set tailSet = set2.tailSet(fromKey);
353 synchronized (subSetSharedRoot) {
354 subSetSharedRoot.setSet(tailSet);
355 }
356
357 synchronized (subSetSharedRoot.getSet()) {
358 subSetSharedRoot.getSet().add(new WrappedString(1));
359 }
360 }
361 barrier.barrier();
362
363 Assert.assertEquals(getParticipantCount() + 1, set2.size());
364 Assert.assertTrue(set2.contains(new WrappedString(1)));
365
366 barrier.barrier();
367
368 clear();
369 initializeSets();
370
371 key = getKey();
372 barrier.barrier();
373
374 if (key == 0) {
376 Object fromKey = new Integer (0);
377 Object toKey = new Integer (10);
378 Object toKey2 = new Integer (5);
379 SortedSet subSet = set.subSet(fromKey, toKey);
380 Set subSet2 = subSet.subSet(fromKey, toKey2);
381 synchronized (subSetSharedRoot) {
382 subSetSharedRoot.setSet(subSet2);
383 }
384 synchronized (subSetSharedRoot.getSet()) {
385 subSetSharedRoot.getSet().add(new Integer (1));
386 }
387 }
388
389 barrier.barrier();
390
391 Assert.assertEquals(getParticipantCount() + 1, set.size());
392 Assert.assertTrue(set.contains(new Integer (1)));
393
394 barrier.barrier();
395
396 key = getKey();
397 barrier.barrier();
398 if (key == 0) {
399 Object fromKey = new WrappedString(0);
400 Object toKey = new WrappedString(10);
401 Object toKey2 = new WrappedString(5);
402 SortedSet subSet = set2.subSet(fromKey, toKey2);
403 Set subSet2 = subSet.subSet(fromKey, toKey);
404 synchronized (subSetSharedRoot) {
405 subSetSharedRoot.setSet(subSet2);
406 }
407 synchronized (subSetSharedRoot.getSet()) {
408 subSetSharedRoot.getSet().add(new WrappedString(1));
409 }
410 }
411
412 barrier.barrier();
413 Assert.assertEquals(getParticipantCount() + 1, set2.size());
414 Assert.assertTrue(set2.contains(new WrappedString(1)));
415
416 barrier.barrier();
417 }
418
419 private void clear() throws Exception {
420 synchronized (set) {
421 set.clear();
422 }
423 synchronized (set2) {
424 set2.clear();
425 }
426
427 synchronized (subSetSharedRoot) {
428 subSetSharedRoot.clear();
429 }
430
431 barrier.barrier();
432 }
433
434 private void initializeSets() throws Exception {
435 synchronized (subSetSharedRoot) {
436 if (subSetSharedRoot.getKey() != 0) {
437 subSetSharedRoot.setKey(0);
438 }
439 }
440 barrier.barrier();
441
442 synchronized (set) {
443 int key = subSetSharedRoot.getKey();
444 set.add(new Integer (key));
445 subSetSharedRoot.setKey(key + 2);
446 }
447 barrier.barrier();
448 synchronized (subSetSharedRoot) {
449 if (subSetSharedRoot.getKey() != 0) {
450 subSetSharedRoot.setKey(0);
451 }
452 }
453 barrier.barrier();
454 synchronized (set2) {
455 int key = subSetSharedRoot.getKey();
456 set2.add(new WrappedString(key));
457 subSetSharedRoot.setKey(key + 2);
458 }
459 barrier.barrier();
460 }
461
462 public static void visitL1DSOConfig(ConfigVisitor visitor, DSOClientConfigHelper config) {
463 TransparencyClassSpec spec = config.getOrCreateSpec(CyclicBarrier.class.getName());
464 config.addWriteAutolock("* " + CyclicBarrier.class.getName() + "*.*(..)");
465
466 String testClass = TreeSetTestApp.class.getName();
467 spec = config.getOrCreateSpec(testClass);
468
469 config.addIncludePattern(testClass + "$*");
470
471 String methodExpression = "* " + testClass + "*.*(..)";
472 config.addWriteAutolock(methodExpression);
473
474 spec.addRoot("set", "set");
475 spec.addRoot("set2", "set2");
476 spec.addRoot("barrier", "barrier");
477 spec.addRoot("subSetSharedRoot", "subSetSharedRoot");
478 }
479
480 private static class WrappedString {
482 private final String string;
483
484 WrappedString(String string) {
485 this.string = string;
486 }
487
488 WrappedString(int i) {
489 this.string = String.valueOf(i);
490 }
491
492 String getString() {
493 return this.string;
494 }
495 }
496
497 private static class WrappedStringComparator implements Comparator {
498
499 public int compare(Object o1, Object o2) {
500 WrappedString ws1 = (WrappedString) o1;
501 WrappedString ws2 = (WrappedString) o2;
502 return ws1.getString().compareTo(ws2.getString());
503 }
504
505 }
506
507
510 private static class SubSetSharedObject {
511 private int key;
512 private Set set;
513
514 public SubSetSharedObject(int key) {
515 this.key = key;
516 }
517
518 public int getKey() {
519 return key;
520 }
521
522 public void setKey(int key) {
523 this.key = key;
524 }
525
526 public Set getSet() {
527 return set;
528 }
529
530 public void setSet(Set set) {
531 this.set = set;
532 }
533
534 public void clear() {
535 this.key = 0;
536 this.set = null;
537 }
538 }
539 }
540 |
Popular Tags |
Java API By Example, From Geeks To Geeks.