--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/lang/reflect/DefaultStaticTest/DefaultStaticInvokeTest.java Tue Aug 06 18:54:02 2013 +0200
@@ -0,0 +1,307 @@
+/*
+ * 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 org.testng.annotations.Test;
+
+import static helper.Mod.*;
+import static helper.Declared.*;
+import helper.Mod;
+
+public class DefaultStaticInvokeTest {
+
+ @Test(dataProvider = "testCasesAll",
+ dataProviderClass = DefaultStaticTestData.class)
+ public void testGetMethods(String testTarget, Object param)
+ throws Exception {
+ // test the methods retrieved by getMethods()
+ testMethods(ALL_METHODS, testTarget, param);
+ }
+
+ @Test(dataProvider = "testCasesAll",
+ dataProviderClass = DefaultStaticTestData.class)
+ public void testGetDeclaredMethods(String testTarget, Object param)
+ throws Exception {
+ // test the methods retrieved by getDeclaredMethods()
+ testMethods(DECLARED_ONLY, testTarget, param);
+ }
+
+ @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 = getTestMethod(typeUnderTest, name, param);
+ testThisMethod(toTest, m, typeUnderTest, param);
+ }
+ }
+
+ @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);
+ }
+
+ }
+
+ @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()) {
+ return;
+ }
+ Exception caught = null;
+ try {
+ getTestMH(typeUnderTest, mName, param, true);
+ } catch (Exception e) {
+ caught = e;
+ }
+ assertTrue(caught != null);
+ 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(expectedMethods.length, myMethods.size());
+
+ for (MethodDesc toTest : expectedMethods) {
+
+ String name = toTest.name();
+ Method candidate = myMethods.get(name);
+
+ assertNotNull(candidate);
+ myMethods.remove(name);
+
+ 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:
+ assertFalse(true); //this should never happen
+ break;
+ }
+
+ }
+
+ private Object tryInvoke(Method m, Class<?> receiverType, Object param)
+ throws Exception {
+ Object receiver = receiverType == null ? null : receiverType.newInstance();
+ Object result = null;
+ if (param == null) {
+ result = m.invoke(receiver);
+ } else {
+ result = m.invoke(receiver, param);
+ }
+ return result;
+ }
+
+ private Method getTestMethod(Class clazz, String methodName, Object param)
+ throws NoSuchMethodException {
+ Class[] paramsType = (param != null)
+ ? new Class[]{Object.class}
+ : new Class[]{};
+ return clazz.getMethod(methodName, paramsType);
+ }
+
+ 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);
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/lang/reflect/DefaultStaticTest/DefaultStaticTestData.java Tue Aug 06 18:54:02 2013 +0200
@@ -0,0 +1,401 @@
+/*
+ * 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 Data used for testing default/static method
+ *
+ * @author Yong Lu
+ */
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.testng.annotations.DataProvider;
+import org.testng.collections.Lists;
+
+import static helper.Mod.*;
+import static helper.Declared.*;
+import helper.Mod;
+import helper.Declared;
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF1.defaultMethod", mod = DEFAULT, declared = YES)
+interface TestIF1 {
+
+ default String defaultMethod() {
+ return "TestIF1.defaultMethod";
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF1.defaultMethod", mod = DEFAULT, declared = NO)
+class TestClass1 implements TestIF1 {
+}
+
+@MethodDesc(name = "staticMethod", retval = "TestIF2.staticMethod", mod = STATIC, declared = YES)
+interface TestIF2 {
+
+ static String staticMethod() {
+ return "TestIF2.staticMethod";
+ }
+}
+
+@MethodDesc(name = "method", retval = "TestIF2.staticMethod", mod = REGULAR, declared = YES)
+class TestClass2 implements TestIF2 {
+
+ public String method() {
+ return TestIF2.staticMethod();
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF3.defaultMethod", mod = DEFAULT, declared = YES)
+@MethodDesc(name = "method", retval = "", mod = ABSTRACT, declared = YES)
+interface TestIF3 {
+
+ String method();
+
+ default String defaultMethod() {
+ return "TestIF3.defaultMethod";
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF3.defaultMethod", mod = DEFAULT, declared = NO)
+@MethodDesc(name = "method", retval = "TestClass3.method", mod = REGULAR, declared = YES)
+class TestClass3 implements TestIF3 {
+
+ public String method() {
+ return "TestClass3.method";
+ }
+}
+
+@MethodDesc(name = "staticMethod", retval = "TestIF4.staticMethod", mod = STATIC, declared = YES)
+@MethodDesc(name = "method", retval = "", mod = ABSTRACT, declared = YES)
+interface TestIF4 {
+
+ String method();
+
+ static String staticMethod() {
+ return "TestIF4.staticMethod";
+ }
+}
+
+@MethodDesc(name = "method", retval = "TestClass4.method", mod = REGULAR, declared = YES)
+class TestClass4 implements TestIF4 {
+
+ public String method() {
+ return "TestClass4.method";
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF5.defaultMethod", mod = DEFAULT, declared = YES)
+@MethodDesc(name = "staticMethod", retval = "TestIF5.staticMethod", mod = STATIC, declared = YES)
+interface TestIF5 {
+
+ default String defaultMethod() {
+ return "TestIF5.defaultMethod";
+ }
+
+ static String staticMethod() {
+ return "TestIF5.staticMethod";
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF5.defaultMethod", mod = DEFAULT, declared = NO)
+class TestClass5 implements TestIF5 {
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF6.defaultMethod", mod = DEFAULT, declared = YES)
+@MethodDesc(name = "staticMethod", retval = "TestIF6.staticMethod", mod = STATIC, declared = YES)
+@MethodDesc(name = "method", retval = "", mod = ABSTRACT, declared = YES)
+interface TestIF6 {
+
+ String method();
+
+ default String defaultMethod() {
+ return "TestIF6.defaultMethod";
+ }
+
+ static String staticMethod() {
+ return "TestIF6.staticMethod";
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF6.defaultMethod", mod = DEFAULT, declared = NO)
+@MethodDesc(name = "method", retval = "TestClass6.method", mod = REGULAR, declared = YES)
+class TestClass6 implements TestIF6 {
+
+ public String method() {
+ return "TestClass6.method";
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF7.TestClass7", mod = DEFAULT, declared = YES)
+interface TestIF7<T> {
+
+ default T defaultMethod(T t) {
+ return t;
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF7.TestClass7", mod = DEFAULT, declared = NO)
+class TestClass7<T> implements TestIF7<T> {
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF8.TestClass8", mod = DEFAULT, declared = YES)
+interface TestIF8<E> {
+
+ default <E> E defaultMethod(E e) {
+ return e;
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF8.TestClass8", mod = DEFAULT, declared = NO)
+class TestClass8<T> implements TestIF8<T> {
+};
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF9.defaultMethod", mod = DEFAULT, declared = YES)
+interface TestIF9 extends TestIF1 {
+
+ default String defaultMethod() {
+ return "TestIF9.defaultMethod";
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF9.defaultMethod", mod = DEFAULT, declared = NO)
+class TestClass9 implements TestIF9 {
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF9.defaultMethod", mod = DEFAULT, declared = NO)
+@MethodDesc(name = "method", retval = "TestIF9.defaultMethod", mod = REGULAR, declared = YES)
+class TestClass91 implements TestIF9, TestIF1 {
+
+ public String method() {
+ return defaultMethod();
+ }
+}
+
+@MethodDesc(name = "staticMethod", retval = "TestIF10.staticMethod", mod = STATIC, declared = YES)
+interface TestIF10 extends TestIF2 {
+
+ static String staticMethod() {
+
+ return "TestIF10.staticMethod";
+ }
+}
+
+@MethodDesc(name = "staticMethod", retval = "TestIF11.staticMethod", mod = STATIC, declared = YES)
+@MethodDesc(name = "defaultMethod", retval = "TestIF1.defaultMethod", mod = DEFAULT, declared = NO)
+interface TestIF11 extends TestIF1 {
+
+ static String staticMethod() {
+ return "TestIF11.staticMethod";
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF1.defaultMethod", mod = DEFAULT, declared = NO)
+class TestClass11 implements TestIF11 {
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF12.defaultMethod", mod = DEFAULT, declared = YES)
+@MethodDesc(name = "staticMethod", retval = "TestIF2.staticMethod", mod = STATIC, declared = NO)
+interface TestIF12 extends TestIF2 {
+
+ default String defaultMethod() {
+ return "TestIF12.defaultMethod";
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF12.defaultMethod", mod = DEFAULT, declared = NO)
+class TestClass12 implements TestIF12 {
+}
+
+//Diamond Case
+@MethodDesc(name = "defaultMethod", retval = "TestIF1.defaultMethod", mod = DEFAULT, declared = NO)
+interface TestIF1A extends TestIF1 {
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF1.defaultMethod", mod = DEFAULT, declared = NO)
+interface TestIF1B extends TestIF1 {
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF1.defaultMethod", mod = DEFAULT, declared = NO)
+class TestClass13 implements TestIF1A, TestIF1B {
+}
+
+//Diamond Override Case
+@MethodDesc(name = "defaultMethod", retval = "TestIF1C.defaultMethod", mod = DEFAULT, declared = YES)
+interface TestIF1C extends TestIF1 {
+
+ default String defaultMethod() {
+ return "TestIF1C.defaultMethod";
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF1D.defaultMethod", mod = DEFAULT, declared = YES)
+interface TestIF1D extends TestIF1 {
+
+ default String defaultMethod() {
+ return "TestIF1D.defaultMethod";
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestClass14.defaultMethod", mod = REGULAR, declared = YES)
+class TestClass14 implements TestIF1C, TestIF1D {
+
+ public String defaultMethod() {
+ return "TestClass14.defaultMethod";
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "", mod = ABSTRACT, declared = YES)
+interface TestIF15 extends TestIF1 {
+
+ String defaultMethod();
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestClass15.defaultMethod", mod = REGULAR, declared = YES)
+class TestClass15 implements TestIF15 {
+
+ public String defaultMethod() {
+ return "TestClass15.defaultMethod";
+ }
+}
+
+interface FuncInterface<T> {
+
+ String test(T t);
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF16.defaultMethod", mod = DEFAULT, declared = YES)
+interface TestIF16 {
+
+ default String defaultMethod() {
+ FuncInterface<Object> fi = o -> o.toString();
+ Object o = "TestIF16.defaultMethod";
+ return fi.test(o);
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF16.defaultMethod", mod = DEFAULT, declared = NO)
+class TestClass16 implements TestIF16 {
+};
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF17.defaultMethod", mod = DEFAULT, declared = YES)
+@MethodDesc(name = "staticMethod", retval = "TestIF17.staticMethod", mod = STATIC, declared = YES)
+interface TestIF17 {
+
+ default String defaultMethod() {
+ return staticMethod().replace("staticMethod", "defaultMethod");
+ }
+
+ public static String staticMethod() {
+ return "TestIF17.staticMethod";
+ }
+}
+
+@MethodDesc(name = "defaultMethod", retval = "TestIF17.defaultMethod", mod = DEFAULT, declared = NO)
+class TestClass17 implements TestIF17 {
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Repeatable(MethodDescs.class)
+@interface MethodDesc {
+ String name();
+ String retval();
+ Mod mod();
+ Declared declared();
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface MethodDescs {
+ MethodDesc[] value();
+}
+
+public class DefaultStaticTestData {
+
+ /**
+ * Test data for DefaultStaticInvokeTest The format of inner array is: First
+ * data is the name of the class under test Second data used in test as the
+ * arguments used for the method call.
+ */
+ @DataProvider
+ static Object[][] testClasses() {
+ return new Object[][]{
+ {"TestClass1", null},
+ //{"TestClass2", null}, @ignore due to JDK-8009411
+ {"TestClass3", null},
+ //{"TestClass4", null}, @ignore due to JDK-8009411
+ //{"TestClass5", null}, @ignore due to JDK-8009411
+ //{"TestClass6", null}, @ignore due to JDK-8009411
+ {"TestClass7", "TestIF7.TestClass7"},
+ {"TestClass8", "TestIF8.TestClass8"},
+ {"TestClass9", null},
+ {"TestClass91", null},
+ //{"TestClass11", null}, @ignore due to JDK-8009411
+ //{"TestClass12", null}, @ignore due to JDK-8009411
+ {"TestClass13", null},
+ {"TestClass14", null},
+ {"TestClass15", null},
+ {"TestClass16", null}
+ //{"TestClass17", null} @ignore due to JDK-8009411
+ };
+ }
+
+ /**
+ * Test data for DefaultStaticInvokeTest The format of inner array is: First
+ * data is the name of the interface under test Second data used in test as
+ * the arguments used for the method call.
+ */
+ @DataProvider
+ static Object[][] testInterfaces() {
+ return new Object[][]{
+ {"TestIF1", null},
+ {"TestIF2", null},
+ {"TestIF3", null},
+ {"TestIF4", null},
+ {"TestIF5", null},
+ {"TestIF6", null},
+ {"TestIF7", "TestIF7.TestClass7"},
+ {"TestIF8", "TestIF8.TestClass8"},
+ {"TestIF9", null},
+ {"TestIF10", null},
+ {"TestIF11", null},
+ {"TestIF12", null},
+ {"TestIF1A", null},
+ {"TestIF1B", null},
+ {"TestIF1C", null},
+ {"TestIF1D", null},
+ {"TestIF15", null},
+ {"TestIF16", null},
+ {"TestIF17", null},};
+ }
+
+ @DataProvider
+ static Object[][] testCasesAll() {
+ List<Object[]> result = Lists.newArrayList();
+ result.addAll(Arrays.asList(testClasses()));
+ result.addAll(Arrays.asList(testInterfaces()));
+ return result.toArray(new Object[result.size()][]);
+ }
+}