1 /*

     2  * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.

     3  * Copyright (c) 2018 SAP SE. All rights reserved.

     4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     5  *

     6  * This code is free software; you can redistribute it and/or modify it

     7  * under the terms of the GNU General Public License version 2 only, as

     8  * published by the Free Software Foundation.

     9  *

    10  * This code is distributed in the hope that it will be useful, but WITHOUT

    11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    13  * version 2 for more details (a copy is included in the LICENSE file that

    14  * accompanied this code).

    15  *

    16  * You should have received a copy of the GNU General Public License version

    17  * 2 along with this work; if not, write to the Free Software Foundation,

    18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    19  *

    20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    21  * or visit www.oracle.com if you need additional information or have any

    22  * questions.

    23  */

    24 

    25 /**

    26  * @test

    27  * @summary Check that the verbose message of the AME is printed correctly.

    28  * @requires !(os.arch=="arm")

    29  * @library /test/lib /

    30  * @build sun.hotspot.WhiteBox

    31  * @run driver ClassFileInstaller sun.hotspot.WhiteBox sun.hotspot.WhiteBox$WhiteBoxPermission

    32  * @compile AbstractMethodErrorTest.java

    33  * @compile AME1_E.jasm AME2_C.jasm AME3_C.jasm AME4_E.jasm AME5_B.jasm AME6_B.jasm

    34  * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI

    35  *                   -XX:-BackgroundCompilation -XX:-Inline

    36  *                   -XX:CompileCommand=exclude,AbstractMethodErrorTest::test_ame1

    37  *                   AbstractMethodErrorTest

    38  */

    39 

    40 import sun.hotspot.WhiteBox;

    41 import compiler.whitebox.CompilerWhiteBoxTest;

    42 import java.lang.reflect.Method;

    43 

    44 // This test assembles an errorneous installation of classes.

    45 // First, compile the test by @compile. This results in a legal set

    46 // of classes.

    47 // Then, with jasm, generate incompatible classes that overwrite

    48 // the class files in the build directory.

    49 // Last, call the real test throwing an AbstractMethodError and

    50 // check the message generated.

    51 public class AbstractMethodErrorTest {

    52 

    53     private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();

    54 

    55     private static boolean enableChecks = true;

    56 

    57     public static void setup_test() {

    58         // Assure all exceptions are loaded.

    59         new AbstractMethodError();

    60         new IncompatibleClassChangeError();

    61 

    62         enableChecks = false;

    63         // Warmup

    64         System.out.println("warmup:");

    65         test_ame5_compiled_vtable_stub();

    66         test_ame6_compiled_itable_stub();

    67         enableChecks = true;

    68 

    69         // Compile

    70         try {

    71             Method method = AbstractMethodErrorTest.class.getMethod("test_ame5_compiled_vtable_stub");

    72             WHITE_BOX.enqueueMethodForCompilation(method, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION);

    73             if (!WHITE_BOX.isMethodCompiled(method)) {

    74                 throw new RuntimeException(method.getName() + " is not compiled");

    75             }

    76             method = AbstractMethodErrorTest.class.getMethod("test_ame6_compiled_itable_stub");

    77             WHITE_BOX.enqueueMethodForCompilation(method, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION);

    78             if (!WHITE_BOX.isMethodCompiled(method)) {

    79                 throw new RuntimeException(method.getName() + " is not compiled");

    80             }

    81             method = AME5_C.class.getMethod("c");

    82             WHITE_BOX.enqueueMethodForCompilation(method, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION);

    83             if (!WHITE_BOX.isMethodCompiled(method)) {

    84                 throw new RuntimeException("AME5_C." + method.getName() + " is not compiled");

    85             }

    86             method = AME5_D.class.getMethod("c");

    87             WHITE_BOX.enqueueMethodForCompilation(method, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION);

    88             if (!WHITE_BOX.isMethodCompiled(method)) {

    89                 throw new RuntimeException("AME5_D." + method.getName() + " is not compiled");

    90             }

    91             method = AME5_E.class.getMethod("c");

    92             WHITE_BOX.enqueueMethodForCompilation(method, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION);

    93             if (!WHITE_BOX.isMethodCompiled(method)) {

    94                 throw new RuntimeException("AME5_E." + method.getName() + " is not compiled");

    95             }

    96             method = AME6_C.class.getMethod("c");

    97             WHITE_BOX.enqueueMethodForCompilation(method, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION);

    98             if (!WHITE_BOX.isMethodCompiled(method)) {

    99                 throw new RuntimeException("AME6_C." + method.getName() + " is not compiled");

   100             }

   101             method = AME6_D.class.getMethod("c");

   102             WHITE_BOX.enqueueMethodForCompilation(method, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION);

   103             if (!WHITE_BOX.isMethodCompiled(method)) {

   104                 throw new RuntimeException("AME6_D." + method.getName() + " is not compiled");

   105             }

   106             method = AME6_E.class.getMethod("c");

   107             WHITE_BOX.enqueueMethodForCompilation(method, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION);

   108             if (!WHITE_BOX.isMethodCompiled(method)) {

   109                 throw new RuntimeException("AME6_E." + method.getName() + " is not compiled");

   110             }

   111         } catch (NoSuchMethodException e) { }

   112     }

   113 

   114     private static String expectedErrorMessageAME1_1 =

   115         "Missing implementation of resolved method abstract " +

   116         "anAbstractMethod()Ljava/lang/String; of abstract class AME1_B.";

   117     private static String expectedErrorMessageAME1_2 =

   118         "Receiver class AME1_E does not define or inherit an implementation of the " +

   119         "resolved method abstract aFunctionOfMyInterface()Ljava/lang/String; of " +

   120         "interface AME1_C.";

   121 

   122     public static void test_ame1() {

   123         AME1_B objectAbstract = new AME1_D();

   124         AME1_C objectInterface = new AME1_D();

   125         objectInterface.secondFunctionOfMyInterface();

   126         objectAbstract.anAbstractMethod();

   127         objectInterface.aFunctionOfMyInterface();

   128 

   129         try {

   130             objectAbstract = new AME1_E();

   131             // AbstractMethodError gets thrown in the interpreter at:

   132             // InterpreterGenerator::generate_abstract_entry

   133             objectAbstract.anAbstractMethod();

   134             throw new RuntimeException("Expected AbstractRuntimeError was not thrown.");

   135         } catch (AbstractMethodError e) {

   136             String errorMsg = e.getMessage();

   137             if (errorMsg == null) {

   138                 throw new RuntimeException("Caught AbstractMethodError with empty message.");

   139             } else if (!errorMsg.equals(expectedErrorMessageAME1_1)) {

   140                 System.out.println("Expected: " + expectedErrorMessageAME1_1 + "\n" +

   141                                    "but got:  " + errorMsg);

   142                 throw new RuntimeException("Wrong error message of AbstractMethodError.");

   143             }

   144         } catch (RuntimeException e) {

   145             throw e;

   146         } catch (Throwable e) {

   147             throw new RuntimeException("Caught unexpected exception: " + e);

   148         }

   149 

   150         try {

   151             objectInterface = new AME1_E();

   152             // AbstractMethodError gets thrown in:

   153             // TemplateTable::invokeinterface or C-Interpreter loop

   154             objectInterface.aFunctionOfMyInterface();

   155             throw new RuntimeException("Expected AbstractRuntimeError was not thrown.");

   156         } catch (AbstractMethodError e) {

   157             String errorMsg = e.getMessage();

   158             if (errorMsg == null) {

   159                 throw new RuntimeException("Caught AbstractMethodError with empty message.");

   160             } else if (!errorMsg.equals(expectedErrorMessageAME1_2)) {

   161                 // Thrown via InterpreterRuntime::throw_AbstractMethodErrorVerbose().

   162                 System.out.println("Expected: " + expectedErrorMessageAME1_2 + "\n" +

   163                                    "but got:  " + errorMsg);

   164                 throw new RuntimeException("Wrong error message of AbstractMethodError.");

   165             }

   166         } catch (Throwable e) {

   167             throw new RuntimeException("Caught unexpected exception: " + e);

   168         }

   169     }

   170 

   171     private static String expectedErrorMessageAME2_Interpreted =

   172         "Missing implementation of resolved method abstract " +

   173         "aFunctionOfMyInterface()V of interface AME2_A.";

   174     private static String expectedErrorMessageAME2_Compiled =

   175         "Receiver class AME2_C does not define or inherit an implementation of the resolved method " +

   176         "abstract aFunctionOfMyInterface()V of interface AME2_A.";

   177 

   178     public AbstractMethodErrorTest() throws InstantiationException, IllegalAccessException {

   179         try {

   180             AME2_B myAbstract = new ImplementsAllFunctions();

   181             myAbstract.fun2();

   182             myAbstract.aFunctionOfMyInterface();

   183 

   184             // AME2_C does not implement the method

   185             // aFunctionOfMyInterface(). Expected runtime behavior is

   186             // throwing an AbstractMethodError.

   187             // The error will be thrown via throw_AbstractMethodErrorWithMethod()

   188             // if the template interpreter calls an abstract method by

   189             // entering the abstract method entry.

   190             myAbstract = new AME2_C();

   191             myAbstract.fun2();

   192             myAbstract.aFunctionOfMyInterface();

   193         } catch (SecurityException e) {

   194             e.printStackTrace();

   195         }

   196     }

   197 

   198     // Loop so that method gets eventually compiled/osred.

   199     public static void test_ame2() throws Exception {

   200         boolean seenInterpreted = false;

   201         boolean seenCompiled = false;

   202 

   203         // Loop to test both, the interpreted and the compiled case.

   204         for (int i = 0; i < 10000 && !(seenInterpreted && seenCompiled); ++i) {

   205             try {

   206                 // Supposed to throw AME with verbose message.

   207                 new AbstractMethodErrorTest();

   208 

   209                 throw new RuntimeException("Expected AbstractMethodError was not thrown.");

   210             } catch (AbstractMethodError e) {

   211                 String errorMsg = e.getMessage();

   212 

   213                 // Check the message obtained.

   214                 if (errorMsg == null) {

   215                     throw new RuntimeException("Caught AbstractMethodError with empty message.");

   216                 } else if (errorMsg.equals(expectedErrorMessageAME2_Interpreted)) {

   217                     seenInterpreted = true;

   218                 } else if (errorMsg.equals(expectedErrorMessageAME2_Compiled)) {

   219                     // Sparc and the other platforms behave differently here:

   220                     // Sparc throws the exception via SharedRuntime::handle_wrong_method_abstract(),

   221                     // x86, ppc and s390 via LinkResolver::runtime_resolve_virtual_method(). Thus,

   222                     // sparc misses the test case for LinkResolver::runtime_resolve_virtual_method().

   223                     seenCompiled = true;

   224                 } else {

   225                     System.out.println("Expected: " + expectedErrorMessageAME2_Interpreted + "\n" +

   226                                        "or:       " + expectedErrorMessageAME2_Compiled + "\n" +

   227                                        "but got:  " + errorMsg);

   228                     throw new RuntimeException("Wrong error message of AbstractMethodError.");

   229                 }

   230             }

   231         }

   232         if (!(seenInterpreted && seenCompiled)) {

   233             if (seenInterpreted) { System.out.println("Saw interpreted message."); }

   234             if (seenCompiled)    { System.out.println("Saw compiled message."); }

   235             throw new RuntimeException("Test did not produce wrong error messages for AbstractMethodError, " +

   236                                        "but it did not test both cases (interpreted and compiled).");

   237         }

   238     }

   239 

   240     private static String expectedErrorMessageAME3_1 =

   241         "Receiver class AME3_C does not define or inherit an implementation of the resolved method " +

   242         "ma()V of class AME3_A. Selected method is abstract AME3_B.ma()V.";

   243 

   244     // Testing abstract class that extends a class that has an implementation.

   245     // Loop so that method gets eventually compiled/osred.

   246     public static void test_ame3_1() throws Exception {

   247         AME3_A c = new AME3_C();

   248 

   249         try {

   250             // Supposed to throw AME with verbose message.

   251             c.ma();

   252 

   253             throw new RuntimeException("Expected AbstractMethodError was not thrown.");

   254         } catch (AbstractMethodError e) {

   255             String errorMsg = e.getMessage();

   256 

   257             // Check the message obtained.

   258             if (errorMsg == null) {

   259                 throw new RuntimeException("Caught AbstractMethodError with empty message.");

   260             } else if (errorMsg.equals(expectedErrorMessageAME3_1)) {

   261                 // Expected test case thrown via LinkResolver::runtime_resolve_virtual_method().

   262             } else {

   263                 System.out.println("Expected: " + expectedErrorMessageAME3_1 + "\n" +

   264                                    "but got:  " + errorMsg);

   265                 throw new RuntimeException("Wrong error message of AbstractMethodError.");

   266             }

   267         }

   268     }

   269 

   270     private static String expectedErrorMessageAME3_2 =

   271         "Receiver class AME3_C does not define or inherit an implementation of " +

   272         "the resolved method abstract ma()V of abstract class AME3_B.";

   273 

   274     // Testing abstract class that extends a class that has an implementation.

   275     // Loop so that method gets eventually compiled/osred.

   276     public static void test_ame3_2() throws Exception {

   277         AME3_C c = new AME3_C();

   278 

   279         try {

   280             // Supposed to throw AME with verbose message.

   281             c.ma();

   282 

   283             throw new RuntimeException("Expected AbstractMethodError was not thrown.");

   284         } catch (AbstractMethodError e) {

   285             String errorMsg = e.getMessage();

   286 

   287             // Check the message obtained.

   288             if (errorMsg == null) {

   289                 throw new RuntimeException("Caught AbstractMethodError with empty message.");

   290             } else if (errorMsg.equals(expectedErrorMessageAME3_2)) {

   291                 // Expected test case thrown via LinkResolver::runtime_resolve_virtual_method().

   292             } else {

   293                 System.out.println("Expected: " + expectedErrorMessageAME3_2 + "\n" +

   294                                    "but got:  " + errorMsg);

   295                 throw new RuntimeException("Wrong error message of AbstractMethodError.");

   296             }

   297         }

   298     }

   299 

   300     private static String expectedErrorMessageAME4 =

   301         "Missing implementation of resolved method abstract ma()V of " +

   302         "abstract class AME4_B.";

   303 

   304     // Testing abstract class that extends a class that has an implementation.

   305     public static void test_ame4() throws Exception {

   306         AME4_C c = new AME4_C();

   307         AME4_D d = new AME4_D();

   308         AME4_E e = new AME4_E();  // Errorneous.

   309 

   310         AME4_A a;

   311         try {

   312             // Test: calls errorneous e.ma() in the last iteration.

   313             final int iterations = 10;

   314             for (int i = 0; i < iterations; i++) {

   315                 a = e;

   316                 if (i % 2 == 0 && i < iterations - 1) {

   317                     a = c;

   318                 }

   319                 if (i % 2 == 1 && i < iterations - 1) {

   320                     a = d;

   321                 }

   322 

   323                 // AbstractMethodError gets thrown in the interpreter at:

   324                 // InterpreterGenerator::generate_abstract_entry

   325                 a.ma();

   326             }

   327 

   328             throw new RuntimeException("Expected AbstractMethodError was not thrown.");

   329         } catch (AbstractMethodError exc) {

   330             System.out.println();

   331             String errorMsg = exc.getMessage();

   332 

   333                 // Check the message obtained.

   334             if (enableChecks && errorMsg == null) {

   335                 throw new RuntimeException("Caught AbstractMethodError with empty message.");

   336             } else if (errorMsg.equals(expectedErrorMessageAME4)) {

   337                 // Expected test case.

   338             } else if (enableChecks) {

   339                 System.out.println("Expected: " + expectedErrorMessageAME4 + "\n" +

   340                                    "but got:  " + errorMsg);

   341                 throw new RuntimeException("Wrong error message of AbstractMethodError.");

   342             }

   343         }

   344     }

   345 

   346     private static String expectedErrorMessageAME5_VtableStub =

   347         "Receiver class AME5_B does not define or inherit an implementation of the resolved method abstract mc()V " +

   348         "of abstract class AME5_A.";

   349 

   350     // AbstractMethodErrors detected in vtable stubs.

   351     // Note: How can we verify that we really stepped through the vtable stub?

   352     // - Bimorphic inlining should not happen since we have no profiling data when

   353     //   we compile the method

   354     // - As a result, an inline cache call should be generated

   355     // - This inline cache call is patched into a real vtable call at the first

   356     //   re-resolve, which happens constantly during the first 10 iterations of the loop.

   357     // => we should be fine! :-)

   358     public static void test_ame5_compiled_vtable_stub() {

   359         // Allocated the objects we need and call a valid method.

   360         boolean caught_ame = false;

   361         AME5_B b = new AME5_B();

   362         AME5_C c = new AME5_C();

   363         AME5_D d = new AME5_D();

   364         AME5_E e = new AME5_E();

   365         b.ma();

   366         c.ma();

   367         d.ma();

   368         e.ma();

   369 

   370         try {

   371             final int iterations = 10;

   372             // Test: calls b.c() in the last iteration.

   373             for (int i = 0; i < iterations; i++) {

   374                 AME5_A a = b;

   375                 if (i % 3 == 0 && i < iterations - 1) {

   376                     a = c;

   377                 }

   378                 if (i % 3 == 1 && i < iterations - 1) {

   379                     a = d;

   380                 }

   381                 if (i % 3 == 2 && i < iterations - 1) {

   382                     a = e;

   383                 }

   384 

   385               a.mc();

   386             }

   387             System.out.println();

   388         } catch (AbstractMethodError exc) {

   389             caught_ame = true;

   390             System.out.println();

   391             String errorMsg = exc.getMessage();

   392             if (enableChecks && errorMsg == null) {

   393                 System.out.println(exc);

   394                 throw new RuntimeException("Empty error message of AbstractMethodError.");

   395             }

   396             if (enableChecks &&

   397                 !errorMsg.equals(expectedErrorMessageAME5_VtableStub)) {

   398                 // Thrown via SharedRuntime::handle_wrong_method_abstract().

   399                 System.out.println("Expected: " + expectedErrorMessageAME5_VtableStub + "\n" +

   400                                    "but got:  " + errorMsg);

   401                 System.out.println(exc);

   402                 throw new RuntimeException("Wrong error message of AbstractMethodError.");

   403             }

   404             if (enableChecks) {

   405                 System.out.println("Passed with message: " + errorMsg);

   406             }

   407         } catch (Throwable exc) {

   408 

   409         throw exc;

   410         }

   411 

   412         // Check that we got the exception at some point.

   413         if (enableChecks && !caught_ame) {

   414             throw new RuntimeException("Expected AbstractMethodError was not thrown.");

   415         }

   416     }

   417 

   418     private static String expectedErrorMessageAME6_ItableStub =

   419         "Receiver class AME6_B does not define or inherit an implementation of the resolved" +

   420         " method abstract mc()V of interface AME6_A.";

   421 

   422     // -------------------------------------------------------------------------

   423     // AbstractMethodErrors detected in itable stubs.

   424     // Note: How can we verify that we really stepped through the itable stub?

   425     // - Bimorphic inlining should not happen since we have no profiling data when

   426     //   we compile the method

   427     // - As a result, an inline cache call should be generated

   428     // - This inline cache call is patched into a real vtable call at the first

   429     //   re-resolve, which happens constantly during the first 10 iterations of the loop.

   430     // => we should be fine! :-)

   431     public static void test_ame6_compiled_itable_stub() {

   432         // Allocated the objects we need and call a valid method.

   433         boolean caught_ame = false;

   434         AME6_B b = new AME6_B();

   435         AME6_C c = new AME6_C();

   436         AME6_D d = new AME6_D();

   437         AME6_E e = new AME6_E();

   438         b.ma();

   439         c.ma();

   440         d.ma();

   441         e.ma();

   442 

   443         try {

   444             final int iterations = 10;

   445             // Test: calls b.c() in the last iteration.

   446             for (int i = 0; i < iterations; i++) {

   447                 AME6_A a = b;

   448                 if (i % 3 == 0 && i < iterations - 1) {

   449                     a = c;

   450                 }

   451                 if (i % 3 == 1 && i < iterations - 1) {

   452                     a = d;

   453                 }

   454                 if (i % 3 == 2 && i < iterations - 1) {

   455                     a = e;

   456                 }

   457                 a.mc();

   458             }

   459             System.out.println();

   460         } catch (AbstractMethodError exc) {

   461             caught_ame = true;

   462             System.out.println();

   463             String errorMsg = exc.getMessage();

   464             if (enableChecks && errorMsg == null) {

   465                 System.out.println(exc);

   466                 throw new RuntimeException("Empty error message of AbstractMethodError.");

   467             }

   468             if (enableChecks &&

   469                 !errorMsg.equals(expectedErrorMessageAME6_ItableStub)) {

   470                 // Thrown via LinkResolver::runtime_resolve_interface_method().

   471                 System.out.println("Expected: " + expectedErrorMessageAME6_ItableStub + "\n" +

   472                                    "but got:  " + errorMsg);

   473                 System.out.println(exc);

   474                 throw new RuntimeException("Wrong error message of AbstractMethodError.");

   475             }

   476             if (enableChecks) {

   477                 System.out.println("Passed with message: " + errorMsg);

   478             }

   479         } catch (Throwable exc) {

   480             throw exc;

   481         }

   482 

   483         // Check that we got the exception at some point.

   484         if (enableChecks && !caught_ame) {

   485             throw new RuntimeException("Expected AbstractMethodError was not thrown.");

   486         }

   487     }

   488 

   489 

   490     public static void main(String[] args) throws Exception {

   491         setup_test();

   492         test_ame1();

   493         test_ame2();

   494         test_ame3_1();

   495         test_ame3_2();

   496         test_ame4();

   497         test_ame5_compiled_vtable_stub();

   498         test_ame6_compiled_itable_stub();

   499     }

   500 }

   501 

   502 // Helper classes to test abstract method error.

   503 //

   504 // Errorneous versions of these classes are implemented in java

   505 // assembler.

   506 

   507 

   508 // -------------------------------------------------------------------------

   509 // This error should be detected interpreted.

   510 //

   511 // Class hierachy:

   512 //

   513 //            C     // interface, defines aFunctionOfMyInterface()

   514 //            |

   515 //      A     |     // interface

   516 //      |     |

   517 //      B     |     // abstract class, defines anAbstractMethod()

   518 //       \   /

   519 //         E        // errorneous class implementation lacks methods C::aFunctionOfMyInterface()

   520 //                                                                   B::anAbstractMethod()

   521 interface AME1_A {

   522 

   523     public String firstFunctionOfMyInterface0();

   524 

   525     public String secondFunctionOfMyInterface0();

   526 }

   527 

   528 abstract class AME1_B implements AME1_A {

   529 

   530     abstract public String firstAbstractMethod();

   531 

   532     abstract public String secondAbstractMethod();

   533 

   534     abstract public String anAbstractMethod();

   535 }

   536 

   537 interface AME1_C {

   538 

   539     public String firstFunctionOfMyInterface();

   540 

   541     public String secondFunctionOfMyInterface();

   542 

   543     public String aFunctionOfMyInterface();

   544 }

   545 

   546 class AME1_D extends AME1_B implements AME1_C {

   547 

   548     public AME1_D() {

   549     }

   550 

   551     public String firstAbstractMethod() {

   552         return this.getClass().getName();

   553     }

   554 

   555     public String secondAbstractMethod() {

   556         return this.getClass().getName();

   557     }

   558 

   559     public String anAbstractMethod() {

   560         return this.getClass().getName();

   561     }

   562 

   563     public String firstFunctionOfMyInterface0() {

   564         return this.getClass().getName();

   565     }

   566 

   567     public String secondFunctionOfMyInterface0() {

   568         return this.getClass().getName();

   569     }

   570 

   571     public String firstFunctionOfMyInterface() {

   572         return this.getClass().getName();

   573     }

   574 

   575     public String secondFunctionOfMyInterface() {

   576         return this.getClass().getName();

   577     }

   578 

   579     public String aFunctionOfMyInterface() {

   580         return this.getClass().getName();

   581     }

   582 }

   583 

   584 class AME1_E extends AME1_B implements AME1_C {

   585 

   586     public AME1_E() {

   587     }

   588 

   589     public String firstAbstractMethod() {

   590         return this.getClass().getName();

   591     }

   592 

   593     public String secondAbstractMethod() {

   594         return this.getClass().getName();

   595     }

   596 

   597     // This method is missing in the .jasm implementation.

   598     public String anAbstractMethod() {

   599         return this.getClass().getName();

   600     }

   601 

   602     public String firstFunctionOfMyInterface0() {

   603         return this.getClass().getName();

   604     }

   605 

   606     public String secondFunctionOfMyInterface0() {

   607         return this.getClass().getName();

   608     }

   609 

   610     public String firstFunctionOfMyInterface() {

   611         return this.getClass().getName();

   612     }

   613 

   614     public String secondFunctionOfMyInterface() {

   615         return this.getClass().getName();

   616     }

   617 

   618     // This method is missing in the .jasm implementation.

   619     public String aFunctionOfMyInterface() {

   620         return this.getClass().getName();

   621     }

   622 }

   623 

   624 // -------------------------------------------------------------------------

   625 // This error should be detected interpreted.

   626 //

   627 // Class hierachy:

   628 //

   629 //      A   // an interface declaring aFunctionOfMyInterface()

   630 //      |

   631 //      B   // an abstract class

   632 //      |

   633 //      C   // errorneous implementation lacks method A::aFunctionOfMyInterface()

   634 //

   635 interface AME2_A {

   636     public void aFunctionOfMyInterface();

   637 }

   638 

   639 abstract class AME2_B implements AME2_A {

   640     abstract public void fun2();

   641 }

   642 

   643 class ImplementsAllFunctions extends AME2_B {

   644 

   645     public ImplementsAllFunctions() {}

   646 

   647     public void fun2() {

   648         //System.out.print("You called public void ImplementsAllFunctions::fun2().\n");

   649     }

   650 

   651     public void aFunctionOfMyInterface() {

   652         //System.out.print("You called public void ImplementsAllFunctions::aFunctionOfMyInterface()\n");

   653     }

   654 }

   655 

   656 class AME2_C extends AME2_B {

   657 

   658     public AME2_C() {}

   659 

   660     public void fun2() {

   661         //System.out.print("You called public void AME2_C::fun2().\n");

   662     }

   663 

   664     // This method is missing in the .jasm implementation.

   665     public void aFunctionOfMyInterface() {

   666         //System.out.print("You called public void AME2_C::aFunctionOfMyInterface()\n");

   667     }

   668 }

   669 

   670 // -----------------------------------------------------------------------

   671 // Test AbstractMethod error shadowing existing implementation.

   672 //

   673 // Class hierachy:

   674 //

   675 //           A           // a class implementing m()

   676 //           |

   677 //           B           // an abstract class defining m() abstract

   678 //           |

   679 //           C           // an errorneous class lacking an implementation of m()

   680 //

   681 class AME3_A {

   682     public void ma() {

   683         System.out.print("A.ma() ");

   684     }

   685 }

   686 

   687 abstract class AME3_B extends AME3_A {

   688     public abstract void ma();

   689 }

   690 

   691 class AME3_C extends AME3_B {

   692     // This method is missing in the .jasm implementation.

   693     public void ma() {

   694         System.out.print("C.ma() ");

   695     }

   696 }

   697 

   698 // -----------------------------------------------------------------------

   699 // Test AbstractMethod error shadowing existing implementation. In

   700 // this test there are several subclasses of the abstract class.

   701 //

   702 // Class hierachy:

   703 //

   704 //           A           // A: a class implementing ma()

   705 //           |

   706 //           B           // B: an abstract class defining ma() abstract

   707 //        /  | \

   708 //       C   D  E        // E: an errorneous class lacking an implementation of ma()

   709 //

   710 class AME4_A {

   711     public void ma() {

   712         System.out.print("A.ma() ");

   713     }

   714 }

   715 

   716 abstract class AME4_B extends AME4_A {

   717     public abstract void ma();

   718 }

   719 

   720 class AME4_C extends AME4_B {

   721     public void ma() {

   722         System.out.print("C.ma() ");

   723     }

   724 }

   725 

   726 class AME4_D extends AME4_B {

   727     public void ma() {

   728         System.out.print("D.ma() ");

   729     }

   730 }

   731 

   732 class AME4_E extends AME4_B {

   733     // This method is missing in the .jasm implementation.

   734     public void ma() {

   735         System.out.print("E.ma() ");

   736     }

   737 }

   738 

   739 // -------------------------------------------------------------------------

   740 // This error should be detected while processing the vtable stub.

   741 //

   742 // Class hierachy:

   743 //

   744 //              A__     // abstract

   745 //             /|\ \

   746 //            C D E \

   747 //                   B  // Bad class, missing method implementation.

   748 //

   749 // Test:

   750 // - Call D.mc() / E.mc() / F.mc() several times to force real vtable call constrution

   751 // - Call errorneous B.mc() in the end to raise the AbstraceMethodError

   752 

   753 abstract class AME5_A {

   754     abstract void ma();

   755     abstract void mb();

   756     abstract void mc();

   757 }

   758 

   759 class AME5_B extends AME5_A {

   760     void ma() {

   761         System.out.print("B.ma() ");

   762     }

   763 

   764     void mb() {

   765         System.out.print("B.mb() ");

   766     }

   767 

   768     // This method is missing in the .jasm implementation.

   769     void mc() {

   770         System.out.print("B.mc() ");

   771     }

   772 }

   773 

   774 class AME5_C extends AME5_A {

   775     void ma() {

   776         System.out.print("C.ma() ");

   777     }

   778 

   779     void mb() {

   780         System.out.print("C.mb() ");

   781     }

   782 

   783     void mc() {

   784         System.out.print("C.mc() ");

   785     }

   786 }

   787 

   788 class AME5_D extends AME5_A {

   789     void ma() {

   790         System.out.print("D.ma() ");

   791     }

   792 

   793     void mb() {

   794         System.out.print("D.mb() ");

   795     }

   796 

   797     void mc() {

   798         System.out.print("D.mc() ");

   799     }

   800 }

   801 

   802 class AME5_E extends AME5_A {

   803     void ma() {

   804        System.out.print("E.ma() ");

   805    }

   806 

   807    void mb() {

   808        System.out.print("E.mb() ");

   809    }

   810 

   811    void mc() {

   812        System.out.print("E.mc() ");

   813    }

   814 }

   815 

   816 //-------------------------------------------------------------------------

   817 // Test AbstractMethod error detected while processing

   818 // the itable stub.

   819 //

   820 // Class hierachy:

   821 //

   822 //           A__   (interface)

   823 //          /|\ \

   824 //         C D E \

   825 //                B (bad class, missing method)

   826 //

   827 // Test:

   828 // - Call D.mc() / E.mc() / F.mc() several times to force real itable call constrution

   829 // - Call errorneous B.mc() in the end to raise the AbstraceMethodError

   830 

   831 interface AME6_A {

   832     abstract void ma();

   833     abstract void mb();

   834     abstract void mc();

   835 }

   836 

   837 class AME6_B implements AME6_A {

   838     public void ma() {

   839         System.out.print("B.ma() ");

   840     }

   841 

   842     public void mb() {

   843         System.out.print("B.mb() ");

   844     }

   845 

   846     // This method is missing in the .jasm implementation.

   847     public void mc() {

   848         System.out.print("B.mc() ");

   849     }

   850 }

   851 

   852 class AME6_C implements AME6_A {

   853     public void ma() {

   854         System.out.print("C.ma() ");

   855     }

   856 

   857     public void mb() {

   858         System.out.print("C.mb() ");

   859     }

   860 

   861     public void mc() {

   862         System.out.print("C.mc() ");

   863     }

   864 }

   865 

   866 class AME6_D implements AME6_A {

   867     public void ma() {

   868         System.out.print("D.ma() ");

   869     }

   870 

   871     public void mb() {

   872         System.out.print("D.mb() ");

   873     }

   874 

   875     public void mc() {

   876         System.out.print("D.mc() ");

   877     }

   878 }

   879 

   880 class AME6_E implements AME6_A {

   881     public void ma() {

   882         System.out.print("E.ma() ");

   883     }

   884 

   885     public void mb() {

   886         System.out.print("E.mb() ");

   887     }

   888 

   889     public void mc() {

   890         System.out.print("E.mc() ");

   891     }

   892 }