|
1
4 package com.tctest;
5
6 import EDU.oswego.cs.dl.util.concurrent.CyclicBarrier;
7
8 import com.tc.object.TCObject;
9 import com.tc.object.bytecode.ClassAdapterBase;
10 import com.tc.object.bytecode.TransparentAccess;
11 import com.tc.object.config.ConfigVisitor;
12 import com.tc.object.config.DSOClientConfigHelper;
13 import com.tc.object.config.TransparencyClassSpec;
14 import com.tc.simulator.app.ApplicationConfig;
15 import com.tc.simulator.listener.ListenerProvider;
16 import com.tc.util.Assert;
17 import com.tctest.runner.AbstractTransparentApp;
18
19 import java.lang.reflect.Field  ;
20 import java.lang.reflect.Method ;
21 import java.util.HashMap ;
22 import java.util.HashSet ;
23 import java.util.Iterator ;
24 import java.util.LinkedHashMap ;
25 import java.util.LinkedHashSet ;
26 import java.util.Map ;
27 import java.util.Set ;
28 import java.util.Map.Entry;
29
30 public class PhysicalInstrumentedMethodsTestApp extends AbstractTransparentApp {
31
32 private final CyclicBarrier barrier;
33
34 private TestSubSubClass subRoot;
35
36 public PhysicalInstrumentedMethodsTestApp(String appId, ApplicationConfig cfg, ListenerProvider listenerProvider) {
37 super(appId, cfg, listenerProvider);
38 barrier = new CyclicBarrier(getParticipantCount());
39 }
40
41 public void run() {
42 try {
43 int index = barrier.barrier();
44
45 validateGenerateTCObjectFieldAndMethod(index);
46
47 if (index == 0) {
48 subRoot = new TestSubSubClass();
49 }
50
51 barrier.barrier();
52
53 fieldSettingTest(index);
54 fieldGettingTest(index);
55 } catch (Throwable t) {
56 notifyError(t);
57 }
58 }
59
60 private void validateGenerateTCObjectFieldAndMethod(int index) {
61 if (index == 0) {
62 validateGeneratedTCObjectField();
63 validateGeneratedTCObjectMethod();
64 }
65 }
66
67 private void validateGeneratedTCObjectField() {
68 Field f = null;
69 try {
70 f = TestParentClass.class.getDeclaredField(ClassAdapterBase.MANAGED_FIELD_NAME);
71 Assert.assertNotNull(f);
72 } catch (NoSuchFieldException e) {
73 throw new AssertionError ("TestParentClass.class does not contain field " + ClassAdapterBase.MANAGED_FIELD_NAME);
74 }
75
76 try {
77 f = TestSubClass.class.getDeclaredField(ClassAdapterBase.MANAGED_FIELD_NAME);
78 throw new AssertionError ("Should have thrown an NoSuchFieldException.");
79 } catch (NoSuchFieldException e) {
80 }
82
83 try {
84 f = TestSubSubClass.class.getDeclaredField(ClassAdapterBase.MANAGED_FIELD_NAME);
85 throw new AssertionError ("Should have thrown an NoSuchFieldException.");
86 } catch (NoSuchFieldException e) {
87 }
89 }
90
91 private void validateGeneratedTCObjectMethod() {
92 try {
93 TestParentClass.class.getDeclaredMethod(ClassAdapterBase.MANAGED_METHOD, new Class []{TCObject.class});
94 } catch (NoSuchMethodException e) {
95 throw new AssertionError ("TestParentClass.class does not contain method " + ClassAdapterBase.MANAGED_METHOD);
96 }
97
98 try {
99 TestSubClass.class.getDeclaredMethod(ClassAdapterBase.MANAGED_METHOD, new Class []{TCObject.class});
100 throw new AssertionError ("Should have thrown a NoSuchMethodException.");
101 } catch (NoSuchMethodException e) {
102 }
104
105 try {
106 TestSubSubClass.class.getDeclaredMethod(ClassAdapterBase.MANAGED_METHOD, new Class []{TCObject.class});
107 throw new AssertionError ("Should have thrown a NoSuchMethodException.");
108 } catch (NoSuchMethodException e) {
109 }
111
112 }
113
114 private void fieldSettingTest(int index) throws Exception {
115 subClassFieldUnManagedSettingUsingReflectionTest(index);
116 subClassFieldUnManagedSettingTest(index);
117 subClassFieldManagedSettingUsingReflectionTest(index);
118 subClassFieldManagedSettingTest(index);
119 }
120
121 private void fieldGettingTest(int index) throws Exception {
122 subClassAllFieldsUnManagedGettingTest(index);
123 subClassAllFieldsUnManagedGettingUsingReflectionTest(index);
124 subClassAllFieldsManagedGettingTest(index);
125 subClassAllFieldsManagedGettingUsingReflectionTest(index);
126 }
127
128 private void clear() throws Exception {
129 synchronized (subRoot) {
130 subRoot.clear();
131 }
132
133 barrier.barrier();
134 }
135
136 private void subClassFieldUnManagedSettingUsingReflectionTest(int index) throws Exception {
137 clear();
138
139 Set referenceSet = new HashSet ();
140 referenceSet.add("first element");
141 referenceSet.add("second element");
142
143 Map referenceMap = new HashMap ();
144 referenceMap.put("first key", "first element");
145 referenceMap.put("second key", "second element");
146
147 int[] referenceArray = new int[] { 1, 2 };
148
149 synchronized (subRoot) {
150 if (index == 0) {
151 Class subRootClass = subRoot.getClass();
152
153 Method m = subRootClass.getDeclaredMethod("__tc_setfield", new Class [] { String .class, Object .class });
155 m.invoke(subRoot, new Object [] {
156 "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildIntField", new Integer (2) });
157 m.invoke(subRoot, new Object [] {
158 "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildObjectField", new Integer (7) });
159 m.invoke(subRoot, new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childIntField",
160 new Integer (4) });
161 m.invoke(subRoot, new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childSetField",
162 referenceSet });
163 m.invoke(subRoot, new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childStringField",
164 "testString" });
165 m.invoke(subRoot, new Object [] {
166 "com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentIntField", new Integer (5) });
167 m.invoke(subRoot, new Object [] {
168 "com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentMapField", referenceMap });
169 m.invoke(subRoot, new Object [] {
170 "com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentArrayField", referenceArray });
171
172 m
174 .invoke(subRoot, new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.this$0",
175 null });
176 TransparentAccess ta = (TransparentAccess) subRoot;
177 Assert.assertNotNull(ta
178 .__tc_getmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.this$0"));
179
180 Assert.assertEquals(2, subRoot.getGrandChildIntField());
181 Assert.assertEquals(new Integer (7), subRoot.getGrandChildObjectField());
182 Assert.assertEquals(4, subRoot.getChildIntField());
183 assertSetsEqual(referenceSet, subRoot.getChildSetField());
184 Assert.assertEquals("testString", subRoot.getChildStringField());
185
186 Assert.assertEquals(5, subRoot.getParentIntField());
187 assertMappings(referenceMap, subRoot.getParentMapField());
188 assertIntegerArray(referenceArray, subRoot.getParentArrayField());
189
190 }
191 }
192 barrier.barrier();
193 }
194
195 private void subClassFieldUnManagedSettingTest(int index) throws Exception {
196 clear();
197
198 Set referenceSet = new HashSet ();
199 referenceSet.add("first element");
200 referenceSet.add("second element");
201
202 Map referenceMap = new HashMap ();
203 referenceMap.put("first key", "first element");
204 referenceMap.put("second key", "second element");
205
206 int[] referenceArray = new int[] { 1, 2 };
207
208 synchronized (subRoot) {
209 if (index == 0) {
210 TransparentAccess ta = (TransparentAccess) subRoot;
211
212 ta.__tc_setfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildIntField",
214 new Integer (2));
215 ta.__tc_setfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildObjectField",
216 new Integer (7));
217 ta.__tc_setfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childIntField", new Integer (4));
218 ta.__tc_setfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childSetField", referenceSet);
219 ta.__tc_setfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childStringField", "testString");
220 ta
221 .__tc_setfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentIntField",
222 new Integer (5));
223 ta.__tc_setfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentMapField", referenceMap);
224 ta.__tc_setfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentArrayField",
225 referenceArray);
226
227 ta.__tc_setfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.this$0", null);
229
230 Assert.assertNotNull(ta
231 .__tc_getmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.this$0"));
232
233 Assert.assertEquals(2, subRoot.getGrandChildIntField());
234 Assert.assertEquals(new Integer (7), subRoot.getGrandChildObjectField());
235 Assert.assertEquals(4, subRoot.getChildIntField());
236 assertSetsEqual(referenceSet, subRoot.getChildSetField());
237 Assert.assertEquals("testString", subRoot.getChildStringField());
238
239 Assert.assertEquals(5, subRoot.getParentIntField());
240 assertMappings(referenceMap, subRoot.getParentMapField());
241 assertIntegerArray(referenceArray, subRoot.getParentArrayField());
242 }
243 }
244 barrier.barrier();
245 }
246
247 private void subClassFieldManagedSettingUsingReflectionTest(int index) throws Exception {
248 clear();
249
250 Set referenceSet = new HashSet ();
251 referenceSet.add("first element");
252 referenceSet.add("second element");
253
254 Map referenceMap = new HashMap ();
255 referenceMap.put("first key", "first element");
256 referenceMap.put("second key", "second element");
257
258 int[] referenceArray = new int[] { 1, 2 };
259
260 synchronized (subRoot) {
261 if (index == 0) {
262 Class subRootClass = subRoot.getClass();
263
264 Method m = subRootClass.getDeclaredMethod("__tc_setmanagedfield", new Class [] { String .class, Object .class });
265 m.invoke(subRoot, new Object [] {
266 "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildIntField", new Integer (2) });
267 m.invoke(subRoot, new Object [] {
268 "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildObjectField", new Integer (7) });
269 m.invoke(subRoot, new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childIntField",
270 new Integer (4) });
271 m.invoke(subRoot, new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childSetField",
272 referenceSet });
273 m.invoke(subRoot, new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childStringField",
274 "testString" });
275 m.invoke(subRoot, new Object [] {
276 "com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentIntField", new Integer (5) });
277 m.invoke(subRoot, new Object [] {
278 "com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentMapField", referenceMap });
279 m.invoke(subRoot, new Object [] {
280 "com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentArrayField", referenceArray });
281
282 m
284 .invoke(subRoot, new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.this$0",
285 null });
286 }
287 }
288
289 barrier.barrier();
290
291 TransparentAccess ta = (TransparentAccess) subRoot;
292 Assert.assertNotNull(ta
293 .__tc_getmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.this$0"));
294
295 Assert.assertEquals(2, subRoot.getGrandChildIntField());
296 Assert.assertEquals(new Integer (7), subRoot.getGrandChildObjectField());
297 Assert.assertEquals(4, subRoot.getChildIntField());
298 assertSetsEqual(referenceSet, subRoot.getChildSetField());
299 Assert.assertEquals("testString", subRoot.getChildStringField());
300
301 Assert.assertEquals(5, subRoot.getParentIntField());
302 assertMappings(referenceMap, subRoot.getParentMapField());
303 assertIntegerArray(referenceArray, subRoot.getParentArrayField());
304
305 barrier.barrier();
306 }
307
308 private void subClassFieldManagedSettingTest(int index) throws Exception {
309 clear();
310
311 Set referenceSet = new HashSet ();
312 referenceSet.add("first element");
313 referenceSet.add("second element");
314
315 Map referenceMap = new HashMap ();
316 referenceMap.put("first key", "first element");
317 referenceMap.put("second key", "second element");
318
319 int[] referenceArray = new int[] { 1, 2 };
320 TransparentAccess ta = (TransparentAccess) subRoot;
321
322 synchronized (subRoot) {
323 if (index == 0) {
324 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildIntField",
325 new Integer (2));
326 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildObjectField",
327 new Integer (7));
328 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childIntField",
329 new Integer (4));
330 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childSetField",
331 referenceSet);
332 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childStringField",
333 "testString");
334 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentIntField",
335 new Integer (5));
336 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentMapField",
337 referenceMap);
338 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentArrayField",
339 referenceArray);
340
341 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.this$0", null);
343 }
344 }
345
346 barrier.barrier();
347
348 Assert.assertNotNull(ta
349 .__tc_getmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.this$0"));
350
351 Assert.assertEquals(2, subRoot.getGrandChildIntField());
352 Assert.assertEquals(new Integer (7), subRoot.getGrandChildObjectField());
353 Assert.assertEquals(4, subRoot.getChildIntField());
354 assertSetsEqual(referenceSet, subRoot.getChildSetField());
355 Assert.assertEquals("testString", subRoot.getChildStringField());
356
357 Assert.assertEquals(5, subRoot.getParentIntField());
358 assertMappings(referenceMap, subRoot.getParentMapField());
359 assertIntegerArray(referenceArray, subRoot.getParentArrayField());
360
361 barrier.barrier();
362 }
363
364 private void subClassAllFieldsUnManagedGettingUsingReflectionTest(int index) throws Exception {
365 clear();
366
367 Set referenceSet = new HashSet ();
368 referenceSet.add("first element");
369 referenceSet.add("second element");
370
371 Map referenceMap = new HashMap ();
372 referenceMap.put("first key", "first element");
373 referenceMap.put("second key", "second element");
374
375 int[] referenceArray = new int[] { 1, 2 };
376
377 synchronized (subRoot) {
378 TransparentAccess ta = (TransparentAccess) subRoot;
379 if (index == 0) {
380 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildIntField",
381 new Integer (2));
382 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildObjectField",
383 new Integer (7));
384 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childIntField",
385 new Integer (4));
386 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childSetField",
387 referenceSet);
388 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childStringField",
389 "testString");
390 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentIntField",
391 new Integer (5));
392 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentMapField",
393 referenceMap);
394 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentArrayField",
395 referenceArray);
396
397 Map map = new HashMap ();
398 Class subRootClass = subRoot.getClass();
400
401 Method m = subRootClass.getDeclaredMethod("__tc_getallfields", new Class [] { Map .class });
402 m.invoke(subRoot, new Object [] { map });
403
404 Assert.assertEquals(new Integer (2), map
405 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildIntField"));
406 Assert.assertEquals(new Integer (7), map
407 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildObjectField"));
408 Assert.assertTrue(this == map.get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.this$0"));
409 Assert.assertEquals(4, ((Integer ) map
410 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childIntField")).intValue());
411 assertSetsEqual(referenceSet, (Set ) map
412 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childSetField"));
413 Assert.assertEquals("testString", map
414 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childStringField"));
415
416 Assert.assertEquals(5, ((Integer ) map
417 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentIntField")).intValue());
418 assertMappings(referenceMap, (Map ) map
419 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentMapField"));
420 assertIntegerArray(referenceArray, (int[]) map
421 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentArrayField"));
422
423 }
424 }
425 barrier.barrier();
426 }
427
428 private void subClassAllFieldsUnManagedGettingTest(int index) throws Exception {
429 clear();
430
431 Set referenceSet = new HashSet ();
432 referenceSet.add("first element");
433 referenceSet.add("second element");
434
435 Map referenceMap = new HashMap ();
436 referenceMap.put("first key", "first element");
437 referenceMap.put("second key", "second element");
438
439 int[] referenceArray = new int[] { 1, 2 };
440
441 synchronized (subRoot) {
442 TransparentAccess ta = (TransparentAccess) subRoot;
443 if (index == 0) {
444 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildIntField",
445 new Integer (2));
446 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildObjectField",
447 new Integer (7));
448 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childIntField",
449 new Integer (4));
450 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childSetField",
451 referenceSet);
452 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childStringField",
453 "testString");
454 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentIntField",
455 new Integer (5));
456 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentMapField",
457 referenceMap);
458 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentArrayField",
459 referenceArray);
460
461 Map map = new HashMap ();
462 ta.__tc_getallfields(map);
464 Assert.assertEquals(new Integer (2), map
465 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildIntField"));
466 Assert.assertEquals(new Integer (7), map
467 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildObjectField"));
468 Assert.assertTrue(this == map.get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.this$0"));
469 Assert.assertEquals(4, ((Integer ) map
470 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childIntField")).intValue());
471 assertSetsEqual(referenceSet, (Set ) map
472 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childSetField"));
473 Assert.assertEquals("testString", map
474 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childStringField"));
475
476 Assert.assertEquals(5, ((Integer ) map
477 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentIntField")).intValue());
478 assertMappings(referenceMap, (Map ) map
479 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentMapField"));
480 assertIntegerArray(referenceArray, (int[]) map
481 .get("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentArrayField"));
482
483 }
484 }
485 barrier.barrier();
486 }
487
488 private void subClassAllFieldsManagedGettingUsingReflectionTest(int index) throws Exception {
489 clear();
490
491 Set referenceSet = new HashSet ();
492 referenceSet.add("first element");
493 referenceSet.add("second element");
494
495 Map referenceMap = new HashMap ();
496 referenceMap.put("first key", "first element");
497 referenceMap.put("second key", "second element");
498
499 int[] referenceArray = new int[] { 1, 2 };
500
501 synchronized (subRoot) {
502 TransparentAccess ta = (TransparentAccess) subRoot;
503 if (index == 0) {
504 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildIntField",
505 new Integer (2));
506 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildObjectField",
507 new Integer (7));
508 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childIntField",
509 new Integer (4));
510 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childSetField",
511 referenceSet);
512 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childStringField",
513 "testString");
514 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentIntField",
515 new Integer (5));
516 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentMapField",
517 referenceMap);
518 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentArrayField",
519 referenceArray);
520 }
521 }
522
523 barrier.barrier();
524
525 Class subRootClass = subRoot.getClass();
526
527 Method m = subRootClass.getDeclaredMethod("__tc_getmanagedfield", new Class [] { String .class });
528 Assert.assertEquals(2, ((Integer ) m
529 .invoke(subRoot,
530 new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildIntField" }))
531 .intValue());
532 Assert
533 .assertEquals(
534 7,
535 ((Integer ) m
536 .invoke(
537 subRoot,
538 new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildObjectField" }))
539 .intValue());
540 Assert.assertNotNull(m
541 .invoke(subRoot, new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.this$0" }));
542 if (index == 0) {
543 Assert.assertTrue(this == m
544 .invoke(subRoot, new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.this$0" }));
545 }
546 Assert.assertEquals(4, ((Integer ) m
547 .invoke(subRoot, new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childIntField" }))
548 .intValue());
549 assertSetsEqual(referenceSet, (Set ) m
550 .invoke(subRoot, new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childSetField" }));
551 Assert
552 .assertEquals("testString", m
553 .invoke(subRoot,
554 new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childStringField" }));
555 Assert.assertEquals(5, ((Integer ) m
556 .invoke(subRoot,
557 new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentIntField" }))
558 .intValue());
559 assertMappings(referenceMap, (Map ) m
560 .invoke(subRoot,
561 new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentMapField" }));
562 assertIntegerArray(referenceArray, (int[]) m
563 .invoke(subRoot,
564 new Object [] { "com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentArrayField" }));
565
566 barrier.barrier();
567 }
568
569 private void subClassAllFieldsManagedGettingTest(int index) throws Exception {
570 clear();
571
572 Set referenceSet = new HashSet ();
573 referenceSet.add("first element");
574 referenceSet.add("second element");
575
576 Map referenceMap = new HashMap ();
577 referenceMap.put("first key", "first element");
578 referenceMap.put("second key", "second element");
579
580 int[] referenceArray = new int[] { 1, 2 };
581 TransparentAccess ta = (TransparentAccess) subRoot;
582
583 synchronized (subRoot) {
584 if (index == 0) {
585 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildIntField",
586 new Integer (2));
587 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildObjectField",
588 new Integer (7));
589 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childIntField",
590 new Integer (4));
591 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childSetField",
592 referenceSet);
593 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childStringField",
594 "testString");
595 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentIntField",
596 new Integer (5));
597 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentMapField",
598 referenceMap);
599 ta.__tc_setmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentArrayField",
600 referenceArray);
601 }
602 }
603
604 barrier.barrier();
605
606 Assert.assertEquals(2, ((Integer ) ta
607 .__tc_getmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildIntField"))
608 .intValue());
609 Assert.assertEquals(new Integer (7), ta
610 .__tc_getmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.grandChildObjectField"));
611 Assert.assertNotNull(ta
612 .__tc_getmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.this$0"));
613 if (index == 0) {
614 Assert.assertTrue(this == ta
615 .__tc_getmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubSubClass.this$0"));
616 }
617 Assert.assertEquals(4, ((Integer ) ta
618 .__tc_getmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childIntField")).intValue());
619 assertSetsEqual(referenceSet, (Set ) ta
620 .__tc_getmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childSetField"));
621 Assert.assertEquals("testString", ta
622 .__tc_getmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestSubClass.childStringField"));
623
624 Assert.assertEquals(5, ((Integer ) ta
625 .__tc_getmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentIntField"))
626 .intValue());
627 assertMappings(referenceMap, (Map ) ta
628 .__tc_getmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentMapField"));
629 assertIntegerArray(referenceArray, (int[]) ta
630 .__tc_getmanagedfield("com.tctest.PhysicalInstrumentedMethodsTestApp$TestParentClass.parentArrayField"));
631
632 barrier.barrier();
633 }
634
635 private void assertIntegerArray(int[] expect, int[] actual) {
636 Assert.assertEquals(expect.length, actual.length);
637
638 for (int i = 0; i < expect.length; i++) {
639 Assert.assertEquals(expect[i], actual[i]);
640 }
641 }
642
643 private void assertMappings(Map expect, Map actual) {
644 Assert.assertEquals(expect.size(), actual.size());
645
646 Set expectEntries = expect.entrySet();
647 Set actualEntries = actual.entrySet();
648 if (actual instanceof LinkedHashMap ) {
649 for (Iterator iExpect = expectEntries.iterator(), iActual = actualEntries.iterator(); iExpect.hasNext();) {
650 Assert.assertEquals(iExpect.next(), iActual.next());
651 }
652 }
653
654 for (Iterator i = expectEntries.iterator(); i.hasNext();) {
655 Entry entry = (Entry) i.next();
656 Assert.assertEquals(entry.getValue(), actual.get(entry.getKey()));
657 }
658
659 for (Iterator i = actualEntries.iterator(); i.hasNext();) {
660 Entry entry = (Entry) i.next();
661 Assert.assertEquals(entry.getValue(), expect.get(entry.getKey()));
662 }
663 }
664
665 private void assertSetsEqual(Set expectElements, Set actual) {
666 Assert.assertEquals(expectElements.size(), actual.size());
667
668 if (actual instanceof LinkedHashSet ) {
669 for (Iterator iExpect = expectElements.iterator(), iActual = actual.iterator(); iExpect.hasNext();) {
670 Assert.assertEquals(iExpect.next(), iActual.next());
671 }
672 }
673
674 Assert.assertTrue(expectElements.containsAll(actual));
675 Assert.assertTrue(actual.containsAll(expectElements));
676
677 if (expectElements.isEmpty()) {
678 Assert.assertTrue(actual.isEmpty());
679 } else {
680 Assert.assertFalse(actual.isEmpty());
681 }
682 }
683
684 public static void visitL1DSOConfig(ConfigVisitor visitor, DSOClientConfigHelper config) {
685 TransparencyClassSpec spec = config.getOrCreateSpec(CyclicBarrier.class.getName());
686 config.addWriteAutolock("* " + CyclicBarrier.class.getName() + "*.*(..)");
687
688 String testClass = PhysicalInstrumentedMethodsTestApp.class.getName();
689 spec = config.getOrCreateSpec(testClass);
690 config.addIncludePattern(testClass + "$*");
691 config.addIncludePattern(testClass + "$*$TestSubSubInnerClass");
692
693 String methodExpression = "* " + testClass + "*.*(..)";
694 config.addWriteAutolock(methodExpression);
695
696 spec.addRoot("subRoot", "subRoot");
697 spec.addRoot("barrier", "barrier");
698 }
699
700 private static class TestParentClass {
701 private int parentIntField;
702 private Map parentMapField;
703 private int[] parentArrayField;
704
705 public TestParentClass() {
706 this.parentIntField = 0;
707 this.parentMapField = new HashMap ();
708 }
709
710 public int getParentIntField() {
711 return parentIntField;
712 }
713
714 public void setParentIntField(int parentIntField) {
715 this.parentIntField = parentIntField;
716 }
717
718 public Map getParentMapField() {
719 return parentMapField;
720 }
721
722 public void setParentMapField(Map parentMapField) {
723 this.parentMapField = parentMapField;
724 }
725
726 public int[] getParentArrayField() {
727 return parentArrayField;
728 }
729
730 public void setParentArrayField(int[] parentArrayField) {
731 this.parentArrayField = parentArrayField;
732 }
733
734 public void clear() {
735 this.parentIntField = 0;
736 this.parentMapField.clear();
737 }
738 }
739
740 private static class TestSubClass extends TestParentClass {
741 private int childIntField;
742 private Set childSetField;
743 private String childStringField;
744 private int index;
745
746 public TestSubClass() {
747 this.index = 0;
748 this.childIntField = 0;
749 this.childSetField = new HashSet ();
750 }
751
752 public void clear() {
753 this.index = 0;
754 this.childIntField = 0;
755 this.childSetField.clear();
756 super.clear();
757 }
758
759 public int getChildIntField() {
760 return childIntField;
761 }
762
763 public void setChildIntField(int childIntField) {
764 this.childIntField = childIntField;
765 }
766
767 public Set getChildSetField() {
768 return childSetField;
769 }
770
771 public void setChildSetField(Set childSetField) {
772 this.childSetField = childSetField;
773 }
774
775 public String getChildStringField() {
776 return childStringField;
777 }
778
779 public void setChildStringField(String childStringField) {
780 this.childStringField = childStringField;
781 }
782
783 public int getIndex() {
784 return index;
785 }
786
787 public void setIndex(int index) {
788 this.index = index;
789 }
790 }
791
792 private class TestSubSubClass extends TestSubClass {
793 private int grandChildIntField;
794 private Object grandChildObjectField;
795 private TestSubSubInnerClass t;
796
797 public TestSubSubClass() {
798 super();
799 this.grandChildIntField = 0;
800 this.grandChildObjectField = new Object ();
801 this.t = new TestSubSubInnerClass(10);
802 }
803
804 public Object getT() {
805 return this.t;
807 }
808
809 public int getGrandChildIntField() {
810 return grandChildIntField;
811 }
812
813 public void setGrandChildIntField(int grandChildIntField) {
814 this.grandChildIntField = grandChildIntField;
815 }
816
817 public Object getGrandChildObjectField() {
818 return grandChildObjectField;
819 }
820
821 public void setGrandChildObjectField(Object grandChildObjectField) {
822 this.grandChildObjectField = grandChildObjectField;
823 }
824
825 public void clear() {
826 this.grandChildIntField = 0;
827 this.grandChildObjectField = new Object ();
828 super.clear();
829 }
830
831 private class TestSubSubInnerClass {
832 private long l;
833
834 public TestSubSubInnerClass(long l) {
835 this.l = l;
836 }
837
838 long getL() {
839 return this.l;
841 }
842
843 }
844 }
845 }
846
|
Popular Tags
|
Java API By Example, From Geeks To Geeks.