Java example source code file (DefaultStaticInvokeTest.java)

This example Java source code file (DefaultStaticInvokeTest.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

all_methods, class, classnotfoundexception, declared_only, exception, methoddesc, methodhandle, mod, nosuchmethodexception, object, reflection, static, string, test, util, yes

The DefaultStaticInvokeTest.java Java example source code

/*
 * 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);
        }
    }
}