AbstractMethodErrorTest.java

/*
 * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2018 SAP SE. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/**
 * @test
 * @summary Check that the verbose message of the AME is printed correctly.
 * @requires !(os.arch=="arm") & vm.flavor == "server" & !vm.emulatedClient & vm.compMode=="Xmixed" & !vm.graal.enabled & vm.opt.UseJVMCICompiler != true & (vm.opt.TieredStopAtLevel == null | vm.opt.TieredStopAtLevel==4)
 * @library /test/lib /
 * @build sun.hotspot.WhiteBox
 * @run driver ClassFileInstaller sun.hotspot.WhiteBox
 * @compile AbstractMethodErrorTest.java
 * @compile AME1_E.jasm AME2_C.jasm AME3_C.jasm AME4_E.jasm AME5_B.jasm AME6_B.jasm
 * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
 *                   -XX:CompileThreshold=1000 -XX:-BackgroundCompilation -XX:-Inline
 *                   -XX:CompileCommand=exclude,AbstractMethodErrorTest::test_ame1
 *                   AbstractMethodErrorTest
 */

import sun.hotspot.WhiteBox;
import compiler.whitebox.CompilerWhiteBoxTest;
import java.lang.reflect.Method;

// This test assembles an errorneous installation of classes.
// First, compile the test by @compile. This results in a legal set
// of classes.
// Then, with jasm, generate incompatible classes that overwrite
// the class files in the build directory.
// Last, call the real test throwing an AbstractMethodError and
// check the message generated.
public class AbstractMethodErrorTest {

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

    private static boolean enableChecks = true;

    private static boolean compile(Class<?> clazz, String name) {
        try {
            Method method = clazz.getMethod(name);
            boolean enqueued = WHITE_BOX.enqueueMethodForCompilation(method, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION);
            if (!enqueued) {
                System.out.println("Warning: Blocking compilation failed for " + clazz.getName() + "." + name + " (timeout?)");
                return false;
            } else if (!WHITE_BOX.isMethodCompiled(method)) {
                throw new RuntimeException(clazz.getName() + "." + name + " is not compiled");
            }
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(clazz.getName() + "." + name + " not found", e);
        }
        return true;
    }

    public static boolean setup_test() {
        // Assure all exceptions are loaded.
        new AbstractMethodError();
        new IncompatibleClassChangeError();

        enableChecks = false;
        // Warmup
        System.out.println("warmup:");
        test_ame5_compiled_vtable_stub();
        test_ame6_compiled_itable_stub();
        enableChecks = true;

        // Compile
        if (!compile(AbstractMethodErrorTest.class, "test_ame5_compiled_vtable_stub") ||
            !compile(AbstractMethodErrorTest.class, "test_ame6_compiled_itable_stub") ||
            !compile(AME5_C.class, "mc") ||
            !compile(AME5_D.class, "mc") ||
            !compile(AME5_E.class, "mc") ||
            !compile(AME6_C.class, "mc") ||
            !compile(AME6_D.class, "mc") ||
            !compile(AME6_E.class, "mc")) {
            return false;
        }

        System.out.println("warmup done.");
        return true;
    }

    private static String expectedErrorMessageAME1_1 =
        "Missing implementation of resolved method 'abstract " +
        "java.lang.String anAbstractMethod()' of abstract class AME1_B.";
    private static String expectedErrorMessageAME1_2 =
        "Receiver class AME1_E does not define or inherit an implementation of the " +
        "resolved method 'abstract java.lang.String aFunctionOfMyInterface()' of " +
        "interface AME1_C.";

    public static void test_ame1() {
        AME1_B objectAbstract = new AME1_D();
        AME1_C objectInterface = new AME1_D();
        objectInterface.secondFunctionOfMyInterface();
        objectAbstract.anAbstractMethod();
        objectInterface.aFunctionOfMyInterface();

        try {
            objectAbstract = new AME1_E();
            // AbstractMethodError gets thrown in the interpreter at:
            // InterpreterGenerator::generate_abstract_entry
            objectAbstract.anAbstractMethod();
            throw new RuntimeException("Expected AbstractRuntimeError was not thrown.");
        } catch (AbstractMethodError e) {
            String errorMsg = e.getMessage();
            if (errorMsg == null) {
                throw new RuntimeException("Caught AbstractMethodError with empty message.");
            } else if (!errorMsg.equals(expectedErrorMessageAME1_1)) {
                System.out.println("Expected: " + expectedErrorMessageAME1_1 + "\n" +
                                   "but got:  " + errorMsg);
                throw new RuntimeException("Wrong error message of AbstractMethodError.");
            }
        } catch (RuntimeException e) {
            throw e;
        } catch (Throwable e) {
            throw new RuntimeException("Caught unexpected exception: " + e);
        }

        try {
            objectInterface = new AME1_E();
            // AbstractMethodError gets thrown in:
            // TemplateTable::invokeinterface or C-Interpreter loop
            objectInterface.aFunctionOfMyInterface();
            throw new RuntimeException("Expected AbstractRuntimeError was not thrown.");
        } catch (AbstractMethodError e) {
            String errorMsg = e.getMessage();
            if (errorMsg == null) {
                throw new RuntimeException("Caught AbstractMethodError with empty message.");
            } else if (!errorMsg.equals(expectedErrorMessageAME1_2)) {
                // Thrown via InterpreterRuntime::throw_AbstractMethodErrorVerbose().
                System.out.println("Expected: " + expectedErrorMessageAME1_2 + "\n" +
                                   "but got:  " + errorMsg);
                throw new RuntimeException("Wrong error message of AbstractMethodError.");
            } else {
                System.out.println("Passed with message: " + errorMsg);
            }
        } catch (Throwable e) {
            throw new RuntimeException("Caught unexpected exception: " + e);
        }
    }

    private static String expectedErrorMessageAME2_Interpreted =
        "Missing implementation of resolved method 'abstract " +
        "void aFunctionOfMyInterface()' of interface AME2_A.";
    private static String expectedErrorMessageAME2_Compiled =
        "Receiver class AME2_C does not define or inherit an implementation of the resolved method " +
        "'abstract void aFunctionOfMyInterface()' of interface AME2_A.";

    public AbstractMethodErrorTest() throws InstantiationException, IllegalAccessException {
        try {
            AME2_B myAbstract = new ImplementsAllFunctions();
            myAbstract.fun2();
            myAbstract.aFunctionOfMyInterface();

            // AME2_C does not implement the method
            // aFunctionOfMyInterface(). Expected runtime behavior is
            // throwing an AbstractMethodError.
            // The error will be thrown via throw_AbstractMethodErrorWithMethod()
            // if the template interpreter calls an abstract method by
            // entering the abstract method entry.
            myAbstract = new AME2_C();
            myAbstract.fun2();
            myAbstract.aFunctionOfMyInterface();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
    }

    // Loop so that method gets eventually compiled/osred.
    public static void test_ame2() throws Exception {
        boolean seenInterpreted = false;
        boolean seenCompiled = false;

        // Loop to test both, the interpreted and the compiled case.
        for (int i = 0; i < 10000 && !(seenInterpreted && seenCompiled); ++i) {
            try {
                // Supposed to throw AME with verbose message.
                new AbstractMethodErrorTest();

                throw new RuntimeException("Expected AbstractMethodError was not thrown.");
            } catch (AbstractMethodError e) {
                String errorMsg = e.getMessage();

                // Check the message obtained.
                if (errorMsg == null) {
                    throw new RuntimeException("Caught AbstractMethodError with empty message.");
                } else if (errorMsg.equals(expectedErrorMessageAME2_Interpreted)) {
                    seenInterpreted = true;
                } else if (errorMsg.equals(expectedErrorMessageAME2_Compiled)) {
                    // Sparc and the other platforms behave differently here:
                    // Sparc throws the exception via SharedRuntime::handle_wrong_method_abstract(),
                    // x86, ppc and s390 via LinkResolver::runtime_resolve_virtual_method(). Thus,
                    // sparc misses the test case for LinkResolver::runtime_resolve_virtual_method().
                    seenCompiled = true;
                } else {
                    System.out.println("Expected: " + expectedErrorMessageAME2_Interpreted + "\n" +
                                       "or:       " + expectedErrorMessageAME2_Compiled + "\n" +
                                       "but got:  " + errorMsg);
                    throw new RuntimeException("Wrong error message of AbstractMethodError.");
                }
            }
        }
        if (!(seenInterpreted && seenCompiled)) {
            if (seenInterpreted) { System.out.println("Saw interpreted message."); }
            if (seenCompiled)    { System.out.println("Saw compiled message."); }
            throw new RuntimeException("Test did not produce wrong error messages for AbstractMethodError, " +
                                       "but it did not test both cases (interpreted and compiled).");
        }
    }

    private static String expectedErrorMessageAME3_1 =
        "Receiver class AME3_C does not define or inherit an implementation of the resolved method " +
        "'void ma()' of class AME3_A. Selected method is 'abstract void AME3_B.ma()'.";

    // Testing abstract class that extends a class that has an implementation.
    // Loop so that method gets eventually compiled/osred.
    public static void test_ame3_1() throws Exception {
        AME3_A c = new AME3_C();

        try {
            // Supposed to throw AME with verbose message.
            c.ma();

            throw new RuntimeException("Expected AbstractMethodError was not thrown.");
        } catch (AbstractMethodError e) {
            String errorMsg = e.getMessage();

            // Check the message obtained.
            if (errorMsg == null) {
                throw new RuntimeException("Caught AbstractMethodError with empty message.");
            } else if (errorMsg.equals(expectedErrorMessageAME3_1)) {
                // Expected test case thrown via LinkResolver::runtime_resolve_virtual_method().
                System.out.println("Passed with message: " + errorMsg);
            } else {
                System.out.println("Expected: " + expectedErrorMessageAME3_1 + "\n" +
                                   "but got:  " + errorMsg);
                throw new RuntimeException("Wrong error message of AbstractMethodError.");
            }
        }
    }

    private static String expectedErrorMessageAME3_2 =
        "Receiver class AME3_C does not define or inherit an implementation of " +
        "the resolved method 'abstract void ma()' of abstract class AME3_B.";

    // Testing abstract class that extends a class that has an implementation.
    // Loop so that method gets eventually compiled/osred.
    public static void test_ame3_2() throws Exception {
        AME3_C c = new AME3_C();

        try {
            // Supposed to throw AME with verbose message.
            c.ma();

            throw new RuntimeException("Expected AbstractMethodError was not thrown.");
        } catch (AbstractMethodError e) {
            String errorMsg = e.getMessage();

            // Check the message obtained.
            if (errorMsg == null) {
                throw new RuntimeException("Caught AbstractMethodError with empty message.");
            } else if (errorMsg.equals(expectedErrorMessageAME3_2)) {
                // Expected test case thrown via LinkResolver::runtime_resolve_virtual_method().
                System.out.println("Passed with message: " + errorMsg);
            } else {
                System.out.println("Expected: " + expectedErrorMessageAME3_2 + "\n" +
                                   "but got:  " + errorMsg);
                throw new RuntimeException("Wrong error message of AbstractMethodError.");
            }
        }
    }

    private static String expectedErrorMessageAME4 =
        "Missing implementation of resolved method 'abstract void ma()' of " +
        "abstract class AME4_B.";

    // Testing abstract class that extends a class that has an implementation.
    public static void test_ame4() throws Exception {
        AME4_C c = new AME4_C();
        AME4_D d = new AME4_D();
        AME4_E e = new AME4_E();  // Errorneous.

        AME4_A a;
        try {
            // Test: calls errorneous e.ma() in the last iteration.
            final int iterations = 10;
            for (int i = 0; i < iterations; i++) {
                a = e;
                if (i % 2 == 0 && i < iterations - 1) {
                    a = c;
                }
                if (i % 2 == 1 && i < iterations - 1) {
                    a = d;
                }

                // AbstractMethodError gets thrown in the interpreter at:
                // InterpreterGenerator::generate_abstract_entry
                a.ma();
            }

            throw new RuntimeException("Expected AbstractMethodError was not thrown.");
        } catch (AbstractMethodError exc) {
            System.out.println();
            String errorMsg = exc.getMessage();

                // Check the message obtained.
            if (enableChecks && errorMsg == null) {
                throw new RuntimeException("Caught AbstractMethodError with empty message.");
            } else if (errorMsg.equals(expectedErrorMessageAME4)) {
                // Expected test case.
                System.out.println("Passed with message: " + errorMsg);
            } else if (enableChecks) {
                System.out.println("Expected: " + expectedErrorMessageAME4 + "\n" +
                                   "but got:  " + errorMsg);
                throw new RuntimeException("Wrong error message of AbstractMethodError.");
            }
        }
    }

    private static String expectedErrorMessageAME5_VtableStub =
        "Receiver class AME5_B does not define or inherit an implementation of the resolved method 'abstract void mc()' " +
        "of abstract class AME5_A.";

    // AbstractMethodErrors detected in vtable stubs.
    // Note: How can we verify that we really stepped through the vtable stub?
    // - Bimorphic inlining should not happen since we have no profiling data when
    //   we compile the method
    // - As a result, an inline cache call should be generated
    // - This inline cache call is patched into a real vtable call at the first
    //   re-resolve, which happens constantly during the first 10 iterations of the loop.
    // => we should be fine! :-)
    public static void test_ame5_compiled_vtable_stub() {
        // Allocated the objects we need and call a valid method.
        boolean caught_ame = false;
        AME5_B b = new AME5_B();
        AME5_C c = new AME5_C();
        AME5_D d = new AME5_D();
        AME5_E e = new AME5_E();
        b.ma();
        c.ma();
        d.ma();
        e.ma();

        try {
            final int iterations = 10;
            // Test: calls b.c() in the last iteration.
            for (int i = 0; i < iterations; i++) {
                AME5_A a = b;
                if (i % 3 == 0 && i < iterations - 1) {
                    a = c;
                }
                if (i % 3 == 1 && i < iterations - 1) {
                    a = d;
                }
                if (i % 3 == 2 && i < iterations - 1) {
                    a = e;
                }

              a.mc();
            }
            System.out.println();
        } catch (AbstractMethodError exc) {
            caught_ame = true;
            System.out.println();
            String errorMsg = exc.getMessage();
            if (enableChecks && errorMsg == null) {
                System.out.println(exc);
                throw new RuntimeException("Empty error message of AbstractMethodError.");
            }
            if (enableChecks &&
                !errorMsg.equals(expectedErrorMessageAME5_VtableStub)) {
                // Thrown via SharedRuntime::handle_wrong_method_abstract().
                System.out.println("Expected: " + expectedErrorMessageAME5_VtableStub + "\n" +
                                   "but got:  " + errorMsg);
                System.out.println(exc);
                throw new RuntimeException("Wrong error message of AbstractMethodError.");
            }
            if (enableChecks) {
                System.out.println("Passed with message: " + errorMsg);
            }
        } catch (Throwable exc) {

        throw exc;
        }

        // Check that we got the exception at some point.
        if (enableChecks && !caught_ame) {
            throw new RuntimeException("Expected AbstractMethodError was not thrown.");
        }
    }

    private static String expectedErrorMessageAME6_ItableStub =
        "Receiver class AME6_B does not define or inherit an implementation of the resolved" +
        " method 'abstract void mc()' of interface AME6_A.";

    // -------------------------------------------------------------------------
    // AbstractMethodErrors detected in itable stubs.
    // Note: How can we verify that we really stepped through the itable stub?
    // - Bimorphic inlining should not happen since we have no profiling data when
    //   we compile the method
    // - As a result, an inline cache call should be generated
    // - This inline cache call is patched into a real vtable call at the first
    //   re-resolve, which happens constantly during the first 10 iterations of the loop.
    // => we should be fine! :-)
    public static void test_ame6_compiled_itable_stub() {
        // Allocated the objects we need and call a valid method.
        boolean caught_ame = false;
        AME6_B b = new AME6_B();
        AME6_C c = new AME6_C();
        AME6_D d = new AME6_D();
        AME6_E e = new AME6_E();
        b.ma();
        c.ma();
        d.ma();
        e.ma();

        try {
            final int iterations = 10;
            // Test: calls b.c() in the last iteration.
            for (int i = 0; i < iterations; i++) {
                AME6_A a = b;
                if (i % 3 == 0 && i < iterations - 1) {
                    a = c;
                }
                if (i % 3 == 1 && i < iterations - 1) {
                    a = d;
                }
                if (i % 3 == 2 && i < iterations - 1) {
                    a = e;
                }
                a.mc();
            }
            System.out.println();
        } catch (AbstractMethodError exc) {
            caught_ame = true;
            System.out.println();
            String errorMsg = exc.getMessage();
            if (enableChecks && errorMsg == null) {
                System.out.println(exc);
                throw new RuntimeException("Empty error message of AbstractMethodError.");
            }
            if (enableChecks &&
                !errorMsg.equals(expectedErrorMessageAME6_ItableStub)) {
                // Thrown via LinkResolver::runtime_resolve_interface_method().
                System.out.println("Expected: " + expectedErrorMessageAME6_ItableStub + "\n" +
                                   "but got:  " + errorMsg);
                System.out.println(exc);
                throw new RuntimeException("Wrong error message of AbstractMethodError.");
            }
            if (enableChecks) {
                System.out.println("Passed with message: " + errorMsg);
            }
        } catch (Throwable exc) {
            throw exc;
        }

        // Check that we got the exception at some point.
        if (enableChecks && !caught_ame) {
            throw new RuntimeException("Expected AbstractMethodError was not thrown.");
        }
    }


    public static void main(String[] args) throws Exception {
        if (!setup_test()) {
          return;
        }
        test_ame1();
        test_ame2();
        test_ame3_1();
        test_ame3_2();
        test_ame4();
        test_ame5_compiled_vtable_stub();
        test_ame6_compiled_itable_stub();
    }
}

// Helper classes to test abstract method error.
//
// Errorneous versions of these classes are implemented in java
// assembler.


// -------------------------------------------------------------------------
// This error should be detected interpreted.
//
// Class hierachy:
//
//            C     // interface, defines aFunctionOfMyInterface()
//            |
//      A     |     // interface
//      |     |
//      B     |     // abstract class, defines anAbstractMethod()
//       \   /
//         E        // errorneous class implementation lacks methods C::aFunctionOfMyInterface()
//                                                                   B::anAbstractMethod()
interface AME1_A {

    public String firstFunctionOfMyInterface0();

    public String secondFunctionOfMyInterface0();
}

abstract class AME1_B implements AME1_A {

    abstract public String firstAbstractMethod();

    abstract public String secondAbstractMethod();

    abstract public String anAbstractMethod();
}

interface AME1_C {

    public String firstFunctionOfMyInterface();

    public String secondFunctionOfMyInterface();

    public String aFunctionOfMyInterface();
}

class AME1_D extends AME1_B implements AME1_C {

    public AME1_D() {
    }

    public String firstAbstractMethod() {
        return this.getClass().getName();
    }

    public String secondAbstractMethod() {
        return this.getClass().getName();
    }

    public String anAbstractMethod() {
        return this.getClass().getName();
    }

    public String firstFunctionOfMyInterface0() {
        return this.getClass().getName();
    }

    public String secondFunctionOfMyInterface0() {
        return this.getClass().getName();
    }

    public String firstFunctionOfMyInterface() {
        return this.getClass().getName();
    }

    public String secondFunctionOfMyInterface() {
        return this.getClass().getName();
    }

    public String aFunctionOfMyInterface() {
        return this.getClass().getName();
    }
}

class AME1_E extends AME1_B implements AME1_C {

    public AME1_E() {
    }

    public String firstAbstractMethod() {
        return this.getClass().getName();
    }

    public String secondAbstractMethod() {
        return this.getClass().getName();
    }

    // This method is missing in the .jasm implementation.
    public String anAbstractMethod() {
        return this.getClass().getName();
    }

    public String firstFunctionOfMyInterface0() {
        return this.getClass().getName();
    }

    public String secondFunctionOfMyInterface0() {
        return this.getClass().getName();
    }

    public String firstFunctionOfMyInterface() {
        return this.getClass().getName();
    }

    public String secondFunctionOfMyInterface() {
        return this.getClass().getName();
    }

    // This method is missing in the .jasm implementation.
    public String aFunctionOfMyInterface() {
        return this.getClass().getName();
    }
}

// -------------------------------------------------------------------------
// This error should be detected interpreted.
//
// Class hierachy:
//
//      A   // an interface declaring aFunctionOfMyInterface()
//      |
//      B   // an abstract class
//      |
//      C   // errorneous implementation lacks method A::aFunctionOfMyInterface()
//
interface AME2_A {
    public void aFunctionOfMyInterface();
}

abstract class AME2_B implements AME2_A {
    abstract public void fun2();
}

class ImplementsAllFunctions extends AME2_B {

    public ImplementsAllFunctions() {}

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

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

class AME2_C extends AME2_B {

    public AME2_C() {}

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

    // This method is missing in the .jasm implementation.
    public void aFunctionOfMyInterface() {
        //System.out.print("You called public void AME2_C::aFunctionOfMyInterface()\n");
    }
}

// -----------------------------------------------------------------------
// Test AbstractMethod error shadowing existing implementation.
//
// Class hierachy:
//
//           A           // a class implementing m()
//           |
//           B           // an abstract class defining m() abstract
//           |
//           C           // an errorneous class lacking an implementation of m()
//
class AME3_A {
    public void ma() {
        System.out.print("A.ma() ");
    }
}

abstract class AME3_B extends AME3_A {
    public abstract void ma();
}

class AME3_C extends AME3_B {
    // This method is missing in the .jasm implementation.
    public void ma() {
        System.out.print("C.ma() ");
    }
}

// -----------------------------------------------------------------------
// Test AbstractMethod error shadowing existing implementation. In
// this test there are several subclasses of the abstract class.
//
// Class hierachy:
//
//           A           // A: a class implementing ma()
//           |
//           B           // B: an abstract class defining ma() abstract
//        /  | \
//       C   D  E        // E: an errorneous class lacking an implementation of ma()
//
class AME4_A {
    public void ma() {
        System.out.print("A.ma() ");
    }
}

abstract class AME4_B extends AME4_A {
    public abstract void ma();
}

class AME4_C extends AME4_B {
    public void ma() {
        System.out.print("C.ma() ");
    }
}

class AME4_D extends AME4_B {
    public void ma() {
        System.out.print("D.ma() ");
    }
}

class AME4_E extends AME4_B {
    // This method is missing in the .jasm implementation.
    public void ma() {
        System.out.print("E.ma() ");
    }
}

// -------------------------------------------------------------------------
// This error should be detected while processing the vtable stub.
//
// Class hierachy:
//
//              A__     // abstract
//             /|\ \
//            C D E \
//                   B  // Bad class, missing method implementation.
//
// Test:
// - Call D.mc() / E.mc() / F.mc() several times to force real vtable call constrution
// - Call errorneous B.mc() in the end to raise the AbstraceMethodError

abstract class AME5_A {
    public abstract void ma();
    public abstract void mb();
    public abstract void mc();
}

class AME5_B extends AME5_A {
    public void ma() {
        System.out.print("B.ma() ");
    }

    public void mb() {
        System.out.print("B.mb() ");
    }

    // This method is missing in the .jasm implementation.
    public void mc() {
        System.out.print("B.mc() ");
    }
}

class AME5_C extends AME5_A {
    public void ma() {
        System.out.print("C.ma() ");
    }

    public void mb() {
        System.out.print("C.mb() ");
    }

    public void mc() {
        System.out.print("C.mc() ");
    }
}

class AME5_D extends AME5_A {
    public void ma() {
        System.out.print("D.ma() ");
    }

    public void mb() {
        System.out.print("D.mb() ");
    }

    public void mc() {
        System.out.print("D.mc() ");
    }
}

class AME5_E extends AME5_A {
    public  void ma() {
        System.out.print("E.ma() ");
    }

    public void mb() {
        System.out.print("E.mb() ");
    }

    public void mc() {
        System.out.print("E.mc() ");
    }
}

//-------------------------------------------------------------------------
// Test AbstractMethod error detected while processing
// the itable stub.
//
// Class hierachy:
//
//           A__   (interface)
//          /|\ \
//         C D E \
//                B (bad class, missing method)
//
// Test:
// - Call D.mc() / E.mc() / F.mc() several times to force real itable call constrution
// - Call errorneous B.mc() in the end to raise the AbstraceMethodError

interface AME6_A {
    abstract void ma();
    abstract void mb();
    abstract void mc();
}

class AME6_B implements AME6_A {
    public void ma() {
        System.out.print("B.ma() ");
    }

    public void mb() {
        System.out.print("B.mb() ");
    }

    // This method is missing in the .jasm implementation.
    public void mc() {
        System.out.print("B.mc() ");
    }
}

class AME6_C implements AME6_A {
    public void ma() {
        System.out.print("C.ma() ");
    }

    public void mb() {
        System.out.print("C.mb() ");
    }

    public void mc() {
        System.out.print("C.mc() ");
    }
}

class AME6_D implements AME6_A {
    public void ma() {
        System.out.print("D.ma() ");
    }

    public void mb() {
        System.out.print("D.mb() ");
    }

    public void mc() {
        System.out.print("D.mc() ");
    }
}

class AME6_E implements AME6_A {
    public void ma() {
        System.out.print("E.ma() ");
    }

    public void mb() {
        System.out.print("E.mb() ");
    }

    public void mc() {
        System.out.print("E.mc() ");
    }
}