Mercurial > hg > openjdk > lambda > jdk
changeset 9513:cd0ea5563523
7184826: (reflect) Add support for Project Lambda concepts in core reflection
Reviewed-by: darcy, jfranck
Contributed-by: Amy Lu <amy.lu@oracle.com>
| author | jfranck |
|---|---|
| date | Tue, 06 Aug 2013 18:54:02 +0200 |
| parents | ba634b53f53a |
| children | 98643f3ddf40 |
| files | test/java/lang/reflect/DefaultStaticTest/DefaultStaticInvokeTest.java test/java/lang/reflect/DefaultStaticTest/DefaultStaticTestData.java test/java/lang/reflect/DefaultStaticTest/helper/Declared.java test/java/lang/reflect/DefaultStaticTest/helper/Mod.java test/java/lang/reflect/Method/DefaultMethodModeling.java test/java/lang/reflect/Method/IsDefaultTest.java |
| diffstat | 6 files changed, 876 insertions(+), 1 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/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/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()][]); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/java/lang/reflect/DefaultStaticTest/helper/Declared.java Tue Aug 06 18:54:02 2013 +0200 @@ -0,0 +1,35 @@ +/* + * 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. + */ + +/* + * Helper class used for testing default/static method + * + * @author Yong Lu + */ + +package helper; + +public enum Declared { + YES, + NO +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/java/lang/reflect/DefaultStaticTest/helper/Mod.java Tue Aug 06 18:54:02 2013 +0200 @@ -0,0 +1,37 @@ +/* + * 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. + */ + +/* + * Helper class used for testing default/static method + * + * @author Yong Lu + */ + +package helper; + +public enum Mod { + DEFAULT, + STATIC, + REGULAR, + ABSTRACT +}
--- a/test/java/lang/reflect/Method/DefaultMethodModeling.java Tue Aug 06 08:34:28 2013 -0700 +++ b/test/java/lang/reflect/Method/DefaultMethodModeling.java Tue Aug 06 18:54:02 2013 +0200 @@ -43,7 +43,7 @@ SuperIwithDefault.class, SuperIwithDefaultChild.class, Base.class, Combo1.class, Combo2.class, SonSuperIwithDefault.class, DaughterSuperIwithDefault.class, GrandchildSuperIwithDefault.class, D.class, - B.class, C.class + B.class, C.class, B1.class, D1.class }; for(Class<?> clazz : classes) { @@ -202,6 +202,17 @@ public void quux(){} } +class D1 implements SonSuperIwithDefault, DaughterSuperIwithDefault { + @ExpectedModel(declaringClass=D1.class) + public void foo(){} + + @ExpectedModel(declaringClass=D1.class) + public void baz(){} + + @ExpectedModel(declaringClass=D1.class) + public void quux(){} +} + // -=-=-=- // What does re-abstraction look like? @@ -222,3 +233,21 @@ @ExpectedModel(declaringClass=C.class) public void bar(){} } + +abstract class A1 implements SonSuperIwithDefault { + @ExpectedModel(modifiers=PUBLIC|ABSTRACT, declaringClass=A1.class) + public abstract void baz(); + + @ExpectedModel(modifiers=PUBLIC|ABSTRACT, declaringClass=A1.class) + public abstract void foo(); +} + +class B1 extends A1 { + @ExpectedModel(declaringClass=B1.class) + @Override + public void foo(){;} + + @ExpectedModel(declaringClass=B1.class) + @Override + public void baz(){} +}
--- a/test/java/lang/reflect/Method/IsDefaultTest.java Tue Aug 06 08:34:28 2013 -0700 +++ b/test/java/lang/reflect/Method/IsDefaultTest.java Tue Aug 06 18:54:02 2013 +0200 @@ -42,6 +42,12 @@ classList.add(TestType2.class); classList.add(TestType3.class); classList.add(TestType4.class); + classList.add(TestType2.nestedTestType2.class); + classList.add(TestType5.class); + classList.add(TestType5.nestedTestType5.class); + classList.add(TestType6.class); + classList.add(TestType6.nestedTestType6.class); + classList.add(TestType7.class); for(Class<?> clazz: classList) { for(Method method: clazz.getDeclaredMethods()) { @@ -78,11 +84,22 @@ @ExpectedIsDefault(true) default void bar() {}; // Default method + + @ExpectedIsDefault(true) + default void bar(int i) {}; // Default method + + @ExpectedIsDefault(true) + default void bar(String i) {}; // Default method } class TestType2 { @ExpectedIsDefault(false) void bar() {}; + + interface nestedTestType2 { + @ExpectedIsDefault(true) + default void nestedBar() {}; + } } class TestType3 implements TestType1 { @@ -92,6 +109,10 @@ @ExpectedIsDefault(false) @Override public void bar() {}; + + @ExpectedIsDefault(false) + @Override + public void bar(int i) {}; } @interface TestType4 { @@ -102,6 +123,51 @@ String anotherValue() default ""; } +interface TestType5 { + @ExpectedIsDefault(false) + abstract void aFoo(); + + @ExpectedIsDefault(false) + static void sFoo() {}; + + @ExpectedIsDefault(true) + public default void pBar() {}; + + @ExpectedIsDefault(true) + public default String sBar() {return "";}; + + interface nestedTestType5{ + @ExpectedIsDefault(false) + void nestedFoo(); + + @ExpectedIsDefault(true) + default void nestedBar() {}; + } +} + +class TestType6{ + interface nestedTestType6 { + @ExpectedIsDefault(true) + default void nestedBar() {}; + + @ExpectedIsDefault(false) + void nestedFoo(); + } + + @ExpectedIsDefault(false) + void foo(nestedTestType6 n) {} +} + +class TestType7 implements TestType6.nestedTestType6 { + + @ExpectedIsDefault(false) + public void nestedFoo() {} + + @ExpectedIsDefault(false) + @Override + public void nestedBar() {}; +} + @Retention(RetentionPolicy.RUNTIME) @interface ExpectedIsDefault { boolean value();