/*

 * Copyright (c) 2015, 2016, Oracle and/or its affiliates. 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

 * @bug 8051045 8166974

 * @summary Test exceptions from invokedynamic and the bootstrap method

 * @modules java.base/jdk.internal.org.objectweb.asm

 * @run main BootstrapMethodErrorTest

 */

import jdk.internal.org.objectweb.asm.ClassWriter;

import jdk.internal.org.objectweb.asm.Handle;

import jdk.internal.org.objectweb.asm.MethodVisitor;

import jdk.internal.org.objectweb.asm.Opcodes;

import java.lang.invoke.CallSite;

import java.lang.invoke.ConstantCallSite;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import java.lang.invoke.WrongMethodTypeException;

import java.lang.reflect.InvocationTargetException;

import java.util.List;

public class BootstrapMethodErrorTest {

    static abstract class IndyClassloader extends ClassLoader implements Opcodes {

        public IndyClassloader() {

            super(BootstrapMethodErrorTest.class.getClassLoader());

        }

        @Override

        public Class findClass(String name) throws ClassNotFoundException {

            byte[] b;

            try {

                b = loadClassData(name);

            }

            catch (Throwable th) {

                throw new ClassNotFoundException("Loading error", th);

            }

            return defineClass(name, b, 0, b.length);

        }

        static final String BOOTSTRAP_METHOD_CLASS_NAME = "C";

        static final String BOOTSTRAP_METHOD_NAME = "bsm";

        static final String INDY_CALLER_CLASS_NAME = "Exec";

        static final String BOOTSTRAP_METHOD_DESC = MethodType.methodType(

                Object.class, MethodHandles.Lookup.class, String.class, MethodType.class).

                toMethodDescriptorString();

        private byte[] loadClassData(String name) throws Exception {

            ClassWriter cw = new ClassWriter(

                    ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);

            if (name.equals(BOOTSTRAP_METHOD_CLASS_NAME)) {

                defineIndyBootstrapMethodClass(cw);

                return cw.toByteArray();

            }

            else if (name.equals("Exec")) {

                defineIndyCallingClass(cw);

                return cw.toByteArray();

            }

            return null;

        }

        void defineIndyCallingClass(ClassWriter cw) {

            cw.visit(52, ACC_SUPER | ACC_PUBLIC, INDY_CALLER_CLASS_NAME, null, "java/lang/Object", null);

            MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "invoke", "()V", null, null);

            mv.visitCode();

            Handle h = new Handle(H_INVOKESTATIC,

                                  BOOTSTRAP_METHOD_CLASS_NAME, BOOTSTRAP_METHOD_NAME,

                                  BOOTSTRAP_METHOD_DESC, false);

            mv.visitInvokeDynamicInsn(BOOTSTRAP_METHOD_CLASS_NAME, "()V", h);

            mv.visitInsn(RETURN);

            mv.visitMaxs(0, 0);

            mv.visitEnd();

            cw.visitEnd();

        }

        void defineIndyBootstrapMethodClass(ClassWriter cw) {

            cw.visit(52, ACC_SUPER | ACC_PUBLIC,

                     BOOTSTRAP_METHOD_CLASS_NAME, null, "java/lang/Object", null);

            MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC,

                                              BOOTSTRAP_METHOD_NAME, BOOTSTRAP_METHOD_DESC, null, null);

            mv.visitCode();

            defineIndyBootstrapMethodBody(mv);

            mv.visitMaxs(0, 0);

            mv.visitEnd();

        }

        void defineIndyBootstrapMethodBody(MethodVisitor mv) {

            mv.visitInsn(ACONST_NULL);

            mv.visitInsn(ARETURN);

        }

        void invoke() throws Exception {

            Class.forName(BOOTSTRAP_METHOD_CLASS_NAME, true, this);

            Class<?> exec = Class.forName(INDY_CALLER_CLASS_NAME, true, this);

            exec.getMethod("invoke").invoke(null);

        }

        void test() throws Exception {

            Class.forName(BOOTSTRAP_METHOD_CLASS_NAME, true, this);

            Class<?> exec = Class.forName(INDY_CALLER_CLASS_NAME, true, this);

            try {

                exec.getMethod("invoke").invoke(null);

                throw new RuntimeException("Expected InvocationTargetException but no exception at all was thrown");

            } catch (InvocationTargetException e) {

                Throwable t = e.getCause();

                for (Class<? extends Throwable> etc : expectedThrowableClasses()) {

                    if (!etc.isInstance(t)) {

                        throw new RuntimeException(

                                "Expected " + etc.getName() + " but got another exception: "

                                + t.getClass().getName(),

                                t);

                    }

                    t = t.getCause();

                }

            }

        }

        abstract List<Class<? extends Throwable>> expectedThrowableClasses();

    }

    // Methods called by a bootstrap method

    public static CallSite getCallSite() {

        try {

            MethodHandle mh = MethodHandles.lookup().findStatic(

                    BootstrapMethodErrorTest.class,

                    "target",

                    MethodType.methodType(Object.class, Object.class));

            return new ConstantCallSite(mh);

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

    }

    public static Object target(Object o) {

        return null;

    }

    static class TestThrowable extends Throwable {}

    public static void throwsTestThrowable() throws Throwable {

        throw new TestThrowable();

    }

    static class TestError extends Error {}

    public static void throwsTestError() {

        throw new TestError();

    }

    static class TestRuntimeException extends RuntimeException {}

    public static void throwsTestRuntimeException() {

        throw new TestRuntimeException();

    }

    static class TestCheckedException extends Exception {}

    public static void throwsTestCheckedException() throws TestCheckedException {

        throw new TestCheckedException();

    }

    // Test classes

    static class InaccessibleBootstrapMethod extends IndyClassloader {

        void defineIndyBootstrapMethodClass(ClassWriter cw) {

            cw.visit(52, ACC_SUPER | ACC_PUBLIC,

                     BOOTSTRAP_METHOD_CLASS_NAME, null, "java/lang/Object", null);

            // Bootstrap method is declared to be private

            MethodVisitor mv = cw.visitMethod(ACC_PRIVATE | ACC_STATIC,

                                              BOOTSTRAP_METHOD_NAME, BOOTSTRAP_METHOD_DESC, null, null);

            mv.visitCode();

            defineIndyBootstrapMethodBody(mv);

            mv.visitMaxs(0, 0);

            mv.visitEnd();

        }

        @Override

        List<Class<? extends Throwable>> expectedThrowableClasses() {

            return List.of(IllegalAccessError.class);

        }

    }

    static class BootstrapMethodDoesNotReturnCallSite extends IndyClassloader {

        void defineIndyBootstrapMethodBody(MethodVisitor mv) {

            // return null from the bootstrap method,

            // which cannot be cast to CallSite

            mv.visitInsn(ACONST_NULL);

            mv.visitInsn(ARETURN);

        }

        @Override

        List<Class<? extends Throwable>> expectedThrowableClasses() {

            return List.of(BootstrapMethodError.class, ClassCastException.class);

        }

    }

    static class BootstrapMethodCallSiteHasWrongTarget extends IndyClassloader {

        @Override

        void defineIndyBootstrapMethodBody(MethodVisitor mv) {

            // Invoke the method BootstrapMethodErrorTest.getCallSite to obtain

            // a CallSite instance whose target is different from that of

            // the indy call site

            mv.visitMethodInsn(INVOKESTATIC, "BootstrapMethodErrorTest",

                               "getCallSite", "()Ljava/lang/invoke/CallSite;", false);

            mv.visitInsn(ARETURN);

        }

        @Override

        List<Class<? extends Throwable>> expectedThrowableClasses() {

            return List.of(BootstrapMethodError.class, WrongMethodTypeException.class);

        }

    }

    abstract static class BootstrapMethodThrows extends IndyClassloader {

        final String methodName;

        public BootstrapMethodThrows(Class<? extends Throwable> t) {

            this.methodName = "throws" + t.getSimpleName();

        }

        @Override

        void defineIndyBootstrapMethodBody(MethodVisitor mv) {

            // Invoke the method whose name is methodName which will throw

            // an exception

            mv.visitMethodInsn(INVOKESTATIC, "BootstrapMethodErrorTest",

                               methodName, "()V", false);

            mv.visitInsn(ACONST_NULL);

            mv.visitInsn(ARETURN);

        }

    }

    static class BootstrapMethodThrowsThrowable extends BootstrapMethodThrows {

        public BootstrapMethodThrowsThrowable() {

            super(TestThrowable.class);

        }

        @Override

        List<Class<? extends Throwable>> expectedThrowableClasses() {

            return List.of(BootstrapMethodError.class, TestThrowable.class);

        }

    }

    static class BootstrapMethodThrowsError extends BootstrapMethodThrows {

        public BootstrapMethodThrowsError() {

            super(TestError.class);

        }

        @Override

        List<Class<? extends Throwable>> expectedThrowableClasses() {

            return List.of(TestError.class);

        }

    }

    static class BootstrapMethodThrowsRuntimeException extends BootstrapMethodThrows {

        public BootstrapMethodThrowsRuntimeException() {

            super(TestRuntimeException.class);

        }

        @Override

        List<Class<? extends Throwable>> expectedThrowableClasses() {

            return List.of(BootstrapMethodError.class, TestRuntimeException.class);

        }

    }

    static class BootstrapMethodThrowsCheckedException extends BootstrapMethodThrows {

        public BootstrapMethodThrowsCheckedException() {

            super(TestCheckedException.class);

        }

        @Override

        List<Class<? extends Throwable>> expectedThrowableClasses() {

            return List.of(BootstrapMethodError.class, TestCheckedException.class);

        }

    }

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

        new InaccessibleBootstrapMethod().test();

        new BootstrapMethodDoesNotReturnCallSite().test();

        new BootstrapMethodCallSiteHasWrongTarget().test();

        new BootstrapMethodThrowsThrowable().test();

        new BootstrapMethodThrowsError().test();

        new BootstrapMethodThrowsRuntimeException().test();

        new BootstrapMethodThrowsCheckedException().test();

    }

}