Java API By Example, From Geeks To Geeks.

1 package measurements.suites; 2 3 import java.lang.reflect.Field ; 4 import java.lang.reflect.Method ; 5 6 import junit.framework.Test; 7 import ch.ethz.inf.util.junit.PerformanceTest; 8 import ch.ethz.inf.util.junit.PerformanceTestSuite; 9 import ch.ethz.jvmai.*; 10 11 /** 12  * JoinPoint micro-measurements. 13  * 14  * Performance micro-measurements tests for method boundaries, 15  * fields accesses and modifications, exception handlers: 16  * 17  * 1) INVOKEVIRTUAL -> invoke a normal method 18  * 2) SYNC INVOKEVIRTUAL -> invoke a normal but synchronized method 19  * 3) INVOKEINTERFACE -> invoke a method through an interface 20  * 4) INVOKESPECIAL -> invoke a private method 21  * 5) INVOKESTATIC -> invoke a static method 22  * 6) GETFIELD -> used when a field has been read 23  * 7) PUTFIELD -> used when a field has been write 24  * 8) Exception Catch 25  * 9) Exception Throw 26  * 27  * Each test is executed "RUNS" times. 28  * 29  * @author Angela Nicoara 30  */ 31 public class JoinPointMeasurements1 extends PerformanceTest { 32 33     public boolean useProse = false; 34     public boolean checkAssert = true; 35 36     protected JVMAspectInterface aspectInterface; 37     protected TestHook hook; 38 39     // INVOKEVIRTUAL 40 public void localMethod() { } 41     public void localMethodLongO(Object ob1, Object ob2) { } 42     public void localMethodLongI(int ob1, int ob2) { } 43     public void localMethodLongL(long ob1, long ob2) { } 44     public void localMethodLongD(double ob1, double ob2) { } 45 46     // INVOKESPECIAL 47 private void privatelocalMethod() { } 48     private void privatelocalMethodLongO(Object ob1, Object ob2) { } 49     private void privatelocalMethodLongI(int ob1, int ob2) { } 50     private void privatelocalMethodLongL(long ob1, long ob2) { } 51     private void privatelocalMethodLongD(double ob1, double ob2) { } 52      53     // INVOKEINTERFACE 54 protected JoinPointTestInterface obInterface = new JoinPointTestClass(); 55      56     // SYNC INVOKEVIRTUAL 57 protected JoinPointTestClass obSync = new JoinPointTestClass(); 58      59     public int theField = 0; 60      61     // GETFIELD 62 // In case of the advice weaver the field that is accessed or modified has to be in a method 63 public void theFieldAccess(int runs) 64     { 65         int n = 0; 66 67         startChronometer(); 68         for (int i = 0; i < RUNS; i++) n = this.theField; 69         stopChronometer(); 70     } 71      72     // PUTFIELD 73 // In case of the advice weaver the field that is accessed or modified has to be in a method 74 public void theFieldModification(int runs) 75     { 76         startChronometer(); 77         for (int i = 0; i < RUNS; i++) this.theField = i; 78         stopChronometer(); 79     } 80 81     // INVOKEVIRTUAL 82 protected Method method; 83     protected Method methodLongO; 84     protected Method methodLongI; 85     protected Method methodLongL; 86     protected Method methodLongD; 87 88     // SYNC INVOKEVIRTUAL 89 protected Method syncMethod; 90     protected Method syncMethodLongO; 91     protected Method syncMethodLongI; 92     protected Method syncMethodLongL; 93     protected Method syncMethodLongD; 94      95     // INVOKEINTERFACE 96 protected Method interfaceMethod; 97     protected Method interfaceMethodLongO; 98     protected Method interfaceMethodLongI; 99     protected Method interfaceMethodLongL; 100     protected Method interfaceMethodLongD; 101      102     // INVOKESTATIC 103 protected Method staticMethod; 104     protected Method staticMethodLongO; 105     protected Method staticMethodLongI; 106     protected Method staticMethodLongL; 107     protected Method staticMethodLongD; 108 109     // INVOKESPECIAL 110 protected Method privateMethod; 111     protected Method privateMethodLongO; 112     protected Method privateMethodLongI; 113     protected Method privateMethodLongL; 114     protected Method privateMethodLongD; 115      116     protected Field field; 117      118     public class TestException extends Exception {}; 119     public TestException exception = new TestException(); 120 121     public static int fieldAccessCount; 122     public static int fieldModificationCount; 123     public static int methodEntryCount; 124     public static int methodExitCount; 125     public static int exceptionThrowCount; 126     public static int exceptionCatchCount; 127          128     public static class TestHook extends JoinPointHook 129     { 130         public void onFieldAccess(FieldAccessJoinPoint joinPoint) { fieldAccessCount++; } 131         public void onFieldModification(FieldModificationJoinPoint joinPoint) { fieldModificationCount++; } 132         public void onMethodEntry(MethodEntryJoinPoint joinPoint) { methodEntryCount++; } 133         public void onMethodExit(MethodExitJoinPoint joinPoint) { methodExitCount++; } 134         public void onExceptionThrow(ExceptionJoinPoint joinPoint) { exceptionThrowCount++; } 135         public void onExceptionCatch(ExceptionCatchJoinPoint joinPoint) { exceptionCatchCount++; } 136         public void onClassLoad(Class cls) {} 137     } 138      139     public JoinPointMeasurements1(String name) { 140         super(name); 141         RANGE = new int[] { 100000000 }; 142          143         String proseParam = System.getProperty("useprose"); 144         if (proseParam != null) useProse = true; 145     } 146 147     protected void setUp() throws Exception 148     { 149         if (useProse) 150         { 151             String providerName = System.getProperty("ch.ethz.prose.JVMAIProvider"); 152             Class providerClass = Class.forName(providerName); 153             Provider provider = (Provider) providerClass.newInstance(); 154 155             aspectInterface = provider.getAspectInterface(); 156             aspectInterface.startup(null, true); 157 158             hook = new TestHook(); 159             aspectInterface.setJoinPointHook(hook); 160 161             // INVOKEVIRTUAL 162 method = JoinPointMeasurements1.class.getDeclaredMethod("localMethod", new Class [] {}); 163             methodLongO = JoinPointMeasurements1.class.getDeclaredMethod("localMethodLongO", new Class [] {Object .class, Object .class}); 164             methodLongI = JoinPointMeasurements1.class.getDeclaredMethod("localMethodLongI", new Class [] {Integer.TYPE, Integer.TYPE}); 165             methodLongL = JoinPointMeasurements1.class.getDeclaredMethod("localMethodLongL", new Class [] {Long.TYPE, Long.TYPE}); 166             methodLongD = JoinPointMeasurements1.class.getDeclaredMethod("localMethodLongD", new Class [] {Double.TYPE, Double.TYPE}); 167 168             // SYNC INVOKEVIRTUAL 169 syncMethod = JoinPointTestClass.class.getDeclaredMethod("syncMethodShort", new Class [] {}); 170             syncMethodLongO = JoinPointTestClass.class.getDeclaredMethod("syncMethodLongO", new Class [] {Object .class, Object .class}); 171             syncMethodLongI = JoinPointTestClass.class.getDeclaredMethod("syncMethodLongI", new Class [] {Integer.TYPE, Integer.TYPE}); 172             syncMethodLongL = JoinPointTestClass.class.getDeclaredMethod("syncMethodLongL", new Class [] {Long.TYPE, Long.TYPE}); 173             syncMethodLongD = JoinPointTestClass.class.getDeclaredMethod("syncMethodLongD", new Class [] {Double.TYPE, Double.TYPE}); 174              175             // INVOKEINTERFACE 176 interfaceMethod = JoinPointTestClass.class.getDeclaredMethod("interfaceMethodShort", new Class [] {}); 177             interfaceMethodLongO = JoinPointTestClass.class.getDeclaredMethod("interfaceMethodLongO", new Class [] {Object .class, Object .class}); 178             interfaceMethodLongI = JoinPointTestClass.class.getDeclaredMethod("interfaceMethodLongI", new Class [] {Integer.TYPE, Integer.TYPE}); 179             interfaceMethodLongL = JoinPointTestClass.class.getDeclaredMethod("interfaceMethodLongL", new Class [] {Long.TYPE, Long.TYPE}); 180             interfaceMethodLongD = JoinPointTestClass.class.getDeclaredMethod("interfaceMethodLongD", new Class [] {Double.TYPE, Double.TYPE}); 181 182             // INVOKESTATIC 183 staticMethod = JoinPointTestClass.class.getDeclaredMethod("staticMethodShort", new Class [] {}); 184             staticMethodLongO = JoinPointTestClass.class.getDeclaredMethod("staticMethodLongO", new Class [] {Object .class, Object .class}); 185             staticMethodLongI = JoinPointTestClass.class.getDeclaredMethod("staticMethodLongI", new Class [] {Integer.TYPE, Integer.TYPE}); 186             staticMethodLongL = JoinPointTestClass.class.getDeclaredMethod("staticMethodLongL", new Class [] {Long.TYPE, Long.TYPE}); 187             staticMethodLongD = JoinPointTestClass.class.getDeclaredMethod("staticMethodLongD", new Class [] {Double.TYPE, Double.TYPE}); 188              189             // INVOKESPECIAL 190 privateMethod = JoinPointMeasurements1.class.getDeclaredMethod("privatelocalMethod", new Class [] {}); 191             privateMethodLongO = JoinPointMeasurements1.class.getDeclaredMethod("privatelocalMethodLongO", new Class [] {Object .class, Object .class}); 192             privateMethodLongI = JoinPointMeasurements1.class.getDeclaredMethod("privatelocalMethodLongI", new Class [] {Integer.TYPE, Integer.TYPE}); 193             privateMethodLongL = JoinPointMeasurements1.class.getDeclaredMethod("privatelocalMethodLongL", new Class [] {Long.TYPE, Long.TYPE}); 194             privateMethodLongD = JoinPointMeasurements1.class.getDeclaredMethod("privatelocalMethodLongD", new Class [] {Double.TYPE, Double.TYPE}); 195 196             field = JoinPointMeasurements1.class.getDeclaredField("theField"); 197         } 198 199         fieldAccessCount = 0; 200         fieldModificationCount = 0; 201         methodEntryCount = 0; 202         methodExitCount = 0; 203         exceptionThrowCount = 0; 204         exceptionCatchCount = 0; 205     } 206      207     protected void tearDown() 208     { 209         if (useProse) aspectInterface.teardown(); 210     } 211 212     //===================================================== 213 214     // 1) INVOKEVIRTUAL - no call to weaver because the joinpoint isn't activated 215 public void testVirtualMethod_no_jp_NoArg() 216     { 217         startChronometer(); 218         for (int i = 0; i < RUNS; i++) localMethod(); 219         stopChronometer(); 220     } 221      222     // 2) INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 223 public void testVirtualMethodEntry_jp_activated_locked_NoArg() 224     { 225         if (useProse) { 226             aspectInterface.suspendNotification(Thread.currentThread()); //suspend all the events(notifications) before the watch(es) has been set 227 aspectInterface.setMethodEntryWatch(method, new Object ()); 228             aspectInterface.resumeNotification(Thread.currentThread()); //advice weaving: all the joinpoints are activated atomically 229 aspectInterface.suspendNotification(Thread.currentThread()); 230         } 231 232         startChronometer(); 233         for (int i = 0; i < RUNS; i++) localMethod(); 234         stopChronometer(); 235     } 236 237     // 2) INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 238 public void testVirtualMethodExit_jp_activated_locked_NoArg() 239     { 240         if (useProse) { 241             aspectInterface.suspendNotification(Thread.currentThread()); 242             aspectInterface.setMethodExitWatch(method, new Object ()); 243             aspectInterface.resumeNotification(Thread.currentThread()); 244             aspectInterface.suspendNotification(Thread.currentThread()); 245         } 246 247         startChronometer(); 248         for (int i = 0; i < RUNS; i++) localMethod(); 249         stopChronometer(); 250     } 251      252     // 3) INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 253 public void testVirtualMethodEntry_jp_activated_NoArg() 254     { 255         if (useProse) { 256             aspectInterface.suspendNotification(Thread.currentThread()); 257             aspectInterface.setMethodEntryWatch(method, new Object ()); 258             aspectInterface.resumeNotification(Thread.currentThread()); 259         } 260 261         startChronometer(); 262         for (int i = 0; i < RUNS; i++) localMethod(); 263         stopChronometer(); 264          265         if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 266     } 267      268     // 3) INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 269 public void testVirtualMethodExit_jp_activated_NoArg() 270     { 271         if (useProse) { 272             aspectInterface.suspendNotification(Thread.currentThread()); 273             aspectInterface.setMethodExitWatch(method, new Object ()); 274             aspectInterface.resumeNotification(Thread.currentThread()); 275         } 276 277         startChronometer(); 278         for (int i = 0; i < RUNS; i++) localMethod(); 279         stopChronometer(); 280          281         if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 282     } 283 284     //===================================================== 285 286     // 1) SYNC INVOKEVIRTUAL - no call to weaver because the joinpoint isn't activated 287 public void testSyncVirtualMethod_no_jp_NoArg() 288     { 289         startChronometer(); 290         for (int i = 0; i < RUNS; i++) obSync.syncMethodShort(); 291         stopChronometer(); 292     } 293      294     // 2) SYNC INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 295 public void testSyncVirtualMethodEntry_jp_activated_locked_NoArg() 296     { 297         if (useProse) { 298             aspectInterface.suspendNotification(Thread.currentThread()); //suspend all the events(notifications) before the watch(es) has been set 299 aspectInterface.setMethodEntryWatch(syncMethod, new Object ()); 300             aspectInterface.resumeNotification(Thread.currentThread()); //advice weaving: all the joinpoints are activated atomically 301 aspectInterface.suspendNotification(Thread.currentThread()); 302         } 303 304         startChronometer(); 305         for (int i = 0; i < RUNS; i++) obSync.syncMethodShort(); 306         stopChronometer(); 307     } 308 309     // 2) SYNC INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 310 public void testSyncVirtualMethodExit_jp_activated_locked_NoArg() 311     { 312         if (useProse) { 313             aspectInterface.suspendNotification(Thread.currentThread()); 314             aspectInterface.setMethodExitWatch(syncMethod, new Object ()); 315             aspectInterface.resumeNotification(Thread.currentThread()); 316             aspectInterface.suspendNotification(Thread.currentThread()); 317         } 318 319         startChronometer(); 320         for (int i = 0; i < RUNS; i++) obSync.syncMethodShort(); 321         stopChronometer(); 322     } 323      324     // 3) SYNC INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 325 public void testSyncVirtualMethodEntry_jp_activated_NoArg() 326     { 327         if (useProse) { 328             aspectInterface.suspendNotification(Thread.currentThread()); 329             aspectInterface.setMethodEntryWatch(syncMethod, new Object ()); 330             aspectInterface.resumeNotification(Thread.currentThread()); 331         } 332 333         startChronometer(); 334         for (int i = 0; i < RUNS; i++) obSync.syncMethodShort(); 335         stopChronometer(); 336          337         if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 338     } 339      340     // 3) SYNC INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 341 public void testSyncVirtualMethodExit_jp_activated_NoArg() 342     { 343         if (useProse) { 344             aspectInterface.suspendNotification(Thread.currentThread()); 345             aspectInterface.setMethodExitWatch(syncMethod, new Object ()); 346             aspectInterface.resumeNotification(Thread.currentThread()); 347         } 348 349         startChronometer(); 350         for (int i = 0; i < RUNS; i++) obSync.syncMethodShort(); 351         stopChronometer(); 352          353         if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 354     } 355      356     //===================================================== 357 358     // 1) INVOKEINTERFACE - no call to weaver because the joinpoint isn't activated 359 public void testInterfaceMethod_no_jp_NoArg() 360     { 361         startChronometer(); 362         for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodShort(); 363         stopChronometer(); 364     } 365      366     // 2) INVOKEINTERFACE - no call to weaver because joinpoint is activated but locked 367 public void testInterfaceMethodEntry_jp_activated_locked_NoArg() 368     { 369         if (useProse) { 370             aspectInterface.suspendNotification(Thread.currentThread()); 371             aspectInterface.setMethodEntryWatch(interfaceMethod, new Object ()); 372             aspectInterface.resumeNotification(Thread.currentThread()); 373             aspectInterface.suspendNotification(Thread.currentThread()); 374         } 375 376         startChronometer(); 377         for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodShort(); 378         stopChronometer(); 379     } 380 381     // 2) INVOKEINTERFACE - no call to weaver because joinpoint is activated but locked 382 public void testInterfaceMethodExit_jp_activated_locked_NoArg() 383     { 384         if (useProse) { 385             aspectInterface.suspendNotification(Thread.currentThread()); 386             aspectInterface.setMethodExitWatch(interfaceMethod, new Object ()); 387             aspectInterface.resumeNotification(Thread.currentThread()); 388             aspectInterface.suspendNotification(Thread.currentThread()); 389         } 390 391         startChronometer(); 392         for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodShort(); 393         stopChronometer(); 394     } 395      396     // 3) INVOKEINTERFACE - call to empty weaver because of on active, unlocked joinpoint 397 public void testInterfaceMethodEntry_jp_activated_NoArg() 398     { 399         if (useProse) { 400             aspectInterface.suspendNotification(Thread.currentThread()); 401             aspectInterface.setMethodEntryWatch(interfaceMethod, new Object ()); 402             aspectInterface.resumeNotification(Thread.currentThread()); 403         } 404 405         startChronometer(); 406         for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodShort(); 407         stopChronometer(); 408          409         if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 410     } 411      412     // 3) INVOKEINTERFACE - call to empty weaver because of on active, unlocked joinpoint 413 public void testInterfaceMethodExit_jp_activated_NoArg() 414     { 415         if (useProse) { 416             aspectInterface.suspendNotification(Thread.currentThread()); 417             aspectInterface.setMethodExitWatch(interfaceMethod, new Object ()); 418             aspectInterface.resumeNotification(Thread.currentThread()); 419         } 420 421         startChronometer(); 422         for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodShort(); 423         stopChronometer(); 424          425         if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 426     } 427      428     //===================================================== 429 430     // 1) INVOKESTATIC - no call to weaver because the joinpoint isn't activated 431 public void testStaticMethod_no_jp_NoArg() 432     { 433         startChronometer(); 434         for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodShort(); 435         stopChronometer(); 436     } 437      438     // 2) INVOKESTATIC - no call to weaver because joinpoint is activated but locked 439 public void testStaticMethodEntry_jp_activated_locked_NoArg() 440     { 441         if (useProse) { 442             aspectInterface.suspendNotification(Thread.currentThread()); 443             aspectInterface.setMethodEntryWatch(staticMethod, new Object ()); 444             aspectInterface.resumeNotification(Thread.currentThread()); 445             aspectInterface.suspendNotification(Thread.currentThread()); 446         } 447 448         startChronometer(); 449         for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodShort(); 450         stopChronometer(); 451     } 452 453     // 2) INVOKESTATIC - no call to weaver because joinpoint is activated but locked 454 public void testStaticMethodExit_jp_activated_locked_NoArg() 455     { 456         if (useProse) { 457             aspectInterface.suspendNotification(Thread.currentThread()); 458             aspectInterface.setMethodExitWatch(staticMethod, new Object ()); 459             aspectInterface.resumeNotification(Thread.currentThread()); 460             aspectInterface.suspendNotification(Thread.currentThread()); 461         } 462 463         startChronometer(); 464         for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodShort(); 465         stopChronometer(); 466     } 467      468     // 3) INVOKESTATIC - call to empty weaver because of on active, unlocked joinpoint 469 public void testStaticMethodEntry_jp_activated_NoArg() 470     { 471         if (useProse) { 472             aspectInterface.suspendNotification(Thread.currentThread()); 473             aspectInterface.setMethodEntryWatch(staticMethod, new Object ()); 474             aspectInterface.resumeNotification(Thread.currentThread()); 475         } 476 477         startChronometer(); 478         for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodShort(); 479         stopChronometer(); 480          481         if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 482     } 483 484     // 3) INVOKESTATIC - call to empty weaver because of on active, unlocked joinpoint 485 public void testStaticMethodExit_jp_activated_NoArg() 486     { 487         if (useProse) { 488             aspectInterface.suspendNotification(Thread.currentThread()); 489             aspectInterface.setMethodExitWatch(staticMethod, new Object ()); 490             aspectInterface.resumeNotification(Thread.currentThread()); 491         } 492 493         startChronometer(); 494         for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodShort(); 495         stopChronometer(); 496          497         if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 498     } 499      500     //===================================================== 501 502     // 1) INVOKESPECIAL - no call to weaver because the joinpoint isn't activated 503 public void testSpecialMethod_no_jp_NoArg() 504     { 505         startChronometer(); 506         for (int i = 0; i < RUNS; i++) privatelocalMethod(); 507         stopChronometer(); 508     } 509      510     // 2) INVOKESPECIAL - no call to weaver because joinpoint is activated but locked 511 public void testSpecialMethodEntry_jp_activated_locked_NoArg() 512     { 513         if (useProse) { 514             aspectInterface.suspendNotification(Thread.currentThread()); 515             aspectInterface.setMethodEntryWatch(privateMethod, new Object ()); 516             aspectInterface.resumeNotification(Thread.currentThread()); 517             aspectInterface.suspendNotification(Thread.currentThread()); 518         } 519 520         startChronometer(); 521         for (int i = 0; i < RUNS; i++) privatelocalMethod(); 522         stopChronometer(); 523     } 524 525     // 2) INVOKESPECIAL - no call to weaver because joinpoint is activated but locked 526 public void testSpecialMethodExit_jp_activated_locked_NoArg() 527     { 528         if (useProse) { 529             aspectInterface.suspendNotification(Thread.currentThread()); 530             aspectInterface.setMethodExitWatch(privateMethod, new Object ()); 531             aspectInterface.resumeNotification(Thread.currentThread()); 532             aspectInterface.suspendNotification(Thread.currentThread()); 533         } 534 535         startChronometer(); 536         for (int i = 0; i < RUNS; i++) privatelocalMethod(); 537         stopChronometer(); 538     } 539      540     // 3) INVOKESPECIAL - call to empty weaver because of on active, unlocked joinpoint 541 public void testSpecialMethodEntry_jp_activated_NoArg() 542     { 543         if (useProse) { 544             aspectInterface.suspendNotification(Thread.currentThread()); 545             aspectInterface.setMethodEntryWatch(privateMethod, new Object ()); 546             aspectInterface.resumeNotification(Thread.currentThread()); 547         } 548 549         startChronometer(); 550         for (int i = 0; i < RUNS; i++) privatelocalMethod(); 551         stopChronometer(); 552          553         if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 554     } 555      556     // 3) INVOKESPECIAL - call to empty weaver because of on active, unlocked joinpoint 557 public void testSpecialMethodExit_jp_activated_NoArg() 558     { 559         if (useProse) { 560             aspectInterface.suspendNotification(Thread.currentThread()); 561             aspectInterface.setMethodExitWatch(privateMethod, new Object ()); 562             aspectInterface.resumeNotification(Thread.currentThread()); 563         } 564 565         startChronometer(); 566         for (int i = 0; i < RUNS; i++) privatelocalMethod(); 567         stopChronometer(); 568          569         if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 570     } 571 572     //===================================================== 573 574     // 1) GETFIELD - no call to weaver because the joinpoint isn't activated 575 public void testFieldAccess_no_jp_NoArg() 576     { 577         this.theFieldAccess(RUNS); 578     } 579      580     // 2) GETFIELD - no call to weaver because joinpoint is activated but locked 581 public void testFieldAccess_jp_activated_locked_NoArg() 582     { 583         if (useProse) { 584             aspectInterface.suspendNotification(Thread.currentThread()); 585             aspectInterface.setFieldAccessWatch(field, new Object ()); 586             aspectInterface.resumeNotification(Thread.currentThread()); 587             aspectInterface.suspendNotification(Thread.currentThread()); 588         } 589 590         this.theFieldAccess(RUNS); 591     } 592 593     // 3) GETFIELD - call to empty weaver because of on active, unlocked joinpoint 594 public void testFieldAccess_jp_activated_NoArg() 595     { 596         if (useProse) { 597             aspectInterface.suspendNotification(Thread.currentThread()); 598             aspectInterface.setFieldAccessWatch(field, new Object ()); 599             aspectInterface.resumeNotification(Thread.currentThread()); 600         } 601 602         this.theFieldAccess(RUNS); 603 604         if (checkAssert) assertEquals("Hook notifications", RUNS, fieldAccessCount); 605     } 606 607     //===================================================== 608 609     // 1) PUTFIELD - no call to weaver because the joinpoint isn't activated 610 public void testFieldModification_no_jp_NoArg() 611     { 612         this.theFieldModification(RUNS); 613     } 614      615     // 2) PUTFIELD - no call to weaver because joinpoint is activated but locked 616 public void testFieldModification_jp_activated_locked_NoArg() 617     { 618         if (useProse) { 619             aspectInterface.suspendNotification(Thread.currentThread()); 620             aspectInterface.setFieldModificationWatch(field, new Object ()); 621             aspectInterface.resumeNotification(Thread.currentThread()); 622             aspectInterface.suspendNotification(Thread.currentThread()); 623         } 624 625         this.theFieldModification(RUNS); 626     } 627 628     // 3) PUTFIELD - call to empty weaver because of on active, unlocked joinpoint 629 public void testFieldModification_jp_activated_NoArg() 630     { 631         if (useProse) { 632             aspectInterface.suspendNotification(Thread.currentThread()); 633             aspectInterface.setFieldModificationWatch(field, new Object ()); 634             aspectInterface.resumeNotification(Thread.currentThread()); 635         } 636 637         this.theFieldModification(RUNS); 638 639         if (checkAssert) assertEquals("Hook notifications", RUNS, fieldModificationCount); 640     } 641      642     //===================================================== 643 644     public void exceptionThrow() throws TestException { 645         throw exception; 646     } 647 648     public void exceptionCatch() { 649         try { 650             exceptionThrow(); 651         } catch (TestException e) {} 652     } 653 654     //===================================================== 655 656     // 1) THROW - no call to weaver because the joinpoint isn't activated 657 public void testExceptionThrow_no_jp_NoArg() 658     { 659         //RUNS = 1000000; 660 TestException e = new TestException(); 661 662         startChronometer(); 663         for (int i = 0; i < RUNS; i++) exceptionCatch(); 664         stopChronometer(); 665     } 666      667     // 2) THROW - no call to weaver because joinpoint is activated but locked 668 public void testExceptionThrow_jp_activated_locked_NoArg() 669     { 670         if (useProse) { 671             aspectInterface.suspendNotification(Thread.currentThread()); 672             aspectInterface.setExceptionThrowWatch(TestException.class, new Object ()); 673             aspectInterface.resumeNotification(Thread.currentThread()); 674             aspectInterface.suspendNotification(Thread.currentThread()); 675         } 676 677         //RUNS = 1000000; 678 TestException e = new TestException(); 679 680         startChronometer(); 681         for (int i = 0; i < RUNS; i++) exceptionCatch(); 682         stopChronometer(); 683     } 684 685     // 3) THROW - call to empty weaver because of on active, unlocked joinpoint 686 public void testExceptionThrow_jp_activated_NoArg() 687     { 688         if (useProse) { 689             aspectInterface.suspendNotification(Thread.currentThread()); 690             aspectInterface.setExceptionThrowWatch(TestException.class, new Object ()); 691             aspectInterface.resumeNotification(Thread.currentThread()); 692         } 693 694         //RUNS = 1000000; 695 TestException e = new TestException(); 696 697         startChronometer(); 698         for (int i = 0; i < RUNS; i++) exceptionCatch(); 699         stopChronometer(); 700          701         if (checkAssert) assertEquals("Hook notifications", RUNS, exceptionThrowCount); 702     } 703 704     //===================================================== 705 706     // 1) CATCH - no call to weaver because the joinpoint isn't activated 707 public void testExceptionCatch_no_jp_NoArg() 708     { 709         //RUNS = 1000000; 710 TestException e = new TestException(); 711 712         startChronometer(); 713         for (int i = 0; i < RUNS; i++) exceptionCatch(); 714         stopChronometer(); 715     } 716      717     // 2) CATCH - no call to weaver because joinpoint is activated but locked 718 public void testExceptionCatch_jp_activated_locked_NoArg() { 719         if (useProse) { 720             aspectInterface.suspendNotification(Thread.currentThread()); 721             aspectInterface.setExceptionCatchWatch(TestException.class, new Object ()); 722             aspectInterface.resumeNotification(Thread.currentThread()); 723             aspectInterface.suspendNotification(Thread.currentThread()); 724         } 725 726         //RUNS = 1000000; 727 TestException e = new TestException(); 728 729         startChronometer(); 730         for (int i = 0; i < RUNS; i++) exceptionCatch(); 731         stopChronometer(); 732     } 733 734     // 3) CATCH - call to empty weaver because of on active, unlocked joinpoint 735 public void testExceptionCatch_jp_activated_NoArg() 736     { 737         if (useProse) { 738             aspectInterface.suspendNotification(Thread.currentThread()); 739             aspectInterface.setExceptionCatchWatch(TestException.class, new Object ()); 740             aspectInterface.resumeNotification(Thread.currentThread()); 741         } 742 743         //RUNS = 1000000; 744 TestException e = new TestException(); 745 746         startChronometer(); 747         for (int i = 0; i < RUNS; i++) exceptionCatch(); 748         stopChronometer(); 749          750         if (checkAssert) assertEquals("Hook notifications", RUNS, exceptionCatchCount); 751     } 752      753      754     //===================================================== 755 //===================================================== 756 //===================================================== 757 //===================================================== 758 //===================================================== 759 760     // Method arguments: (Object, Object) 761 //===================================================== 762 763     // 1) INVOKEVIRTUAL - no call to weaver because the joinpoint isn't activated 764 public void testVirtualMethod_LongO() 765     { 766         Object obj = new Object (); 767         startChronometer(); 768         for (int i = 0; i < RUNS; i++) localMethodLongO(obj, obj); 769         stopChronometer(); 770     } 771 /* 772     // 2) INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 773     public void testVirtualMethodEntry_jp_activated_locked_LongO() 774     { 775         Object obj = new Object(); 776         if (useProse) { 777             aspectInterface.suspendNotification(Thread.currentThread()); 778             aspectInterface.setMethodEntryWatch(methodLongO, new Object()); 779             aspectInterface.resumeNotification(Thread.currentThread()); 780             aspectInterface.suspendNotification(Thread.currentThread()); 781         } 782 783         startChronometer(); 784         for (int i = 0; i < RUNS; i++) localMethodLongO(obj, obj); 785         stopChronometer(); 786     } 787 788     // 2) INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 789     public void testVirtualMethodExit_jp_activated_locked_LongO() 790     { 791         Object obj = new Object(); 792         if (useProse) { 793             aspectInterface.suspendNotification(Thread.currentThread()); 794             aspectInterface.setMethodExitWatch(methodLongO, new Object()); 795             aspectInterface.resumeNotification(Thread.currentThread()); 796             aspectInterface.suspendNotification(Thread.currentThread()); 797         } 798 799         startChronometer(); 800         for (int i = 0; i < RUNS; i++) localMethodLongO(obj, obj); 801         stopChronometer(); 802     } 803 */ 804     // 3) INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 805 public void testVirtualMethodEntry_jp_activated_LongO() 806     { 807         Object obj = new Object (); 808         if (useProse) { 809             aspectInterface.suspendNotification(Thread.currentThread()); 810             aspectInterface.setMethodEntryWatch(methodLongO, new Object ()); 811             aspectInterface.resumeNotification(Thread.currentThread()); 812         } 813 814         startChronometer(); 815         for (int i = 0; i < RUNS; i++) localMethodLongO(obj, obj); 816         stopChronometer(); 817          818         if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 819     } 820      821     // 3) INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 822 public void testVirtualMethodExit_jp_activated_LongO() 823     { 824         Object obj = new Object (); 825         if (useProse) { 826             aspectInterface.suspendNotification(Thread.currentThread()); 827             aspectInterface.setMethodExitWatch(methodLongO, new Object ()); 828             aspectInterface.resumeNotification(Thread.currentThread()); 829         } 830 831         startChronometer(); 832         for (int i = 0; i < RUNS; i++) localMethodLongO(obj, obj); 833         stopChronometer(); 834          835         if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 836     } 837 838     //===================================================== 839 840     // 1) SYNC INVOKEVIRTUAL - no call to weaver because the joinpoint isn't activated 841 public void testSyncVirtualMethod_LongO() 842     { 843         Object obj = new Object (); 844         startChronometer(); 845         for (int i = 0; i < RUNS; i++) obSync.syncMethodLongO(obj, obj); 846         stopChronometer(); 847     } 848 /* 849     // 2) SYNC INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 850     public void testSyncVirtualMethodEntry_jp_activated_locked_LongO() 851     { 852         Object obj = new Object(); 853         if (useProse) { 854             aspectInterface.suspendNotification(Thread.currentThread()); 855             aspectInterface.setMethodEntryWatch(syncMethodLongO, new Object()); 856             aspectInterface.resumeNotification(Thread.currentThread()); 857             aspectInterface.suspendNotification(Thread.currentThread()); 858         } 859 860         startChronometer(); 861         for (int i = 0; i < RUNS; i++) obSync.syncMethodLongO(obj, obj); 862         stopChronometer(); 863     } 864 865     // 2) SYNC INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 866     public void testSyncVirtualMethodExit_jp_activated_locked_LongO() 867     { 868         Object obj = new Object(); 869         if (useProse) { 870             aspectInterface.suspendNotification(Thread.currentThread()); 871             aspectInterface.setMethodExitWatch(syncMethodLongO, new Object()); 872             aspectInterface.resumeNotification(Thread.currentThread()); 873             aspectInterface.suspendNotification(Thread.currentThread()); 874         } 875 876         startChronometer(); 877         for (int i = 0; i < RUNS; i++) obSync.syncMethodLongO(obj, obj); 878         stopChronometer(); 879     } 880 */ 881     // 3) SYNC INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 882 public void testSyncVirtualMethodEntry_jp_activated_LongO() 883     { 884         Object obj = new Object (); 885         if (useProse) { 886             aspectInterface.suspendNotification(Thread.currentThread()); 887             aspectInterface.setMethodEntryWatch(syncMethodLongO, new Object ()); 888             aspectInterface.resumeNotification(Thread.currentThread()); 889         } 890 891         startChronometer(); 892         for (int i = 0; i < RUNS; i++) obSync.syncMethodLongO(obj, obj); 893         stopChronometer(); 894          895         if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 896     } 897      898     // 3) SYNC INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 899 public void testSyncVirtualMethodExit_jp_activated_LongO() 900     { 901         Object obj = new Object (); 902         if (useProse) { 903             aspectInterface.suspendNotification(Thread.currentThread()); 904             aspectInterface.setMethodExitWatch(syncMethodLongO, new Object ()); 905             aspectInterface.resumeNotification(Thread.currentThread()); 906         } 907 908         startChronometer(); 909         for (int i = 0; i < RUNS; i++) obSync.syncMethodLongO(obj, obj); 910         stopChronometer(); 911          912         if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 913     } 914      915     //===================================================== 916 917     // 1) INVOKEINTERFACE - no call to weaver because the joinpoint isn't activated 918 public void testInterfaceMethod_LongO() 919     { 920         Object obj = new Object (); 921         startChronometer(); 922         for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongO(obj, obj); 923         stopChronometer(); 924     } 925 /* 926     // 2) INVOKEINTERFACE - no call to weaver because joinpoint is activated but locked 927     public void testInterfaceMethodEntry_jp_activated_locked_LongO() 928     { 929         Object obj = new Object(); 930         if (useProse) { 931             aspectInterface.suspendNotification(Thread.currentThread()); 932             aspectInterface.setMethodEntryWatch(interfaceMethodLongO, new Object()); 933             aspectInterface.resumeNotification(Thread.currentThread()); 934             aspectInterface.suspendNotification(Thread.currentThread()); 935         } 936 937         startChronometer(); 938         for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongO(obj, obj); 939         stopChronometer(); 940     } 941 942     // 2) INVOKEINTERFACE - no call to weaver because joinpoint is activated but locked 943     public void testInterfaceMethodExit_jp_activated_locked_LongO() 944     { 945         Object obj = new Object(); 946         if (useProse) { 947             aspectInterface.suspendNotification(Thread.currentThread()); 948             aspectInterface.setMethodExitWatch(interfaceMethodLongO, new Object()); 949             aspectInterface.resumeNotification(Thread.currentThread()); 950             aspectInterface.suspendNotification(Thread.currentThread()); 951         } 952 953         startChronometer(); 954         for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongO(obj, obj); 955         stopChronometer(); 956     } 957 */ 958     // 3) INVOKEINTERFACE - call to empty weaver because of on active, unlocked joinpoint 959 public void testInterfaceMethodEntry_jp_activated_LongO() 960     { 961         Object obj = new Object (); 962         if (useProse) { 963             aspectInterface.suspendNotification(Thread.currentThread()); 964             aspectInterface.setMethodEntryWatch(interfaceMethodLongO, new Object ()); 965             aspectInterface.resumeNotification(Thread.currentThread()); 966         } 967 968         startChronometer(); 969         for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongO(obj, obj); 970         stopChronometer(); 971          972         if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 973     } 974      975     // 3) INVOKEINTERFACE - call to empty weaver because of on active, unlocked joinpoint 976 public void testInterfaceMethodExit_jp_activated_LongO() 977     { 978         Object obj = new Object (); 979         if (useProse) { 980             aspectInterface.suspendNotification(Thread.currentThread()); 981             aspectInterface.setMethodExitWatch(interfaceMethodLongO, new Object ()); 982             aspectInterface.resumeNotification(Thread.currentThread()); 983         } 984 985         startChronometer(); 986         for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongO(obj, obj); 987         stopChronometer(); 988          989         if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 990     } 991      992     //===================================================== 993 994     // 1) INVOKESTATIC - no call to weaver because the joinpoint isn't activated 995 public void testStaticMethod_LongO() 996     { 997         Object obj = new Object (); 998         startChronometer(); 999         for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongO(obj, obj); 1000        stopChronometer(); 1001    } 1002/* 1003    // 2) INVOKESTATIC - no call to weaver because joinpoint is activated but locked 1004    public void testStaticMethodEntry_jp_activated_locked_LongO() 1005    { 1006        Object obj = new Object(); 1007        if (useProse) { 1008            aspectInterface.suspendNotification(Thread.currentThread()); 1009            aspectInterface.setMethodEntryWatch(staticMethodLongO, new Object()); 1010            aspectInterface.resumeNotification(Thread.currentThread()); 1011            aspectInterface.suspendNotification(Thread.currentThread()); 1012        } 1013 1014        startChronometer(); 1015        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongO(obj, obj); 1016        stopChronometer(); 1017    } 1018 1019    // 2) INVOKESTATIC - no call to weaver because joinpoint is activated but locked 1020    public void testStaticMethodExit_jp_activated_locked_LongO() 1021    { 1022        Object obj = new Object(); 1023        if (useProse) { 1024            aspectInterface.suspendNotification(Thread.currentThread()); 1025            aspectInterface.setMethodExitWatch(staticMethodLongO, new Object()); 1026            aspectInterface.resumeNotification(Thread.currentThread()); 1027            aspectInterface.suspendNotification(Thread.currentThread()); 1028        } 1029 1030        startChronometer(); 1031        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongO(obj, obj); 1032        stopChronometer(); 1033    } 1034*/ 1035    // 3) INVOKESTATIC - call to empty weaver because of on active, unlocked joinpoint 1036 public void testStaticMethodEntry_jp_activated_LongO() 1037    { 1038        Object obj = new Object (); 1039        if (useProse) { 1040            aspectInterface.suspendNotification(Thread.currentThread()); 1041            aspectInterface.setMethodEntryWatch(staticMethodLongO, new Object ()); 1042            aspectInterface.resumeNotification(Thread.currentThread()); 1043        } 1044 1045        startChronometer(); 1046        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongO(obj, obj); 1047        stopChronometer(); 1048         1049        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 1050    } 1051 1052    // 3) INVOKESTATIC - call to empty weaver because of on active, unlocked joinpoint 1053 public void testStaticMethodExit_jp_activated_LongO() 1054    { 1055        Object obj = new Object (); 1056        if (useProse) { 1057            aspectInterface.suspendNotification(Thread.currentThread()); 1058            aspectInterface.setMethodExitWatch(staticMethodLongO, new Object ()); 1059            aspectInterface.resumeNotification(Thread.currentThread()); 1060        } 1061 1062        startChronometer(); 1063        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongO(obj, obj); 1064        stopChronometer(); 1065         1066        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 1067    } 1068     1069    //===================================================== 1070 1071    // 1) INVOKESPECIAL - no call to weaver because the joinpoint isn't activated 1072 public void testSpecialMethod_LongO() 1073    { 1074        Object obj = new Object (); 1075        startChronometer(); 1076        for (int i = 0; i < RUNS; i++) privatelocalMethodLongO(obj, obj); 1077        stopChronometer(); 1078    } 1079/* 1080    // 2) INVOKESPECIAL - no call to weaver because joinpoint is activated but locked 1081    public void testSpecialMethodEntry_jp_activated_locked_LongO() 1082    { 1083        Object obj = new Object(); 1084        if (useProse) { 1085            aspectInterface.suspendNotification(Thread.currentThread()); 1086            aspectInterface.setMethodEntryWatch(privateMethodLongO, new Object()); 1087            aspectInterface.resumeNotification(Thread.currentThread()); 1088            aspectInterface.suspendNotification(Thread.currentThread()); 1089        } 1090 1091        startChronometer(); 1092        for (int i = 0; i < RUNS; i++) privatelocalMethodLongO(obj, obj); 1093        stopChronometer(); 1094    } 1095 1096    // 2) INVOKESPECIAL - no call to weaver because joinpoint is activated but locked 1097    public void testSpecialMethodExit_jp_activated_locked_LongO() 1098    { 1099        Object obj = new Object(); 1100        if (useProse) { 1101            aspectInterface.suspendNotification(Thread.currentThread()); 1102            aspectInterface.setMethodExitWatch(privateMethodLongO, new Object()); 1103            aspectInterface.resumeNotification(Thread.currentThread()); 1104            aspectInterface.suspendNotification(Thread.currentThread()); 1105        } 1106 1107        startChronometer(); 1108        for (int i = 0; i < RUNS; i++) privatelocalMethodLongO(obj, obj); 1109        stopChronometer(); 1110    } 1111*/ 1112    // 3) INVOKESPECIAL - call to empty weaver because of on active, unlocked joinpoint 1113 public void testSpecialMethodEntry_jp_activated_LongO() 1114    { 1115        Object obj = new Object (); 1116        if (useProse) { 1117            aspectInterface.suspendNotification(Thread.currentThread()); 1118            aspectInterface.setMethodEntryWatch(privateMethodLongO, new Object ()); 1119            aspectInterface.resumeNotification(Thread.currentThread()); 1120        } 1121 1122        startChronometer(); 1123        for (int i = 0; i < RUNS; i++) privatelocalMethodLongO(obj, obj); 1124        stopChronometer(); 1125         1126        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 1127    } 1128     1129    // 3) INVOKESPECIAL - call to empty weaver because of on active, unlocked joinpoint 1130 public void testSpecialMethodExit_jp_activated_LongO() 1131    { 1132        Object obj = new Object (); 1133        if (useProse) { 1134            aspectInterface.suspendNotification(Thread.currentThread()); 1135            aspectInterface.setMethodExitWatch(privateMethodLongO, new Object ()); 1136            aspectInterface.resumeNotification(Thread.currentThread()); 1137        } 1138 1139        startChronometer(); 1140        for (int i = 0; i < RUNS; i++) privatelocalMethodLongO(obj, obj); 1141        stopChronometer(); 1142         1143        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 1144    } 1145     1146    //===================================================== 1147 //===================================================== 1148 1149     1150    // Method arguments: (int, int) 1151 //===================================================== 1152 1153    // 1) INVOKEVIRTUAL - no call to weaver because the joinpoint isn't activated 1154 public void testVirtualMethod_LongI() 1155    { 1156        int obj = 1; 1157        startChronometer(); 1158        for (int i = 0; i < RUNS; i++) localMethodLongI(obj, obj); 1159        stopChronometer(); 1160    } 1161/* 1162    // 2) INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 1163    public void testVirtualMethodEntry_jp_activated_locked_LongI() 1164    { 1165        int obj = 1; 1166        if (useProse) { 1167            aspectInterface.suspendNotification(Thread.currentThread()); 1168            aspectInterface.setMethodEntryWatch(methodLongI, new Object()); 1169            aspectInterface.resumeNotification(Thread.currentThread()); 1170            aspectInterface.suspendNotification(Thread.currentThread()); 1171        } 1172 1173        startChronometer(); 1174        for (int i = 0; i < RUNS; i++) localMethodLongI(obj, obj); 1175        stopChronometer(); 1176    } 1177 1178    // 2) INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 1179    public void testVirtualMethodExit_jp_activated_locked_LongI() 1180    { 1181        int obj = 1; 1182        if (useProse) { 1183            aspectInterface.suspendNotification(Thread.currentThread()); 1184            aspectInterface.setMethodExitWatch(methodLongI, new Object()); 1185            aspectInterface.resumeNotification(Thread.currentThread()); 1186            aspectInterface.suspendNotification(Thread.currentThread()); 1187        } 1188 1189        startChronometer(); 1190        for (int i = 0; i < RUNS; i++) localMethodLongI(obj, obj); 1191        stopChronometer(); 1192    } 1193*/ 1194    // 3) INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 1195 public void testVirtualMethodEntry_jp_activated_LongI() 1196    { 1197        int obj = 1; 1198        if (useProse) { 1199            aspectInterface.suspendNotification(Thread.currentThread()); 1200            aspectInterface.setMethodEntryWatch(methodLongI, new Object ()); 1201            aspectInterface.resumeNotification(Thread.currentThread()); 1202        } 1203 1204        startChronometer(); 1205        for (int i = 0; i < RUNS; i++) localMethodLongI(obj, obj); 1206        stopChronometer(); 1207         1208        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 1209    } 1210     1211    // 3) INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 1212 public void testVirtualMethodExit_jp_activated_LongI() 1213    { 1214        int obj = 1; 1215        if (useProse) { 1216            aspectInterface.suspendNotification(Thread.currentThread()); 1217            aspectInterface.setMethodExitWatch(methodLongI, new Object ()); 1218            aspectInterface.resumeNotification(Thread.currentThread()); 1219        } 1220 1221        startChronometer(); 1222        for (int i = 0; i < RUNS; i++) localMethodLongI(obj, obj); 1223        stopChronometer(); 1224         1225        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 1226    } 1227     1228    //===================================================== 1229 1230    // 1) SYNC INVOKEVIRTUAL - no call to weaver because the joinpoint isn't activated 1231 public void testSyncVirtualMethod_LongI() 1232    { 1233        int obj = 1; 1234        startChronometer(); 1235        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongI(obj, obj); 1236        stopChronometer(); 1237    } 1238/* 1239    // 2) SYNC INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 1240    public void testSyncVirtualMethodEntry_jp_activated_locked_LongI() 1241    { 1242        int obj = 1; 1243        if (useProse) { 1244            aspectInterface.suspendNotification(Thread.currentThread()); 1245            aspectInterface.setMethodEntryWatch(syncMethodLongI, new Object()); 1246            aspectInterface.resumeNotification(Thread.currentThread()); 1247            aspectInterface.suspendNotification(Thread.currentThread()); 1248        } 1249 1250        startChronometer(); 1251        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongI(obj, obj); 1252        stopChronometer(); 1253    } 1254 1255    // 2) SYNC INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 1256    public void testSyncVirtualMethodExit_jp_activated_locked_LongI() 1257    { 1258        int obj = 1; 1259        if (useProse) { 1260            aspectInterface.suspendNotification(Thread.currentThread()); 1261            aspectInterface.setMethodExitWatch(syncMethodLongI, new Object()); 1262            aspectInterface.resumeNotification(Thread.currentThread()); 1263            aspectInterface.suspendNotification(Thread.currentThread()); 1264        } 1265 1266        startChronometer(); 1267        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongI(obj, obj); 1268        stopChronometer(); 1269    } 1270*/ 1271    // 3) SYNC INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 1272 public void testSyncVirtualMethodEntry_jp_activated_LongI() 1273    { 1274        int obj = 1; 1275        if (useProse) { 1276            aspectInterface.suspendNotification(Thread.currentThread()); 1277            aspectInterface.setMethodEntryWatch(syncMethodLongI, new Object ()); 1278            aspectInterface.resumeNotification(Thread.currentThread()); 1279        } 1280 1281        startChronometer(); 1282        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongI(obj, obj); 1283        stopChronometer(); 1284         1285        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 1286    } 1287     1288    // 3) SYNC INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 1289 public void testSyncVirtualMethodExit_jp_activated_LongI() 1290    { 1291        int obj = 1; 1292        if (useProse) { 1293            aspectInterface.suspendNotification(Thread.currentThread()); 1294            aspectInterface.setMethodExitWatch(syncMethodLongI, new Object ()); 1295            aspectInterface.resumeNotification(Thread.currentThread()); 1296        } 1297 1298        startChronometer(); 1299        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongI(obj, obj); 1300        stopChronometer(); 1301         1302        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 1303    } 1304     1305    //===================================================== 1306 1307    // 1) INVOKEINTERFACE - no call to weaver because the joinpoint isn't activated 1308 public void testInterfaceMethod_LongI() 1309    { 1310        int obj = 1; 1311        startChronometer(); 1312        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongI(obj, obj); 1313        stopChronometer(); 1314    } 1315/* 1316    // 2) INVOKEINTERFACE - no call to weaver because joinpoint is activated but locked 1317    public void testInterfaceMethodEntry_jp_activated_locked_LongI() 1318    { 1319        int obj = 1; 1320        if (useProse) { 1321            aspectInterface.suspendNotification(Thread.currentThread()); 1322            aspectInterface.setMethodEntryWatch(interfaceMethodLongI, new Object()); 1323            aspectInterface.resumeNotification(Thread.currentThread()); 1324            aspectInterface.suspendNotification(Thread.currentThread()); 1325        } 1326 1327        startChronometer(); 1328        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongI(obj, obj); 1329        stopChronometer(); 1330    } 1331 1332    // 2) INVOKEINTERFACE - no call to weaver because joinpoint is activated but locked 1333    public void testInterfaceMethodExit_jp_activated_locked_LongI() 1334    { 1335        int obj = 1; 1336        if (useProse) { 1337            aspectInterface.suspendNotification(Thread.currentThread()); 1338            aspectInterface.setMethodExitWatch(interfaceMethodLongI, new Object()); 1339            aspectInterface.resumeNotification(Thread.currentThread()); 1340            aspectInterface.suspendNotification(Thread.currentThread()); 1341        } 1342 1343        startChronometer(); 1344        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongI(obj, obj); 1345        stopChronometer(); 1346    } 1347*/ 1348    // 3) INVOKEINTERFACE - call to empty weaver because of on active, unlocked joinpoint 1349 public void testInterfaceMethodEntry_jp_activated_LongI() 1350    { 1351        int obj = 1; 1352        if (useProse) { 1353            aspectInterface.suspendNotification(Thread.currentThread()); 1354            aspectInterface.setMethodEntryWatch(interfaceMethodLongI, new Object ()); 1355            aspectInterface.resumeNotification(Thread.currentThread()); 1356        } 1357 1358        startChronometer(); 1359        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongI(obj, obj); 1360        stopChronometer(); 1361         1362        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 1363    } 1364     1365    // 3) INVOKEINTERFACE - call to empty weaver because of on active, unlocked joinpoint 1366 public void testInterfaceMethodExit_jp_activated_LongI() 1367    { 1368        int obj = 1; 1369        if (useProse) { 1370            aspectInterface.suspendNotification(Thread.currentThread()); 1371            aspectInterface.setMethodExitWatch(interfaceMethodLongI, new Object ()); 1372            aspectInterface.resumeNotification(Thread.currentThread()); 1373        } 1374 1375        startChronometer(); 1376        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongI(obj, obj); 1377        stopChronometer(); 1378         1379        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 1380    } 1381     1382    //===================================================== 1383 1384    // 1) INVOKESTATIC - no call to weaver because the joinpoint isn't activated 1385 public void testStaticMethod_LongI() 1386    { 1387        int obj = 1; 1388        startChronometer(); 1389        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongI(obj, obj); 1390        stopChronometer(); 1391    } 1392/* 1393    // 2) INVOKESTATIC - no call to weaver because joinpoint is activated but locked 1394    public void testStaticMethodEntry_jp_activated_locked_LongI() 1395    { 1396        int obj = 1; 1397        if (useProse) { 1398            aspectInterface.suspendNotification(Thread.currentThread()); 1399            aspectInterface.setMethodEntryWatch(staticMethodLongI, new Object()); 1400            aspectInterface.resumeNotification(Thread.currentThread()); 1401            aspectInterface.suspendNotification(Thread.currentThread()); 1402        } 1403 1404        startChronometer(); 1405        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongI(obj, obj); 1406        stopChronometer(); 1407    } 1408 1409    // 2) INVOKESTATIC - no call to weaver because joinpoint is activated but locked 1410    public void testStaticMethodExit_jp_activated_locked_LongI() 1411    { 1412        int obj = 1; 1413        if (useProse) { 1414            aspectInterface.suspendNotification(Thread.currentThread()); 1415            aspectInterface.setMethodExitWatch(staticMethodLongI, new Object()); 1416            aspectInterface.resumeNotification(Thread.currentThread()); 1417            aspectInterface.suspendNotification(Thread.currentThread()); 1418        } 1419 1420        startChronometer(); 1421        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongI(obj, obj); 1422        stopChronometer(); 1423    } 1424*/ 1425    // 3) INVOKESTATIC - call to empty weaver because of on active, unlocked joinpoint 1426 public void testStaticMethodEntry_jp_activated_LongI() 1427    { 1428        int obj = 1; 1429        if (useProse) { 1430            aspectInterface.suspendNotification(Thread.currentThread()); 1431            aspectInterface.setMethodEntryWatch(staticMethodLongI, new Object ()); 1432            aspectInterface.resumeNotification(Thread.currentThread()); 1433        } 1434 1435        startChronometer(); 1436        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongI(obj, obj); 1437        stopChronometer(); 1438         1439        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 1440    } 1441 1442    // 3) INVOKESTATIC - call to empty weaver because of on active, unlocked joinpoint 1443 public void testStaticMethodExit_jp_activated_LongI() 1444    { 1445        int obj = 1; 1446        if (useProse) { 1447            aspectInterface.suspendNotification(Thread.currentThread()); 1448            aspectInterface.setMethodExitWatch(staticMethodLongI, new Object ()); 1449            aspectInterface.resumeNotification(Thread.currentThread()); 1450        } 1451 1452        startChronometer(); 1453        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongI(obj, obj); 1454        stopChronometer(); 1455         1456        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 1457    } 1458     1459    //===================================================== 1460 1461    // 1) INVOKESPECIAL - no call to weaver because the joinpoint isn't activated 1462 public void testSpecialMethod_LongI() 1463    { 1464        int obj = 1; 1465        startChronometer(); 1466        for (int i = 0; i < RUNS; i++) privatelocalMethodLongI(obj, obj); 1467        stopChronometer(); 1468    } 1469/* 1470    // 2) INVOKESPECIAL - no call to weaver because joinpoint is activated but locked 1471    public void testSpecialMethodEntry_jp_activated_locked_LongI() 1472    { 1473        int obj = 1; 1474        if (useProse) { 1475            aspectInterface.suspendNotification(Thread.currentThread()); 1476            aspectInterface.setMethodEntryWatch(privateMethodLongI, new Object()); 1477            aspectInterface.resumeNotification(Thread.currentThread()); 1478            aspectInterface.suspendNotification(Thread.currentThread()); 1479        } 1480 1481        startChronometer(); 1482        for (int i = 0; i < RUNS; i++) privatelocalMethodLongI(obj, obj); 1483        stopChronometer(); 1484    } 1485 1486    // 2) INVOKESPECIAL - no call to weaver because joinpoint is activated but locked 1487    public void testSpecialMethodExit_jp_activated_locked_LongI() 1488    { 1489        int obj = 1; 1490        if (useProse) { 1491            aspectInterface.suspendNotification(Thread.currentThread()); 1492            aspectInterface.setMethodExitWatch(privateMethodLongI, new Object()); 1493            aspectInterface.resumeNotification(Thread.currentThread()); 1494            aspectInterface.suspendNotification(Thread.currentThread()); 1495        } 1496 1497        startChronometer(); 1498        for (int i = 0; i < RUNS; i++) privatelocalMethodLongI(obj, obj); 1499        stopChronometer(); 1500    } 1501*/ 1502    // 3) INVOKESPECIAL - call to empty weaver because of on active, unlocked joinpoint 1503 public void testSpecialMethodEntry_jp_activated_LongI() 1504    { 1505        int obj = 1; 1506        if (useProse) { 1507            aspectInterface.suspendNotification(Thread.currentThread()); 1508            aspectInterface.setMethodEntryWatch(privateMethodLongI, new Object ()); 1509            aspectInterface.resumeNotification(Thread.currentThread()); 1510        } 1511 1512        startChronometer(); 1513        for (int i = 0; i < RUNS; i++) privatelocalMethodLongI(obj, obj); 1514        stopChronometer(); 1515         1516        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 1517    } 1518     1519    // 3) INVOKESPECIAL - call to empty weaver because of on active, unlocked joinpoint 1520 public void testSpecialMethodExit_jp_activated_LongI() 1521    { 1522        int obj = 1; 1523        if (useProse) { 1524            aspectInterface.suspendNotification(Thread.currentThread()); 1525            aspectInterface.setMethodExitWatch(privateMethodLongI, new Object ()); 1526            aspectInterface.resumeNotification(Thread.currentThread()); 1527        } 1528 1529        startChronometer(); 1530        for (int i = 0; i < RUNS; i++) privatelocalMethodLongI(obj, obj); 1531        stopChronometer(); 1532         1533        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 1534    } 1535     1536    //===================================================== 1537 //===================================================== 1538 1539     1540    // Method arguments: (long, long) 1541 //===================================================== 1542 1543    // 1) INVOKEVIRTUAL - no call to weaver because the joinpoint isn't activated 1544 public void testVirtualMethod_LongL() 1545    { 1546        long obj = 1; 1547        startChronometer(); 1548        for (int i = 0; i < RUNS; i++) localMethodLongL(obj, obj); 1549        stopChronometer(); 1550    } 1551/* 1552    // 2) INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 1553    public void testVirtualMethodEntry_jp_activated_locked_LongL() 1554    { 1555        long obj = 1; 1556        if (useProse) { 1557            aspectInterface.suspendNotification(Thread.currentThread()); 1558            aspectInterface.setMethodEntryWatch(methodLongL, new Object()); 1559            aspectInterface.resumeNotification(Thread.currentThread()); 1560            aspectInterface.suspendNotification(Thread.currentThread()); 1561        } 1562 1563        startChronometer(); 1564        for (int i = 0; i < RUNS; i++) localMethodLongL(obj, obj); 1565        stopChronometer(); 1566    } 1567 1568    // 2) INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 1569    public void testVirtualMethodExit_jp_activated_locked_LongL() 1570    { 1571        long obj = 1; 1572        if (useProse) { 1573            aspectInterface.suspendNotification(Thread.currentThread()); 1574            aspectInterface.setMethodExitWatch(methodLongL, new Object()); 1575            aspectInterface.resumeNotification(Thread.currentThread()); 1576            aspectInterface.suspendNotification(Thread.currentThread()); 1577        } 1578 1579        startChronometer(); 1580        for (int i = 0; i < RUNS; i++) localMethodLongL(obj, obj); 1581        stopChronometer(); 1582    } 1583*/ 1584    // 3) INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 1585 public void testVirtualMethodEntry_jp_activated_LongL() 1586    { 1587        long obj = 1; 1588        if (useProse) { 1589            aspectInterface.suspendNotification(Thread.currentThread()); 1590            aspectInterface.setMethodEntryWatch(methodLongL, new Object ()); 1591            aspectInterface.resumeNotification(Thread.currentThread()); 1592        } 1593 1594        startChronometer(); 1595        for (int i = 0; i < RUNS; i++) localMethodLongL(obj, obj); 1596        stopChronometer(); 1597         1598        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 1599    } 1600     1601    // 3) INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 1602 public void testVirtualMethodExit_jp_activated_LongL() 1603    { 1604        long obj = 1; 1605        if (useProse) { 1606            aspectInterface.suspendNotification(Thread.currentThread()); 1607            aspectInterface.setMethodExitWatch(methodLongL, new Object ()); 1608            aspectInterface.resumeNotification(Thread.currentThread()); 1609        } 1610 1611        startChronometer(); 1612        for (int i = 0; i < RUNS; i++) localMethodLongL(obj, obj); 1613        stopChronometer(); 1614         1615        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 1616    } 1617     1618    //===================================================== 1619 1620    // 1) SYNC INVOKEVIRTUAL - no call to weaver because the joinpoint isn't activated 1621 public void testSyncVirtualMethod_LongL() 1622    { 1623        long obj = 1; 1624        startChronometer(); 1625        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongL(obj, obj); 1626        stopChronometer(); 1627    } 1628/* 1629    // 2) SYNC INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 1630    public void testSyncVirtualMethodEntry_jp_activated_locked_LongL() 1631    { 1632        long obj = 1; 1633        if (useProse) { 1634            aspectInterface.suspendNotification(Thread.currentThread()); 1635            aspectInterface.setMethodEntryWatch(syncMethodLongL, new Object()); 1636            aspectInterface.resumeNotification(Thread.currentThread()); 1637            aspectInterface.suspendNotification(Thread.currentThread()); 1638        } 1639 1640        startChronometer(); 1641        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongL(obj, obj); 1642        stopChronometer(); 1643    } 1644 1645    // 2) SYNC INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 1646    public void testSyncVirtualMethodExit_jp_activated_locked_LongL() 1647    { 1648        long obj = 1; 1649        if (useProse) { 1650            aspectInterface.suspendNotification(Thread.currentThread()); 1651            aspectInterface.setMethodExitWatch(syncMethodLongL, new Object()); 1652            aspectInterface.resumeNotification(Thread.currentThread()); 1653            aspectInterface.suspendNotification(Thread.currentThread()); 1654        } 1655 1656        startChronometer(); 1657        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongL(obj, obj); 1658        stopChronometer(); 1659    } 1660*/ 1661    // 3) SYNC INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 1662 public void testSyncVirtualMethodEntry_jp_activated_LongL() 1663    { 1664        long obj = 1; 1665        if (useProse) { 1666            aspectInterface.suspendNotification(Thread.currentThread()); 1667            aspectInterface.setMethodEntryWatch(syncMethodLongL, new Object ()); 1668            aspectInterface.resumeNotification(Thread.currentThread()); 1669        } 1670 1671        startChronometer(); 1672        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongL(obj, obj); 1673        stopChronometer(); 1674         1675        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 1676    } 1677     1678    // 3) SYNC INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 1679 public void testSyncVirtualMethodExit_jp_activated_LongL() 1680    { 1681        long obj = 1; 1682        if (useProse) { 1683            aspectInterface.suspendNotification(Thread.currentThread()); 1684            aspectInterface.setMethodExitWatch(syncMethodLongL, new Object ()); 1685            aspectInterface.resumeNotification(Thread.currentThread()); 1686        } 1687 1688        startChronometer(); 1689        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongL(obj, obj); 1690        stopChronometer(); 1691         1692        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 1693    } 1694     1695    //===================================================== 1696 1697    // 1) INVOKEINTERFACE - no call to weaver because the joinpoint isn't activated 1698 public void testInterfaceMethod_LongL() 1699    { 1700        long obj = 1; 1701        startChronometer(); 1702        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongL(obj, obj); 1703        stopChronometer(); 1704    } 1705/* 1706    // 2) INVOKEINTERFACE - no call to weaver because joinpoint is activated but locked 1707    public void testInterfaceMethodEntry_jp_activated_locked_LongL() 1708    { 1709        long obj = 1; 1710        if (useProse) { 1711            aspectInterface.suspendNotification(Thread.currentThread()); 1712            aspectInterface.setMethodEntryWatch(interfaceMethodLongL, new Object()); 1713            aspectInterface.resumeNotification(Thread.currentThread()); 1714            aspectInterface.suspendNotification(Thread.currentThread()); 1715        } 1716 1717        startChronometer(); 1718        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongL(obj, obj); 1719        stopChronometer(); 1720    } 1721 1722    // 2) INVOKEINTERFACE - no call to weaver because joinpoint is activated but locked 1723    public void testInterfaceMethodExit_jp_activated_locked_LongL() 1724    { 1725        long obj = 1; 1726        if (useProse) { 1727            aspectInterface.suspendNotification(Thread.currentThread()); 1728            aspectInterface.setMethodExitWatch(interfaceMethodLongL, new Object()); 1729            aspectInterface.resumeNotification(Thread.currentThread()); 1730        } 1731 1732        startChronometer(); 1733        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongL(obj, obj); 1734        stopChronometer(); 1735    } 1736*/ 1737    // 3) INVOKEINTERFACE - call to empty weaver because of on active, unlocked joinpoint 1738 public void testInterfaceMethodEntry_jp_activated_LongL() 1739    { 1740        long obj = 1; 1741        if (useProse) { 1742            aspectInterface.suspendNotification(Thread.currentThread()); 1743            aspectInterface.setMethodEntryWatch(interfaceMethodLongL, new Object ()); 1744            aspectInterface.resumeNotification(Thread.currentThread()); 1745        } 1746 1747        startChronometer(); 1748        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongL(obj, obj); 1749        stopChronometer(); 1750         1751        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 1752    } 1753     1754    // 3) INVOKEINTERFACE - call to empty weaver because of on active, unlocked joinpoint 1755 public void testInterfaceMethodExit_jp_activated_LongL() 1756    { 1757        long obj = 1; 1758        if (useProse) { 1759            aspectInterface.suspendNotification(Thread.currentThread()); 1760            aspectInterface.setMethodExitWatch(interfaceMethodLongL, new Object ()); 1761            aspectInterface.resumeNotification(Thread.currentThread()); 1762        } 1763 1764        startChronometer(); 1765        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongL(obj, obj); 1766        stopChronometer(); 1767         1768        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 1769    } 1770     1771    //===================================================== 1772 1773    // 1) INVOKESTATIC - no call to weaver because the joinpoint isn't activated 1774 public void testStaticMethod_LongL() 1775    { 1776        long obj = 1; 1777        startChronometer(); 1778        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongL(obj, obj); 1779        stopChronometer(); 1780    } 1781/* 1782    // 2) INVOKESTATIC - no call to weaver because joinpoint is activated but locked 1783    public void testStaticMethodEntry_jp_activated_locked_LongL() 1784    { 1785        long obj = 1; 1786        if (useProse) { 1787            aspectInterface.suspendNotification(Thread.currentThread()); 1788            aspectInterface.setMethodEntryWatch(staticMethodLongL, new Object()); 1789            aspectInterface.resumeNotification(Thread.currentThread()); 1790            aspectInterface.suspendNotification(Thread.currentThread()); 1791        } 1792 1793        startChronometer(); 1794        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongL(obj, obj); 1795        stopChronometer(); 1796    } 1797 1798    // 2) INVOKESTATIC - no call to weaver because joinpoint is activated but locked 1799    public void testStaticMethodExit_jp_activated_locked_LongL() 1800    { 1801        long obj = 1; 1802        if (useProse) { 1803            aspectInterface.suspendNotification(Thread.currentThread()); 1804            aspectInterface.setMethodExitWatch(staticMethodLongL, new Object()); 1805            aspectInterface.resumeNotification(Thread.currentThread()); 1806            aspectInterface.suspendNotification(Thread.currentThread()); 1807        } 1808 1809        startChronometer(); 1810        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongL(obj, obj); 1811        stopChronometer(); 1812    } 1813*/ 1814    // 3) INVOKESTATIC - call to empty weaver because of on active, unlocked joinpoint 1815 public void testStaticMethodEntry_jp_activated_LongL() 1816    { 1817        long obj = 1; 1818        if (useProse) { 1819            aspectInterface.suspendNotification(Thread.currentThread()); 1820            aspectInterface.setMethodEntryWatch(staticMethodLongL, new Object ()); 1821            aspectInterface.resumeNotification(Thread.currentThread()); 1822        } 1823 1824        startChronometer(); 1825        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongL(obj, obj); 1826        stopChronometer(); 1827         1828        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 1829    } 1830 1831    // 3) INVOKESTATIC - call to empty weaver because of on active, unlocked joinpoint 1832 public void testStaticMethodExit_jp_activated_LongL() 1833    { 1834        long obj = 1; 1835        if (useProse) { 1836            aspectInterface.suspendNotification(Thread.currentThread()); 1837            aspectInterface.setMethodExitWatch(staticMethodLongL, new Object ()); 1838            aspectInterface.resumeNotification(Thread.currentThread()); 1839        } 1840 1841        startChronometer(); 1842        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongL(obj, obj); 1843        stopChronometer(); 1844         1845        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 1846    } 1847     1848    //===================================================== 1849 1850    // 1) INVOKESPECIAL - no call to weaver because the joinpoint isn't activated 1851 public void testSpecialMethod_LongL() 1852    { 1853        long obj = 1; 1854        startChronometer(); 1855        for (int i = 0; i < RUNS; i++) privatelocalMethodLongL(obj, obj); 1856        stopChronometer(); 1857    } 1858/* 1859    // 2) INVOKESPECIAL - no call to weaver because joinpoint is activated but locked 1860    public void testSpecialMethodEntry_jp_activated_locked_LongL() 1861    { 1862        long obj = 1; 1863        if (useProse) { 1864            aspectInterface.suspendNotification(Thread.currentThread()); 1865            aspectInterface.setMethodEntryWatch(privateMethodLongL, new Object()); 1866            aspectInterface.resumeNotification(Thread.currentThread()); 1867            aspectInterface.suspendNotification(Thread.currentThread()); 1868        } 1869 1870        startChronometer(); 1871        for (int i = 0; i < RUNS; i++) privatelocalMethodLongL(obj, obj); 1872        stopChronometer(); 1873    } 1874 1875    // 2) INVOKESPECIAL - no call to weaver because joinpoint is activated but locked 1876    public void testSpecialMethodExit_jp_activated_locked_LongL() 1877    { 1878        long obj = 1; 1879        if (useProse) { 1880            aspectInterface.suspendNotification(Thread.currentThread()); 1881            aspectInterface.setMethodExitWatch(privateMethodLongL, new Object()); 1882            aspectInterface.resumeNotification(Thread.currentThread()); 1883            aspectInterface.suspendNotification(Thread.currentThread()); 1884        } 1885 1886        startChronometer(); 1887        for (int i = 0; i < RUNS; i++) privatelocalMethodLongL(obj, obj); 1888        stopChronometer(); 1889    } 1890*/ 1891    // 3) INVOKESPECIAL - call to empty weaver because of on active, unlocked joinpoint 1892 public void testSpecialMethodEntry_jp_activated_LongL() 1893    { 1894        long obj = 1; 1895        if (useProse) { 1896            aspectInterface.suspendNotification(Thread.currentThread()); 1897            aspectInterface.setMethodEntryWatch(privateMethodLongL, new Object ()); 1898            aspectInterface.resumeNotification(Thread.currentThread()); 1899        } 1900 1901        startChronometer(); 1902        for (int i = 0; i < RUNS; i++) privatelocalMethodLongL(obj, obj); 1903        stopChronometer(); 1904         1905        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 1906    } 1907     1908    // 3) INVOKESPECIAL - call to empty weaver because of on active, unlocked joinpoint 1909 public void testSpecialMethodExit_jp_activated_LongL() 1910    { 1911        long obj = 1; 1912        if (useProse) { 1913            aspectInterface.suspendNotification(Thread.currentThread()); 1914            aspectInterface.setMethodExitWatch(privateMethodLongL, new Object ()); 1915            aspectInterface.resumeNotification(Thread.currentThread()); 1916        } 1917 1918        startChronometer(); 1919        for (int i = 0; i < RUNS; i++) privatelocalMethodLongL(obj, obj); 1920        stopChronometer(); 1921         1922        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 1923    } 1924     1925    //===================================================== 1926 //===================================================== 1927 1928 1929    // Method arguments: (double, double) 1930 //===================================================== 1931 1932    // 1) INVOKEVIRTUAL - no call to weaver because the joinpoint isn't activated 1933 public void testVirtualMethod_LongD() 1934    { 1935        double obj = 10.1; 1936        startChronometer(); 1937        for (int i = 0; i < RUNS; i++) localMethodLongD(obj, obj); 1938        stopChronometer(); 1939    } 1940/* 1941    // 2) INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 1942    public void testVirtualMethodEntry_jp_activated_locked_LongD() 1943    { 1944        double obj = 10.1; 1945        if (useProse) { 1946            aspectInterface.suspendNotification(Thread.currentThread()); 1947            aspectInterface.setMethodEntryWatch(methodLongD, new Object()); 1948            aspectInterface.resumeNotification(Thread.currentThread()); 1949            aspectInterface.suspendNotification(Thread.currentThread()); 1950        } 1951 1952        startChronometer(); 1953        for (int i = 0; i < RUNS; i++) localMethodLongD(obj, obj); 1954        stopChronometer(); 1955    } 1956 1957    // 2) INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 1958    public void testVirtualMethodExit_jp_activated_locked_LongD() 1959    { 1960        double obj = 10.1; 1961        if (useProse) { 1962            aspectInterface.suspendNotification(Thread.currentThread()); 1963            aspectInterface.setMethodExitWatch(methodLongD, new Object()); 1964            aspectInterface.resumeNotification(Thread.currentThread()); 1965            aspectInterface.suspendNotification(Thread.currentThread()); 1966        } 1967 1968        startChronometer(); 1969        for (int i = 0; i < RUNS; i++) localMethodLongD(obj, obj); 1970        stopChronometer(); 1971    } 1972*/ 1973    // 3) INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 1974 public void testVirtualMethodEntry_jp_activated_LongD() 1975    { 1976        double obj = 10.1; 1977        if (useProse) { 1978            aspectInterface.suspendNotification(Thread.currentThread()); 1979            aspectInterface.setMethodEntryWatch(methodLongD, new Object ()); 1980            aspectInterface.resumeNotification(Thread.currentThread()); 1981        } 1982 1983        startChronometer(); 1984        for (int i = 0; i < RUNS; i++) localMethodLongD(obj, obj); 1985        stopChronometer(); 1986         1987        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 1988    } 1989     1990    // 3) INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 1991 public void testVirtualMethodExit_jp_activated_LongD() 1992    { 1993        double obj = 10.1; 1994        if (useProse) { 1995            aspectInterface.suspendNotification(Thread.currentThread()); 1996            aspectInterface.setMethodExitWatch(methodLongD, new Object ()); 1997            aspectInterface.resumeNotification(Thread.currentThread()); 1998        } 1999 2000        startChronometer(); 2001        for (int i = 0; i < RUNS; i++) localMethodLongD(obj, obj); 2002        stopChronometer(); 2003         2004        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 2005    } 2006 2007     2008    //===================================================== 2009 2010    // 1) SYNC INVOKEVIRTUAL - no call to weaver because the joinpoint isn't activated 2011 public void testSyncVirtualMethod_LongD() 2012    { 2013        double obj = 10.1; 2014        startChronometer(); 2015        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongD(obj, obj); 2016        stopChronometer(); 2017    } 2018/* 2019    // 2) SYNC INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 2020    public void testSyncVirtualMethodEntry_jp_activated_locked_LongD() 2021    { 2022        double obj = 10.1; 2023        if (useProse) { 2024            aspectInterface.suspendNotification(Thread.currentThread()); 2025            aspectInterface.setMethodEntryWatch(syncMethodLongD, new Object()); 2026            aspectInterface.resumeNotification(Thread.currentThread()); 2027            aspectInterface.suspendNotification(Thread.currentThread()); 2028        } 2029 2030        startChronometer(); 2031        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongD(obj, obj); 2032        stopChronometer(); 2033    } 2034 2035    // 2) SYNC INVOKEVIRTUAL - no call to weaver because joinpoint is activated but locked 2036    public void testSyncVirtualMethodExit_jp_activated_locked_LongD() 2037    { 2038        double obj = 10.1; 2039        if (useProse) { 2040            aspectInterface.suspendNotification(Thread.currentThread()); 2041            aspectInterface.setMethodExitWatch(syncMethodLongD, new Object()); 2042            aspectInterface.resumeNotification(Thread.currentThread()); 2043            aspectInterface.suspendNotification(Thread.currentThread()); 2044        } 2045 2046        startChronometer(); 2047        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongD(obj, obj); 2048        stopChronometer(); 2049    } 2050*/ 2051    // 3) SYNC INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 2052 public void testSyncVirtualMethodEntry_jp_activated_LongD() 2053    { 2054        double obj = 10.1; 2055        if (useProse) { 2056            aspectInterface.suspendNotification(Thread.currentThread()); 2057            aspectInterface.setMethodEntryWatch(syncMethodLongD, new Object ()); 2058            aspectInterface.resumeNotification(Thread.currentThread()); 2059        } 2060 2061        startChronometer(); 2062        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongD(obj, obj); 2063        stopChronometer(); 2064         2065        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 2066    } 2067     2068    // 3) SYNC INVOKEVIRTUAL - call to empty weaver because of on active, unlocked joinpoint 2069 public void testSyncVirtualMethodExit_jp_activated_LongD() 2070    { 2071        double obj = 10.1; 2072        if (useProse) { 2073            aspectInterface.suspendNotification(Thread.currentThread()); 2074            aspectInterface.setMethodExitWatch(syncMethodLongD, new Object ()); 2075            aspectInterface.resumeNotification(Thread.currentThread()); 2076        } 2077 2078        startChronometer(); 2079        for (int i = 0; i < RUNS; i++) obSync.syncMethodLongD(obj, obj); 2080        stopChronometer(); 2081         2082        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 2083    } 2084     2085    //===================================================== 2086 2087    // 1) INVOKEINTERFACE - no call to weaver because the joinpoint isn't activated 2088 public void testInterfaceMethod_LongD() 2089    { 2090        double obj = 10.1; 2091        startChronometer(); 2092        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongD(obj, obj); 2093        stopChronometer(); 2094    } 2095/* 2096    // 2) INVOKEINTERFACE - no call to weaver because joinpoint is activated but locked 2097    public void testInterfaceMethodEntry_jp_activated_locked_LongD() 2098    { 2099        double obj = 10.1; 2100        if (useProse) { 2101            aspectInterface.suspendNotification(Thread.currentThread()); 2102            aspectInterface.setMethodEntryWatch(interfaceMethodLongD, new Object()); 2103            aspectInterface.resumeNotification(Thread.currentThread()); 2104            aspectInterface.suspendNotification(Thread.currentThread()); 2105        } 2106 2107        startChronometer(); 2108        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongD(obj, obj); 2109        stopChronometer(); 2110    } 2111 2112    // 2) INVOKEINTERFACE - no call to weaver because joinpoint is activated but locked 2113    public void testInterfaceMethodExit_jp_activated_locked_LongD() 2114    { 2115        double obj = 10.1; 2116        if (useProse) { 2117            aspectInterface.suspendNotification(Thread.currentThread()); 2118            aspectInterface.setMethodExitWatch(interfaceMethodLongD, new Object()); 2119            aspectInterface.resumeNotification(Thread.currentThread()); 2120            aspectInterface.suspendNotification(Thread.currentThread()); 2121        } 2122 2123        startChronometer(); 2124        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongD(obj, obj); 2125        stopChronometer(); 2126    } 2127*/ 2128    // 3) INVOKEINTERFACE - call to empty weaver because of on active, unlocked joinpoint 2129 public void testInterfaceMethodEntry_jp_activated_LongD() 2130    { 2131        double obj = 10.1; 2132        if (useProse) { 2133            aspectInterface.suspendNotification(Thread.currentThread()); 2134            aspectInterface.setMethodEntryWatch(interfaceMethodLongD, new Object ()); 2135            aspectInterface.resumeNotification(Thread.currentThread()); 2136        } 2137 2138        startChronometer(); 2139        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongD(obj, obj); 2140        stopChronometer(); 2141         2142        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 2143    } 2144     2145    // 3) INVOKEINTERFACE - call to empty weaver because of on active, unlocked joinpoint 2146 public void testInterfaceMethodExit_jp_activated_LongD() 2147    { 2148        double obj = 10.1; 2149        if (useProse) { 2150            aspectInterface.suspendNotification(Thread.currentThread()); 2151            aspectInterface.setMethodExitWatch(interfaceMethodLongD, new Object ()); 2152            aspectInterface.resumeNotification(Thread.currentThread()); 2153        } 2154 2155        startChronometer(); 2156        for (int i = 0; i < RUNS; i++) obInterface.interfaceMethodLongD(obj, obj); 2157        stopChronometer(); 2158         2159        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 2160    } 2161     2162    //===================================================== 2163 2164    // 1) INVOKESTATIC - no call to weaver because the joinpoint isn't activated 2165 public void testStaticMethod_LongD() 2166    { 2167        double obj = 10.1; 2168        startChronometer(); 2169        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongD(obj, obj); 2170        stopChronometer(); 2171    } 2172/* 2173    // 2) INVOKESTATIC - no call to weaver because joinpoint is activated but locked 2174    public void testStaticMethodEntry_jp_activated_locked_LongD() 2175    { 2176        double obj = 10.1; 2177        if (useProse) { 2178            aspectInterface.suspendNotification(Thread.currentThread()); 2179            aspectInterface.setMethodEntryWatch(staticMethodLongD, new Object()); 2180            aspectInterface.resumeNotification(Thread.currentThread()); 2181            aspectInterface.suspendNotification(Thread.currentThread()); 2182        } 2183 2184        startChronometer(); 2185        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongD(obj, obj); 2186        stopChronometer(); 2187    } 2188 2189    // 2) INVOKESTATIC - no call to weaver because joinpoint is activated but locked 2190    public void testStaticMethodExit_jp_activated_locked_LongD() 2191    { 2192        double obj = 10.1; 2193        if (useProse) { 2194            aspectInterface.suspendNotification(Thread.currentThread()); 2195            aspectInterface.setMethodExitWatch(staticMethodLongD, new Object()); 2196            aspectInterface.resumeNotification(Thread.currentThread()); 2197            aspectInterface.suspendNotification(Thread.currentThread()); 2198        } 2199 2200        startChronometer(); 2201        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongD(obj, obj); 2202        stopChronometer(); 2203    } 2204*/ 2205    // 3) INVOKESTATIC - call to empty weaver because of on active, unlocked joinpoint 2206 public void testStaticMethodEntry_jp_activated_LongD() 2207    { 2208        double obj = 10.1; 2209        if (useProse) { 2210            aspectInterface.suspendNotification(Thread.currentThread()); 2211            aspectInterface.setMethodEntryWatch(staticMethodLongD, new Object ()); 2212            aspectInterface.resumeNotification(Thread.currentThread()); 2213        } 2214 2215        startChronometer(); 2216        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongD(obj, obj); 2217        stopChronometer(); 2218         2219        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 2220    } 2221 2222    // 3) INVOKESTATIC - call to empty weaver because of on active, unlocked joinpoint 2223 public void testStaticMethodExit_jp_activated_LongD() 2224    { 2225        double obj = 10.1; 2226        if (useProse) { 2227            aspectInterface.suspendNotification(Thread.currentThread()); 2228            aspectInterface.setMethodExitWatch(staticMethodLongD, new Object ()); 2229            aspectInterface.resumeNotification(Thread.currentThread()); 2230        } 2231 2232        startChronometer(); 2233        for (int i = 0; i < RUNS; i++) JoinPointTestClass.staticMethodLongD(obj, obj); 2234        stopChronometer(); 2235         2236        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 2237    } 2238     2239    //===================================================== 2240 2241    // 1) INVOKESPECIAL - no call to weaver because the joinpoint isn't activated 2242 public void testSpecialMethod_LongD() 2243    { 2244        double obj = 10.1; 2245        startChronometer(); 2246        for (int i = 0; i < RUNS; i++) privatelocalMethodLongD(obj, obj); 2247        stopChronometer(); 2248    } 2249/* 2250    // 2) INVOKESPECIAL - no call to weaver because joinpoint is activated but locked 2251    public void testSpecialMethodEntry_jp_activated_locked_LongD() 2252    { 2253        double obj = 10.1; 2254        if (useProse) { 2255            aspectInterface.suspendNotification(Thread.currentThread()); 2256            aspectInterface.setMethodEntryWatch(privateMethodLongD, new Object()); 2257            aspectInterface.resumeNotification(Thread.currentThread()); 2258            aspectInterface.suspendNotification(Thread.currentThread()); 2259        } 2260 2261        startChronometer(); 2262        for (int i = 0; i < RUNS; i++) privatelocalMethodLongD(obj, obj); 2263        stopChronometer(); 2264    } 2265 2266    // 2) INVOKESPECIAL - no call to weaver because joinpoint is activated but locked 2267    public void testSpecialMethodExit_jp_activated_locked_LongD() 2268    { 2269        double obj = 10.1; 2270        if (useProse) { 2271            aspectInterface.suspendNotification(Thread.currentThread()); 2272            aspectInterface.setMethodExitWatch(privateMethodLongD, new Object()); 2273            aspectInterface.resumeNotification(Thread.currentThread()); 2274            aspectInterface.suspendNotification(Thread.currentThread()); 2275        } 2276 2277        startChronometer(); 2278        for (int i = 0; i < RUNS; i++) privatelocalMethodLongD(obj, obj); 2279        stopChronometer(); 2280    } 2281*/ 2282    // 3) INVOKESPECIAL - call to empty weaver because of on active, unlocked joinpoint 2283 public void testSpecialMethodEntry_jp_activated_LongD() 2284    { 2285        double obj = 10.1; 2286        if (useProse) { 2287            aspectInterface.suspendNotification(Thread.currentThread()); 2288            aspectInterface.setMethodEntryWatch(privateMethodLongD, new Object ()); 2289            aspectInterface.resumeNotification(Thread.currentThread()); 2290        } 2291 2292        startChronometer(); 2293        for (int i = 0; i < RUNS; i++) privatelocalMethodLongD(obj, obj); 2294        stopChronometer(); 2295         2296        if (checkAssert) assertEquals("Hook notifications", RUNS, methodEntryCount); 2297    } 2298     2299    // 3) INVOKESPECIAL - call to empty weaver because of on active, unlocked joinpoint 2300 public void testSpecialMethodExit_jp_activated_LongD() 2301    { 2302        double obj = 10.1; 2303        if (useProse) { 2304            aspectInterface.suspendNotification(Thread.currentThread()); 2305            aspectInterface.setMethodExitWatch(privateMethodLongD, new Object ()); 2306            aspectInterface.resumeNotification(Thread.currentThread()); 2307        } 2308 2309        startChronometer(); 2310        for (int i = 0; i < RUNS; i++) privatelocalMethodLongD(obj, obj); 2311        stopChronometer(); 2312         2313        if (checkAssert) assertEquals("Hook notifications", RUNS, methodExitCount); 2314    } 2315     2316    //===================================================== 2317 //===================================================== 2318 2319  public static Test suite() { 2320    return new PerformanceTestSuite(JoinPointMeasurements1.class); 2321  } 2322   2323}

A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame Popular Tags