|
1
5 package com.tc.bootjar.java.util;
6
7 import com.tc.asm.ClassAdapter;
8 import com.tc.asm.ClassVisitor;
9 import com.tc.asm.ClassWriter;
10 import com.tc.aspectwerkz.reflect.ClassInfo;
11 import com.tc.aspectwerkz.reflect.MemberInfo;
12 import com.tc.config.schema.NewCommonL1Config;
13 import com.tc.config.schema.builder.DSOApplicationConfigBuilder;
14 import com.tc.exception.ImplementMe;
15 import com.tc.object.MockTCObject;
16 import com.tc.object.ObjectID;
17 import com.tc.object.Portability;
18 import com.tc.object.PortabilityImpl;
19 import com.tc.object.SerializationUtil;
20 import com.tc.object.TestClientObjectManager;
21 import com.tc.object.MockTCObject.MethodCall;
22 import com.tc.object.bytecode.ClassAdapterFactory;
23 import com.tc.object.bytecode.Manageable;
24 import com.tc.object.bytecode.TransparencyClassAdapter;
25 import com.tc.object.config.ConfigLockLevel;
26 import com.tc.object.config.DSOClientConfigHelper;
27 import com.tc.object.config.DSOSpringConfigHelper;
28 import com.tc.object.config.DistributedMethodSpec;
29 import com.tc.object.config.Lock;
30 import com.tc.object.config.LockDefinition;
31 import com.tc.object.config.ModuleSpec;
32 import com.tc.object.config.TransparencyClassSpec;
33 import com.tc.object.config.schema.DSOInstrumentationLoggingOptions;
34 import com.tc.object.config.schema.DSORuntimeLoggingOptions;
35 import com.tc.object.config.schema.DSORuntimeOutputOptions;
36 import com.tc.object.config.schema.InstrumentedClass;
37 import com.tc.object.loaders.IsolationClassLoader;
38 import com.tc.object.logging.InstrumentationLogger;
39 import com.tc.object.tx.MockTransactionManager;
40 import com.tc.test.TCTestCase;
41 import com.tc.util.Assert;
42 import com.terracottatech.config.Modules;
43
44 import java.lang.reflect.Constructor  ;
45 import java.lang.reflect.InvocationTargetException ;
46 import java.security.SecureRandom ;
47 import java.util.Collection ;
48 import java.util.HashMap ;
49 import java.util.HashSet ;
50 import java.util.Iterator ;
51 import java.util.List ;
52 import java.util.Map ;
53 import java.util.Random ;
54 import java.util.Set ;
55 import java.util.Map.Entry;
56
57 public class HashMapTCTest extends TCTestCase {
58 private ClassLoader origThreadContextClassLoader;
59
60 protected void setUp() throws Exception {
61 MockConfig config = new MockConfig();
62
63 TestClientObjectManager testClientObjectManager = new TestClientObjectManager();
64 MockTransactionManager testTransactionManager = new MockTransactionManager();
65 IsolationClassLoader classLoader = new IsolationClassLoader(config, testClientObjectManager, testTransactionManager);
66 classLoader.init();
67
68 this.origThreadContextClassLoader = Thread.currentThread().getContextClassLoader();
69 Thread.currentThread().setContextClassLoader(classLoader);
70 }
71
72 protected void tearDown() throws Exception {
73 super.tearDown();
74
75 Thread.currentThread().setContextClassLoader(this.origThreadContextClassLoader);
76 }
77
78 public void testLogicalInvoke() throws Exception {
79 Map tcmap = createMap("java.util.HashMap");
80 validateLogicalInvoke(tcmap);
81
82 tcmap = createMap("java.util.LinkedHashMap");
83 validateLogicalInvoke(tcmap);
84
85 tcmap = createMap("java.util.Hashtable");
86 validateLogicalInvoke(tcmap);
87 }
88
89 public void BROKENtestMapNotShared() throws Exception {
90 Map jmap = createMap("java.util.HashMap_J");
91 Map tcmap = createMap("java.util.HashMap");
92 validateMapNotShared(jmap, tcmap);
93
94 jmap = createMap("java.util.LinkedHashMap_J");
95 tcmap = createMap("java.util.LinkedHashMap");
96 validateMapNotShared(jmap, tcmap);
97
98 jmap = createMap("java.util.Hashtable_J");
99 tcmap = createMap("java.util.Hashtable");
100 validateMapNotShared(jmap, tcmap);
101 }
102
103 public void BROKENtestEntrySet() throws Exception {
104 Map jmap = createMap("java.util.HashMap_J");
105 Map tcmap = createMap("java.util.HashMap");
106 validateEntrySet(jmap, tcmap);
107
108 jmap = createMap("java.util.LinkedHashMap_J");
109 tcmap = createMap("java.util.LinkedHashMap");
110 validateEntrySet(jmap, tcmap);
111
112 jmap = createMap("java.util.Hashtable_J");
113 tcmap = createMap("java.util.Hashtable");
114 validateEntrySet(jmap, tcmap);
115 }
116
117 public void BROKENtestEntrySetAdd() throws Exception {
118 }
120
121 public void BROKENtestEntrySetRemove() throws Exception {
122 Map jmap = createMap("java.util.HashMap_J");
123 Map tcmap = createMap("java.util.HashMap");
124 validateEntrySetRemove(jmap, tcmap);
125
126 jmap = createMap("java.util.LinkedHashMap_J");
127 tcmap = createMap("java.util.LinkedHashMap");
128 validateEntrySetRemove(jmap, tcmap);
129
130 jmap = createMap("java.util.Hashtable_J");
131 tcmap = createMap("java.util.Hashtable");
132 validateEntrySetRemove(jmap, tcmap);
133 }
134
135 public void BROKENtestEntrySetClear() throws Exception {
136 Map jmap = createMap("java.util.HashMap_J");
137 Map tcmap = createMap("java.util.HashMap");
138 validateEntrySetClear(jmap, tcmap);
139
140 jmap = createMap("java.util.LinkedHashMap_J");
141 tcmap = createMap("java.util.LinkedHashMap");
142 validateEntrySetClear(jmap, tcmap);
143
144 jmap = createMap("java.util.Hashtable_J");
145 tcmap = createMap("java.util.Hashtable");
146 validateEntrySetClear(jmap, tcmap);
147 }
148
149 public void validateEntrySetIteratorRemove() throws Exception {
150 Map jmap = createMap("java.util.HashMap_J");
151 Map tcmap = createMap("java.util.HashMap");
152 validateEntryIteratorRemove(jmap, tcmap);
153
154 jmap = createMap("java.util.LinkedHashMap_J");
155 tcmap = createMap("java.util.LinkedHashMap");
156 validateEntryIteratorRemove(jmap, tcmap);
157
158 jmap = createMap("java.util.Hashtable_J");
159 tcmap = createMap("java.util.Hashtable");
160 validateEntryIteratorRemove(jmap, tcmap);
161 }
162
163 public void BROKENtestKeySet() throws Exception {
164 Map jmap = createMap("java.util.HashMap_J");
165 Map tcmap = createMap("java.util.HashMap");
166 validateKeySet(jmap, tcmap);
167
168 jmap = createMap("java.util.LinkedHashMap_J");
169 tcmap = createMap("java.util.LinkedHashMap");
170 validateKeySet(jmap, tcmap);
171
172 jmap = createMap("java.util.Hashtable_J");
173 tcmap = createMap("java.util.Hashtable");
174 validateKeySet(jmap, tcmap);
175 }
176
177 public void BROKENtestKeySetRemove() throws Exception {
178 Map jmap = createMap("java.util.HashMap_J");
179 Map tcmap = createMap("java.util.HashMap");
180 validateKeySetRemove(jmap, tcmap);
181
182 jmap = createMap("java.util.LinkedHashMap_J");
183 tcmap = createMap("java.util.LinkedHashMap");
184 validateKeySetRemove(jmap, tcmap);
185
186 jmap = createMap("java.util.Hashtable_J");
187 tcmap = createMap("java.util.Hashtable");
188 validateKeySetRemove(jmap, tcmap);
189 }
190
191 public void BROKENtestKeySetClear() throws Exception {
192 Map jmap = createMap("java.util.HashMap_J");
193 Map tcmap = createMap("java.util.HashMap");
194 validateKeySetClear(jmap, tcmap);
195
196 jmap = createMap("java.util.LinkedHashMap_J");
197 tcmap = createMap("java.util.LinkedHashMap");
198 validateKeySetClear(jmap, tcmap);
199
200 jmap = createMap("java.util.Hashtable_J");
201 tcmap = createMap("java.util.Hashtable");
202 validateKeySetClear(jmap, tcmap);
203 }
204
205 public void BROKENtestKeySetIteratorRemove() throws Exception {
206 Map jmap = createMap("java.util.HashMap_J");
207 Map tcmap = createMap("java.util.HashMap");
208 validateKeySetIteratorRemove(jmap, tcmap);
209
210 jmap = createMap("java.util.LinkedHashMap_J");
211 tcmap = createMap("java.util.LinkedHashMap");
212 validateKeySetIteratorRemove(jmap, tcmap);
213
214 jmap = createMap("java.util.Hashtable_J");
215 tcmap = createMap("java.util.Hashtable");
216 validateKeySetIteratorRemove(jmap, tcmap);
217 }
218
219 public void BROKENtestValues() throws Exception {
220 Map jmap = createMap("java.util.HashMap_J");
221 Map tcmap = createMap("java.util.HashMap");
222 validateValues(jmap, tcmap);
223
224 jmap = createMap("java.util.LinkedHashMap_J");
225 tcmap = createMap("java.util.LinkedHashMap");
226 validateValues(jmap, tcmap);
227
228 jmap = createMap("java.util.Hashtable_J");
229 tcmap = createMap("java.util.Hashtable");
230 validateValues(jmap, tcmap);
231 }
232
233 public void BROKENtestValuesRemove() throws Exception {
234 Map jmap = createMap("java.util.HashMap_J");
235 Map tcmap = createMap("java.util.HashMap");
236 validateValuesRemove(jmap, tcmap);
237
238 jmap = createMap("java.util.LinkedHashMap_J");
239 tcmap = createMap("java.util.LinkedHashMap");
240 validateValuesRemove(jmap, tcmap);
241
242 jmap = createMap("java.util.Hashtable_J");
243 tcmap = createMap("java.util.Hashtable");
244 validateValuesRemove(jmap, tcmap);
245 }
246
247 public void BROKENtestValuesClear() throws Exception {
248 Map jmap = createMap("java.util.HashMap_J");
249 Map tcmap = createMap("java.util.HashMap");
250 validateValuesClear(jmap, tcmap);
251
252 jmap = createMap("java.util.LinkedHashMap_J");
253 tcmap = createMap("java.util.LinkedHashMap");
254 validateValuesClear(jmap, tcmap);
255
256 jmap = createMap("java.util.Hashtable_J");
257 tcmap = createMap("java.util.Hashtable");
258 validateValuesClear(jmap, tcmap);
259 }
260
261 public void BROKENtestValuesIteratorRemove() throws Exception {
262 Map jmap = createMap("java.util.HashMap_J");
263 Map tcmap = createMap("java.util.HashMap");
264 validateValuesIteratorRemove(jmap, tcmap);
265
266 jmap = createMap("java.util.LinkedHashMap_J");
267 tcmap = createMap("java.util.LinkedHashMap");
268 validateValuesIteratorRemove(jmap, tcmap);
269
270 jmap = createMap("java.util.Hashtable_J");
271 tcmap = createMap("java.util.Hashtable");
272 validateValuesIteratorRemove(jmap, tcmap);
273 }
274
275
276
277 public void validateLogicalInvoke(Map tcmap) throws Exception {
278
279 MockTCObject tcObject = new MockTCObject(new ObjectID(1), this, false, true);
280
281 ((Manageable) tcmap).__tc_managed(tcObject);
282 SecureRandom sr = new SecureRandom ();
283 long seed = sr.nextLong();
284 populateMap(tcmap, new Random (seed), 100);
285
286 List logicalInvokeHistory = tcObject.getHistory();
287
288 assertEqualsContent(logicalInvokeHistory, tcmap);
289 }
290
291 public void validateMapNotShared(Map jmap, Map tcmap) throws Exception {
292 SecureRandom sr = new SecureRandom ();
293 long seed = sr.nextLong();
294 System.err.println("Seed is " + seed);
295 populateMap(jmap, new Random (seed));
296 populateMap(tcmap, new Random (seed));
297
298 assertEquals(jmap, tcmap);
299
300 System.err.println("Size is " + tcmap.size());
301 assertEquals(tcmap, jmap);
302 }
303
304 public void validateEntrySet(Map jmap, Map tcmap) throws Exception {
305 SecureRandom sr = new SecureRandom ();
306 long seed = sr.nextLong();
307 populateMap(jmap, new Random (seed));
308 populateMap(tcmap, new Random (seed));
309
310 assertEqualsCollection(jmap.entrySet(), tcmap.entrySet());
311 }
312
313 public void validateEntrySetRemove(Map jmap, Map tcmap) throws Exception {
314 populateMapWithHashKey(jmap, 100);
315 populateMapWithHashKey(tcmap, 100);
316
317 Map.Entry entryToBeRemove = new SimpleEntry(new HashKey(10), new HashValue(10));
318
319 Set tcentrySet = tcmap.entrySet();
320 tcentrySet.remove(entryToBeRemove);
321
322 Set jentrySet = jmap.entrySet();
323 jentrySet.remove(entryToBeRemove);
324
325 assertEquals(99, jmap.size());
326 assertEquals(99, tcmap.size());
327 assertEquals(jmap, tcmap);
328 assertEquals(tcmap, jmap);
329 }
330
331 public void validateEntrySetClear(Map jmap, Map tcmap) throws Exception {
332 populateMapWithHashKey(jmap, 100);
333 populateMapWithHashKey(tcmap, 100);
334
335 Set tcentrySet = tcmap.entrySet();
336 tcentrySet.clear();
337
338 Set jentrySet = jmap.entrySet();
339 jentrySet.clear();
340
341 assertEquals(0, jmap.size());
342 assertEquals(0, tcmap.size());
343 }
344
345 public void validateEntryIteratorRemove(Map jmap, Map tcmap) throws Exception {
346 populateMapWithHashKey(jmap, 100);
347 populateMapWithHashKey(tcmap, 100);
348
349 Iterator tcIterator = tcmap.entrySet().iterator();
350 tcIterator.next();
351 tcIterator.next();
352 tcIterator.remove();
353
354 Iterator jIterator = jmap.entrySet().iterator();
355 jIterator.next();
356 jIterator.next();
357 jIterator.remove();
358
359 assertEquals(99, jmap.size());
360 assertEquals(99, tcmap.size());
361 assertEquals(jmap, tcmap);
362 assertEquals(tcmap, jmap);
363 }
364
365 public void validateKeySet(Map jmap, Map tcmap) throws Exception {
366 SecureRandom sr = new SecureRandom ();
367 long seed = sr.nextLong();
368 populateMap(jmap, new Random (seed));
369 populateMap(tcmap, new Random (seed));
370
371 assertEqualsCollection(jmap.keySet(), tcmap.keySet());
372 }
373
374 public void validateKeySetRemove(Map jmap, Map tcmap) throws Exception {
375 populateMapWithHashKey(jmap, 100);
376 populateMapWithHashKey(tcmap, 100);
377
378 HashKey keyToBeRemoved = new HashKey(10);
379
380 Set tckeySet = tcmap.keySet();
381 tckeySet.remove(keyToBeRemoved);
382
383 Set jkeySet = jmap.keySet();
384 jkeySet.remove(keyToBeRemoved);
385
386 assertEquals(99, jmap.size());
387 assertEquals(99, tcmap.size());
388 assertEquals(jmap, tcmap);
389 assertEquals(tcmap, jmap);
390 }
391
392 public void validateKeySetClear(Map jmap, Map tcmap) throws Exception {
393 populateMapWithHashKey(jmap, 100);
394 populateMapWithHashKey(tcmap, 100);
395
396 Set tckeySet = tcmap.keySet();
397 tckeySet.clear();
398
399 Set jkeySet = jmap.keySet();
400 jkeySet.clear();
401
402 assertEquals(0, jmap.size());
403 assertEquals(0, tcmap.size());
404 }
405
406 public void validateKeySetIteratorRemove(Map jmap, Map tcmap) throws Exception {
407 populateMapWithHashKey(jmap, 100);
408 populateMapWithHashKey(tcmap, 100);
409
410 Iterator tciterator = tcmap.keySet().iterator();
411 tciterator.next();
412 tciterator.next();
413 tciterator.remove();
414
415 Iterator jiterator = jmap.keySet().iterator();
416 jiterator.next();
417 jiterator.next();
418 jiterator.remove();
419
420 assertEquals(99, jmap.size());
421 assertEquals(99, tcmap.size());
422 assertEquals(jmap, tcmap);
423 assertEquals(tcmap, jmap);
424 }
425
426 public void validateValues(Map jmap, Map tcmap) throws Exception {
427 SecureRandom sr = new SecureRandom ();
428 long seed = sr.nextLong();
429 populateMap(jmap, new Random (seed));
430 populateMap(tcmap, new Random (seed));
431
432 assertEqualsCollection(jmap.values(), tcmap.values());
433 }
434
435 public void validateValuesRemove(Map jmap, Map tcmap) throws Exception {
436 populateMapWithHashKey(jmap, 100);
437 populateMapWithHashKey(tcmap, 100);
438
439 HashValue valueToBeRemoved = new HashValue(10);
440
441 Collection tcvalues = tcmap.values();
442 tcvalues.remove(valueToBeRemoved);
443
444 Collection jvalues = jmap.values();
445 jvalues.remove(valueToBeRemoved);
446
447 assertEquals(99, jmap.size());
448 assertEquals(99, tcmap.size());
449 assertEquals(jmap, tcmap);
450 assertEquals(tcmap, jmap);
451 }
452
453 public void validateValuesClear(Map jmap, Map tcmap) throws Exception {
454 populateMapWithHashKey(jmap, 100);
455 populateMapWithHashKey(tcmap, 100);
456
457 Collection tcvalues = tcmap.values();
458 tcvalues.clear();
459
460 Collection jvalues = jmap.values();
461 jvalues.clear();
462
463 assertEquals(0, jmap.size());
464 assertEquals(0, tcmap.size());
465 }
466
467 public void validateValuesIteratorRemove(Map jmap, Map tcmap) throws Exception {
468 populateMapWithHashKey(jmap, 100);
469 populateMapWithHashKey(tcmap, 100);
470
471 Iterator tciterator = tcmap.values().iterator();
472 tciterator.next();
473 tciterator.next();
474 tciterator.remove();
475
476 Iterator jiterator = jmap.values().iterator();
477 jiterator.next();
478 jiterator.next();
479 jiterator.remove();
480
481 assertEquals(99, jmap.size());
482 assertEquals(99, tcmap.size());
483 assertEquals(jmap, tcmap);
484 assertEquals(tcmap, jmap);
485 }
486
487 void assertSingleMapping(Map map, final Object key, final Object value) {
488 Assert.assertFalse(map.isEmpty());
489 Assert.assertEquals(1, map.size());
490 Assert.assertEquals(1, map.entrySet().size());
491 Assert.assertEquals(1, map.values().size());
492 Assert.assertEquals(1, map.keySet().size());
493 Assert.assertEquals(value, map.get(key));
494 Assert.assertTrue(map.containsKey(key));
495 Assert.assertTrue(map.containsValue(value));
496
497 Set entries = map.entrySet();
498 for (Iterator i = entries.iterator(); i.hasNext();) {
499 Entry entry = (Entry) i.next();
500 Assert.assertEquals(key, entry.getKey());
501 Assert.assertEquals(value, entry.getValue());
502 }
503
504 for (Iterator i = map.values().iterator(); i.hasNext();) {
505 Object o = i.next();
506 Assert.assertEquals(value, o);
507 }
508
509 for (Iterator i = map.keySet().iterator(); i.hasNext();) {
510 Object o = i.next();
511 Assert.assertEquals(key, o);
512 }
513
514 HashMap compare = new HashMap ();
515 compare.put(key, value);
516 Assert.assertEquals(compare, map);
517 }
518
519 private void assertEqualsContent(Collection expected, Map actual) {
520 assertEquals(expected.size(), actual.size());
521
522 Set keySet = actual.keySet();
523 for (Iterator i = expected.iterator(); i.hasNext();) {
524 MethodCall methodCall = (MethodCall) i.next();
525 assertEquals(SerializationUtil.PUT, methodCall.method);
526
527 assertTrue(keySet.contains(methodCall.parameters[0]));
528 assertEquals(methodCall.parameters[1], actual.get(methodCall.parameters[0]));
529 }
530 }
531
532 private void assertEqualsCollection(Collection expected, Collection actual) {
533 assertEquals(expected.size(), actual.size());
534
535 for (Iterator i = expected.iterator(), j = actual.iterator(); i.hasNext();) {
536 Object expectedObject = i.next();
537 Object actualObject = j.next();
538 assertEquals(expectedObject, actualObject);
539 }
540 }
541
542 private Map createMap(String className) throws ClassNotFoundException , SecurityException , NoSuchMethodException ,
543 IllegalArgumentException , InstantiationException , IllegalAccessException , InvocationTargetException {
544 Class c = Class.forName(className);
545 Constructor constructor = c.getConstructor(new Class [0]);
546 return (Map ) constructor.newInstance(new Object [0]);
547 }
548
549 private void populateMapWithHashKey(Map map, int numOfItems) {
550 for (int i = 0; i < numOfItems; i++) {
551 map.put(new HashKey(i), new HashValue(i));
552 }
553 }
554
555 private void populateMap(Map map, Random r) {
556 populateMap(map, r, 10000);
557 }
558
559 private void populateMap(Map map, Random r, int numOfItems) {
560 for (int i = 0; i < numOfItems; i++) {
561 switch (i % 4) {
562 case 0:
563 map.put(new Long (r.nextLong()), "Long to String");
564 break;
565 case 1:
566 map.put(new Integer (r.nextInt()), "Integer to String");
567 break;
568 case 2:
569 map.put(String.valueOf(r.nextLong()), "String to String");
570 break;
571 case 3:
572 map.put(new ObjectID(r.nextLong()), "ObjectID to String");
573 break;
574 default:
575 throw new AssertionError ();
577 }
578 }
579 }
580
581 private static class MockConfig implements DSOClientConfigHelper {
582
583 final Set isNeverAdaptable = new HashSet ();
584
585 public NewCommonL1Config getNewCommonL1Config() {
586 return null;
587 }
588
589 public boolean shouldBeAdapted(ClassInfo classInfo) {
590 return false;
591 }
592
593 public boolean isNeverAdaptable(ClassInfo classInfo) {
594 return true;
595 }
596
597 public boolean isLogical(String theClass) {
598 return true;
599 }
600
601 public boolean isPhysical(String className) {
602 throw new ImplementMe();
603 }
604
605 public DSOInstrumentationLoggingOptions getInstrumentationLoggingOptions() {
606 return null;
607 }
608
609 public TransparencyClassSpec[] getAllSpecs() {
610 throw new ImplementMe();
611 }
612
613 public void verifyBootJarContents() {
614 }
616
617 public Iterator getAllUserDefinedBootSpecs() {
618 throw new ImplementMe();
619 }
620
621 public ClassAdapter createClassAdapterFor(ClassWriter writer, ClassInfo classInfo, InstrumentationLogger lgr,
622 ClassLoader caller) {
623 throw new ImplementMe();
624 }
625
626 public ClassAdapter createClassAdapterFor(ClassWriter writer, ClassInfo classInfo, InstrumentationLogger lgr,
627 ClassLoader caller, boolean disableSuperClassTypeChecking) {
628 throw new ImplementMe();
629 }
630
631 public boolean isCallConstructorOnLoad(String className) {
632 throw new ImplementMe();
633 }
634
635 public String getChangeApplicatorClassNameFor(String className) {
636 throw new ImplementMe();
637 }
638
639 public TransparencyClassSpec getOrCreateSpec(String className) {
640 throw new ImplementMe();
641 }
642
643 public TransparencyClassSpec getOrCreateSpec(String className, String applicator) {
644 throw new ImplementMe();
645 }
646
647 public LockDefinition[] lockDefinitionsFor(int access, String className, String methodName, String description,
648 String [] exceptions) {
649 throw new ImplementMe();
650 }
651
652 public boolean isRoot(String className, String fieldName) {
653 throw new ImplementMe();
654 }
655
656 public boolean isTransient(int modifiers, String classname, String field) {
657 throw new ImplementMe();
658 }
659
660 public String rootNameFor(String className, String fieldName) {
661 throw new ImplementMe();
662 }
663
664 public boolean isLockMethod(int access, String className, String methodName, String description, String [] exceptions) {
665 throw new ImplementMe();
666 }
667
668 public DistributedMethodSpec getDmiSpec(int modifiers, String className, String methodName, String description,
669 String [] exceptions) {
670 throw new ImplementMe();
671 }
672
673 public TransparencyClassSpec getSpec(String className) {
674 throw new ImplementMe();
675 }
676
677 public boolean isDSOSessions(String name) {
678 throw new ImplementMe();
679 }
680
681 public DSORuntimeLoggingOptions runtimeLoggingOptions() {
682 throw new ImplementMe();
683 }
684
685 public DSORuntimeOutputOptions runtimeOutputOptions() {
686 throw new ImplementMe();
687 }
688
689 public DSOInstrumentationLoggingOptions instrumentationLoggingOptions() {
690 return null;
691 }
692
693 public int getClientInMemoryObjectCount() {
694 throw new ImplementMe();
695 }
696
697 public int getFaultCount() {
698 throw new ImplementMe();
699 }
700
701 public void addWriteAutolock(String methodPattern) {
702 throw new ImplementMe();
703 }
704
705 public void addLock(String methodPattern, LockDefinition lockDefinition) {
706 throw new ImplementMe();
707 }
708
709 public void addReadAutolock(String methodPattern) {
710 throw new ImplementMe();
711 }
712
713 public void addAutolock(String methodPattern, ConfigLockLevel type) {
714 throw new ImplementMe();
715 }
716
717 public void setFaultCount(int count) {
718 throw new ImplementMe();
719 }
720
721 public void addRoot(String className, String fieldName, String rootName, boolean addSpecForClass) {
722 throw new ImplementMe();
723 }
724
725 public boolean matches(Lock lock, MemberInfo methodInfo) {
726 throw new ImplementMe();
727 }
728
729 public boolean matches(String expression, MemberInfo methodInfo) {
730 throw new ImplementMe();
731 }
732
733 public void addTransient(String className, String fieldName) {
734 throw new ImplementMe();
735 }
736
737 public String getOnLoadScriptIfDefined(String className) {
738 throw new ImplementMe();
739 }
740
741 public String getOnLoadMethodIfDefined(String className) {
742 throw new ImplementMe();
743 }
744
745 public boolean isUseNonDefaultConstructor(Class clazz) {
746 throw new ImplementMe();
747 }
748
749 public void addIncludePattern(String expression) {
750 throw new ImplementMe();
751 }
752
753 public void addIncludePattern(String expression, boolean honorTransient) {
754 throw new ImplementMe();
755 }
756
757 public void addExcludePattern(String expression) {
758 throw new ImplementMe();
759 }
760
761 public boolean hasIncludeExcludePatterns() {
762 throw new ImplementMe();
763 }
764
765 public boolean hasIncludeExcludePattern(ClassInfo classInfo) {
766 throw new ImplementMe();
767 }
768
769 public void addAspectModule(String pattern, String moduleName) {
770 throw new ImplementMe();
771 }
772
773 public Map getAspectModules() {
774 return new HashMap ();
775 }
776
777 public void addDSOSpringConfig(DSOSpringConfigHelper config) {
778 throw new ImplementMe();
779 }
780
781 public Collection getDSOSpringConfigs() {
782 throw new ImplementMe();
783 }
784
785 public void addIncludePattern(String expression, boolean honorTransient, boolean oldStyleCallConstructorOnLoad) {
786 throw new ImplementMe();
787 }
788
789 public void addIncludePattern(String expression, boolean honorTransient, boolean oldStyleCallConstructorOnLoad,
790 boolean honorVolatile) {
791 throw new ImplementMe();
792 }
793
794 public void addIncludeAndLockIfRequired(String expression, boolean honorTransient,
795 boolean oldStyleCallConstructorOnLoad, boolean honorVolatile,
796 String lockExpression) {
797 throw new ImplementMe();
798 }
799
800 public boolean isVolatile(int modifiers, String classname, String field) {
801 throw new ImplementMe();
802 }
803
804 public void addRoot(String rootName, String rootFieldName) {
805 throw new ImplementMe();
806
807 }
808
809 public void writeTo(DSOApplicationConfigBuilder appConfigBuilder) {
810 throw new ImplementMe();
811
812 }
813
814 public boolean isRootDSOFinal(String className, String fieldName, boolean isPrimitive) {
815 throw new ImplementMe();
816 }
817
818 public void addRoot(String className, String fieldName, String rootName, boolean dsoFinal, boolean addSpecForClass) {
819 throw new ImplementMe();
820 }
821
822 public String getPostCreateMethodIfDefined(String className) {
823 throw new ImplementMe();
824 }
825
826 public Portability getPortability() {
827 return new PortabilityImpl(this);
828 }
829
830 public void removeSpec(String className) {
831 throw new ImplementMe();
832
833 }
834
835 public String getLogicalExtendingClassName(String className) {
836 return null;
837 }
838
839 public TransparencyClassAdapter createDsoClassAdapterFor(ClassVisitor writer, ClassInfo classInfo,
840 InstrumentationLogger lgr, ClassLoader caller,
841 boolean forcePortable) {
842 return null;
843 }
844
845 public void addSynchronousWriteAutolock(String methodPattern) {
846 throw new ImplementMe();
847 }
848
849 public void addApplicationName(String name) {
850 throw new ImplementMe();
851 }
852
853 public void addInstrumentationDescriptor(InstrumentedClass classDesc) {
854 throw new ImplementMe();
855 }
856
857 public void addUserDefinedBootSpec(String className, TransparencyClassSpec spec) {
858 throw new ImplementMe();
859 }
860
861 public void addTransientType(String className, String fieldName) {
862 throw new ImplementMe();
863 }
864
865 public Modules getModules() {
866 throw new ImplementMe();
867 }
868
869 public boolean hasCustomAdapter(String fullName) {
870 throw new ImplementMe();
871 }
872
873 public Class getChangeApplicator(Class clazz) {
874 throw new ImplementMe();
875 }
876
877 public void setModuleSpecs(ModuleSpec[] pluginSpecs) {
878 throw new ImplementMe();
879 }
880
881 public void addNewModule(String name, String version) {
882 throw new ImplementMe();
883 }
884
885 public Modules getModulesForInitialization() {
886 return null;
887 }
888
889 public boolean isPortableModuleClass(Class clazz) {
890 throw new ImplementMe();
891 }
892
893 public void addCustomAdapter(String name, ClassAdapterFactory factory) {
894 throw new ImplementMe();
895 }
896
897 public int getSessionLockType(String appName) {
898 throw new ImplementMe();
899 }
900
901 public void addSynchronousWriteApplication(String name) {
902 throw new ImplementMe();
903 }
904
905 public void addDistributedMethodCall(DistributedMethodSpec dms) {
906 throw new ImplementMe();
907 }
908
909 public Class getTCPeerClass(Class clazz) {
910 throw new ImplementMe();
911 }
912
913 }
914
915 private static class SimpleEntry implements Map.Entry {
916
917 private final Object key;
918 private Object value;
919
920 public SimpleEntry(Object key, Object value) {
921 this.key = key;
922 this.value = value;
923 }
924
925 public SimpleEntry(Map.Entry e) {
926 this.key = e.getKey();
927 this.value = e.getValue();
928 }
929
930 public Object getKey() {
931 return key;
932 }
933
934 public Object getValue() {
935 return value;
936 }
937
938 public Object setValue(Object value) {
939 Object oldValue = this.value;
940 this.value = value;
941 return oldValue;
942 }
943
944 public boolean equals(Object o) {
945 if (!(o instanceof Map.Entry )) return false;
946 Map.Entry e = (Map.Entry ) o;
947 return eq(key, e.getKey()) && eq(value, e.getValue());
948 }
949
950 public int hashCode() {
951 return ((key == null) ? 0 : key.hashCode()) ^ ((value == null) ? 0 : value.hashCode());
952 }
953
954 public String toString() {
955 return key + "=" + value;
956 }
957
958 private static boolean eq(Object o1, Object o2) {
959 return (o1 == null ? o2 == null : o1.equals(o2));
960 }
961 }
962
963 private static class HashKey {
964 private int i;
965
966 public HashKey(int i) {
967 super();
968 this.i = i;
969 }
970
971 public int getInt() {
972 return this.i;
973 }
974
975 public int hashCode() {
976 return i;
977 }
978
979 public boolean equals(Object obj) {
980 if (obj == null) return false;
981 if (!(obj instanceof HashKey)) return false;
982 return ((HashKey) obj).i == i;
983 }
984 }
985
986 private static class HashValue {
987 private int i;
988
989 public HashValue(int i) {
990 super();
991 this.i = i;
992 }
993
994 public int getInt() {
995 return this.i;
996 }
997
998 public int hashCode() {
999 return i;
1000 }
1001
1002 public boolean equals(Object obj) {
1003 if (obj == null) return false;
1004 if (!(obj instanceof HashValue)) return false;
1005 return ((HashValue) obj).i == i;
1006 }
1007
1008 public String toString() {
1009 return super.toString() + ", i: " + i;
1010 }
1011 }
1012
1013}
1014 |
Popular Tags |
Java API By Example, From Geeks To Geeks.