test/jdk/java/lang/reflect/DefaultStaticTest/DefaultStaticInvokeTest.java

/*
 * Copyright (c) 2013, 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
 * @summary Test locating and invoking default/static method that defined
 *          in interfaces and/or in inheritance
 * @bug 7184826
 * @build helper.Mod helper.Declared DefaultStaticTestData
 * @run testng DefaultStaticInvokeTest
 * @author Yong Lu
 */

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;

import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.fail;
import org.testng.annotations.Test;

import static helper.Mod.*;
import static helper.Declared.*;
import helper.Mod;


public class DefaultStaticInvokeTest {

    // getMethods(): Make sure getMethods returns the expected methods.
    @Test(dataProvider = "testCasesAll",
            dataProviderClass = DefaultStaticTestData.class)
    public void testGetMethods(String testTarget, Object param)
            throws Exception {
        testMethods(ALL_METHODS, testTarget, param);
    }


    // getDeclaredMethods(): Make sure getDeclaredMethods returns the expected methods.
    @Test(dataProvider = "testCasesAll",
            dataProviderClass = DefaultStaticTestData.class)
    public void testGetDeclaredMethods(String testTarget, Object param)
            throws Exception {
        testMethods(DECLARED_ONLY, testTarget, param);
    }


    // getMethod(): Make sure that getMethod finds all methods it should find.
    @Test(dataProvider = "testCasesAll",
            dataProviderClass = DefaultStaticTestData.class)
    public void testGetMethod(String testTarget, Object param)
            throws Exception {

        Class<?> typeUnderTest = Class.forName(testTarget);

        MethodDesc[] descs = typeUnderTest.getAnnotationsByType(MethodDesc.class);

        for (MethodDesc desc : descs) {
            assertTrue(isFoundByGetMethod(typeUnderTest,
                                          desc.name(),
                                          argTypes(param)));
        }
    }


    // getMethod(): Make sure that getMethod does *not* find certain methods.
    @Test(dataProvider = "testCasesAll",
            dataProviderClass = DefaultStaticTestData.class)
    public void testGetMethodSuperInterfaces(String testTarget, Object param)
            throws Exception {

        // Make sure static methods in superinterfaces are not found (unless the type under
        // test declares a static method with the same signature).

        Class<?> typeUnderTest = Class.forName(testTarget);

        for (Class<?> interfaze : typeUnderTest.getInterfaces()) {

            for (MethodDesc desc : interfaze.getAnnotationsByType(MethodDesc.class)) {

                boolean isStatic = desc.mod() == STATIC;

                boolean declaredInThisType = isMethodDeclared(typeUnderTest,
                                                              desc.name());

                boolean expectedToBeFound = !isStatic || declaredInThisType;

                if (expectedToBeFound)
                    continue; // already tested in testGetMethod()

                assertFalse(isFoundByGetMethod(typeUnderTest,
                                               desc.name(),
                                               argTypes(param)));
            }
        }
    }


    // Method.invoke(): Make sure Method.invoke returns the expected value.
    @Test(dataProvider = "testCasesAll",
            dataProviderClass = DefaultStaticTestData.class)
    public void testMethodInvoke(String testTarget, Object param)
            throws Exception {
        Class<?> typeUnderTest = Class.forName(testTarget);
        MethodDesc[] expectedMethods = typeUnderTest.getAnnotationsByType(MethodDesc.class);

        // test the method retrieved by Class.getMethod(String, Object[])
        for (MethodDesc toTest : expectedMethods) {
            String name = toTest.name();
            Method m = typeUnderTest.getMethod(name, argTypes(param));
            testThisMethod(toTest, m, typeUnderTest, param);
        }
    }


    // MethodHandle.invoke(): Make sure MethodHandle.invoke returns the expected value.
    @Test(dataProvider = "testCasesAll",
            dataProviderClass = DefaultStaticTestData.class)
    public void testMethodHandleInvoke(String testTarget, Object param)
            throws Throwable {
        Class<?> typeUnderTest = Class.forName(testTarget);
        MethodDesc[] expectedMethods = typeUnderTest.getAnnotationsByType(MethodDesc.class);

        for (MethodDesc toTest : expectedMethods) {
            String mName = toTest.name();
            Mod mod = toTest.mod();
            if (mod != STATIC && typeUnderTest.isInterface()) {
                return;
            }

            String result = null;
            String expectedReturn = toTest.retval();

            MethodHandle methodHandle = getTestMH(typeUnderTest, mName, param);
            if (mName.equals("staticMethod")) {
                result = (param == null)
                        ? (String) methodHandle.invoke()
                        : (String) methodHandle.invoke(param);
            } else {
                result = (param == null)
                        ? (String) methodHandle.invoke(typeUnderTest.newInstance())
                        : (String) methodHandle.invoke(typeUnderTest.newInstance(), param);
            }

            assertEquals(result, expectedReturn);
        }

    }

    // Lookup.findStatic / .findVirtual: Make sure IllegalAccessException is thrown as expected.
    @Test(dataProvider = "testClasses",
            dataProviderClass = DefaultStaticTestData.class)
    public void testIAE(String testTarget, Object param)
            throws ClassNotFoundException {

        Class<?> typeUnderTest = Class.forName(testTarget);
        MethodDesc[] expectedMethods = typeUnderTest.getAnnotationsByType(MethodDesc.class);

        for (MethodDesc toTest : expectedMethods) {
            String mName = toTest.name();
            Mod mod = toTest.mod();
            if (mod != STATIC && typeUnderTest.isInterface()) {
                continue;
            }
            Exception caught = null;
            try {
                getTestMH(typeUnderTest, mName, param, true);
            } catch (Exception e) {
                caught = e;
            }
            assertNotNull(caught);
            assertEquals(caught.getClass(), IllegalAccessException.class);
        }
    }


    private static final String[] OBJECT_METHOD_NAMES = {
        "equals",
        "hashCode",
        "getClass",
        "notify",
        "notifyAll",
        "toString",
        "wait",
        "wait",
        "wait",};
    private static final String LAMBDA_METHOD_NAMES = "lambda$";
    private static final HashSet<String> OBJECT_NAMES = new HashSet<>(Arrays.asList(OBJECT_METHOD_NAMES));
    private static final boolean DECLARED_ONLY = true;
    private static final boolean ALL_METHODS = false;

    private void testMethods(boolean declaredOnly, String testTarget, Object param)
            throws Exception {
        Class<?> typeUnderTest = Class.forName(testTarget);
        Method[] methods = declaredOnly
                ? typeUnderTest.getDeclaredMethods()
                : typeUnderTest.getMethods();

        MethodDesc[] baseExpectedMethods = typeUnderTest.getAnnotationsByType(MethodDesc.class);
        MethodDesc[] expectedMethods;

        // If only declared filter out non-declared from expected result
        if (declaredOnly) {
            int nonDeclared = 0;
            for (MethodDesc desc : baseExpectedMethods) {
                if (desc.declared() == NO) {
                    nonDeclared++;
                }
            }
            expectedMethods = new MethodDesc[baseExpectedMethods.length - nonDeclared];
            int i = 0;
            for (MethodDesc desc : baseExpectedMethods) {
                if (desc.declared() == YES) {
                    expectedMethods[i++] = desc;
                }
            }
        } else {
            expectedMethods = baseExpectedMethods;
        }

        HashMap<String, Method> myMethods = new HashMap<>(methods.length);
        for (Method m : methods) {
            String mName = m.getName();
            // don't add Object methods and method created from lambda expression
            if ((!OBJECT_NAMES.contains(mName)) && (!mName.contains(LAMBDA_METHOD_NAMES))) {
                myMethods.put(mName, m);
            }
        }

        assertEquals(myMethods.size(), expectedMethods.length);

        for (MethodDesc toTest : expectedMethods) {

            String name = toTest.name();
            Method candidate = myMethods.remove(name);

            assertNotNull(candidate);

            testThisMethod(toTest, candidate, typeUnderTest, param);

        }

        // Should be no methods left since we remove all we expect to see
        assertTrue(myMethods.isEmpty());
    }


    private void testThisMethod(MethodDesc toTest, Method method,
            Class<?> typeUnderTest, Object param) throws Exception {
        // Test modifiers, and invoke
        Mod mod = toTest.mod();
        String expectedReturn = toTest.retval();
        switch (mod) {
            case STATIC:
                //assert candidate is static
                assertTrue(Modifier.isStatic(method.getModifiers()));
                assertFalse(method.isDefault());

                // Test invoke it
                assertEquals(tryInvoke(method, null, param), expectedReturn);
                break;
            case DEFAULT:
                // if typeUnderTest is a class then instantiate and invoke
                if (!typeUnderTest.isInterface()) {
                    assertEquals(tryInvoke(
                            method,
                            typeUnderTest,
                            param),
                            expectedReturn);
                }

                //assert candidate is default
                assertFalse(Modifier.isStatic(method.getModifiers()));
                assertTrue(method.isDefault());
                break;
            case REGULAR:
                // if typeUnderTest must be a class
                assertEquals(tryInvoke(
                        method,
                        typeUnderTest,
                        param),
                        expectedReturn);

                //assert candidate is neither default nor static
                assertFalse(Modifier.isStatic(method.getModifiers()));
                assertFalse(method.isDefault());
                break;
            case ABSTRACT:
                //assert candidate is neither default nor static
                assertFalse(Modifier.isStatic(method.getModifiers()));
                assertFalse(method.isDefault());
                break;
            default:
                fail(); //this should never happen
                break;
        }

    }


    private boolean isMethodDeclared(Class<?> type, String name) {
        MethodDesc[] methDescs = type.getAnnotationsByType(MethodDesc.class);
        for (MethodDesc desc : methDescs) {
            if (desc.declared() == YES && desc.name().equals(name))
                return true;
        }
        return false;
    }


    private boolean isFoundByGetMethod(Class<?> c, String method, Class<?>... argTypes) {
        try {
            c.getMethod(method, argTypes);
            return true;
        } catch (NoSuchMethodException notFound) {
            return false;
        }
    }


    private Class<?>[] argTypes(Object param) {
        return param == null ? new Class[0] : new Class[] { Object.class };
    }


    private Object tryInvoke(Method m, Class<?> receiverType, Object param)
            throws Exception {
        Object receiver = receiverType == null ? null : receiverType.newInstance();
        Object[] args = param == null ? new Object[0] : new Object[] { param };
        return m.invoke(receiver, args);
    }


    private MethodHandle getTestMH(Class clazz, String methodName, Object param)
            throws Exception {
        return getTestMH(clazz, methodName, param, false);
    }


    private MethodHandle getTestMH(Class clazz, String methodName,
            Object param, boolean isNegativeTest)
            throws Exception {
        MethodType mType = (param != null)
                ? MethodType.genericMethodType(1)
                : MethodType.methodType(String.class);
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        if (!isNegativeTest) {
            return methodName.equals("staticMethod")
                    ? lookup.findStatic(clazz, methodName, mType)
                    : lookup.findVirtual(clazz, methodName, mType);
        } else {
            return methodName.equals("staticMethod")
                    ? lookup.findVirtual(clazz, methodName, mType)
                    : lookup.findStatic(clazz, methodName, mType);
        }
    }
}