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