| /* |
| * Copyright (c) 2003, 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 |
| * @bug 4891872 |
| * @summary Some tests for the generic core reflection api. |
| * @author Gilad Bracha |
| * @compile TestC2.java |
| * @run main/othervm -ea TestC2 |
| */ |
| |
| |
| import java.lang.reflect.*; |
| |
| |
| abstract class C0<T> { |
| |
| public T ft; |
| public C0<T> fc1t; |
| public C0 fc1; |
| |
| public C0(){} |
| public C0(T t) {} |
| |
| public abstract C0<T> mc1t(T t, C0<T> c1t, C0 c1); |
| |
| public abstract C0 mc1(); |
| |
| public abstract T mt(T t); |
| |
| } |
| |
| interface I1<X1, X2> extends I3 { |
| |
| X1 foo(X2 x2); |
| } |
| |
| interface I2<E1, E2 extends Throwable, E3> { |
| |
| |
| E1 bar(E3 e3) throws E2; |
| |
| } |
| |
| interface I3 { |
| |
| |
| } |
| |
| |
| abstract class C2<T1 extends C2<T1, T2, T3>, T2 extends C0<T2>, |
| T3 extends Throwable> |
| extends C0<T1> |
| implements I1<T1, T2>, I2<T1, T3, T2>, I3 |
| { |
| |
| public T1 ft; |
| public C0<String> fc1t; |
| public C0 fc1; |
| public int fi; |
| |
| public C2(T2 t2) {} |
| public <T> C2(T t) {} |
| public <T1, T2, T3, T4> C2(T1 t1, T2 t2, T4 t4) {} |
| public C2() throws T3 {} |
| |
| public abstract <T> C0<T> mc1t(T3 t3, C0<T> c1t, C0 c1); |
| |
| public abstract <E, R> C0 mc1(E e); |
| |
| public abstract T1 mt(T2 t); |
| |
| } |
| |
| public class TestC2 { |
| |
| static Class<C2> cls = C2.class; |
| |
| |
| public static void main(String[] args) throws Throwable { |
| testSuperclass(); |
| testSuperInterfaces(); |
| testTypeParameters(); |
| testMethods(); |
| testConstructors(); |
| testFields(); |
| } |
| |
| static void testSuperclass() { |
| |
| System.out.println("testing superclass"); |
| Type sc = cls.getGenericSuperclass(); |
| assert |
| sc instanceof ParameterizedType : |
| "Superclass of C2 should be a parameterized type"; |
| ParameterizedType psc = (ParameterizedType) sc; |
| assert |
| ((psc.getRawType() == C0.class) ) : |
| "The raw generic superclass of C2 should be C0"; |
| |
| Type[] tas = psc.getActualTypeArguments(); |
| assert |
| tas.length == 1 : |
| "Superclass of C2 should have one type argument"; |
| |
| Type t = tas[0]; |
| |
| assert |
| t instanceof TypeVariable : |
| "Type argument to superclass of C2 should be a type variable"; |
| |
| TypeVariable tv = (TypeVariable) t; |
| assert |
| tv.getName().equals("T1") : |
| "Name of type argument to superclass of C2 should be T1"; |
| Type[] bs = tv.getBounds(); |
| assert |
| bs.length == 1 : |
| "T1 has one bound (superclass)"; |
| t = bs[0]; |
| assert |
| t instanceof ParameterizedType : |
| "Bound of C0 should be a parameterized type"; |
| ParameterizedType pt = (ParameterizedType) t; |
| |
| assert |
| ((pt.getRawType() == C2.class) ) : |
| "The raw bound of T1 should be C2"; |
| |
| tas = pt.getActualTypeArguments(); |
| assert |
| tas.length == 3 : |
| "Bound of T1 should have three type arguments"; |
| assert |
| tas[0] instanceof TypeVariable : |
| "First argument to bound of T1 is a type variable"; |
| assert |
| tas[1] instanceof TypeVariable : |
| "Second argument to bound of T1 is a type variable"; |
| assert |
| tas[2] instanceof TypeVariable : |
| "Third argument to bound of T1 is a type variable"; |
| |
| TypeVariable tv1 = (TypeVariable) tas[0]; |
| TypeVariable tv2 = (TypeVariable) tas[1]; |
| TypeVariable tv3 = (TypeVariable) tas[2]; |
| |
| assert |
| tv1.getName().equals("T1"): |
| "First type arg to bound of T1 is T1"; |
| assert |
| tv2.getName().equals("T2"): |
| "Seconmd type arg to bound of T1 is T2"; |
| assert |
| tv3.getName().equals("T3"): |
| "Third type arg to bound of T1 is T3"; |
| |
| |
| } |
| |
| static void testSuperInterfaces() { |
| System.out.println("testing superinterfaces"); |
| Type[] sis = cls.getGenericInterfaces(); |
| assert |
| ((sis.length == 3)): |
| "C2 should have three generic superinterfaces"; |
| |
| Type t = sis[0]; |
| assert |
| t instanceof ParameterizedType : |
| "First superinterface of C2 should be a parameterized type"; |
| ParameterizedType pt = (ParameterizedType) t; |
| assert |
| pt.getRawType() == I1.class : |
| "First super interface of C2 is instantiation of I1"; |
| Type[] tas = pt.getActualTypeArguments(); |
| assert |
| tas.length == 2 : |
| "First super interface of C2 has 2 type arguments"; |
| |
| t = sis[1]; |
| assert |
| t instanceof ParameterizedType : |
| "Second superinterface of C2 should be a parameterized type"; |
| pt = (ParameterizedType) t; |
| assert |
| pt.getRawType() == I2.class : |
| "Second super interface of C2 is instantiation of I2"; |
| tas = pt.getActualTypeArguments(); |
| assert |
| tas.length == 3 : |
| "Second super interface of C2 has 3 type arguments"; |
| |
| t = sis[2]; |
| assert |
| t == I3.class : |
| "Third superinterface of C2 is I3"; |
| |
| // Test interfaces themselves |
| |
| TypeVariable[] tvs = I1.class.getTypeParameters(); |
| assert |
| tvs.length == 2 : |
| "I3 has two formal type parameters"; |
| assert |
| tvs[0].getName().equals("X1") : |
| "Name of first formal type arg of I1 is X1"; |
| assert |
| tvs[1].getName().equals("X2") : |
| "Name of second formal type arg of I1 is X2"; |
| |
| assert |
| I1.class.getGenericSuperclass() == I1.class.getSuperclass() : |
| "The generic and non-generic superclasses of an interface must be the same"; |
| sis = I1.class.getGenericInterfaces(); |
| assert |
| sis.length == 1 : |
| "I1 has one generic superinterface"; |
| assert |
| sis[0] == I3.class : |
| "Superinterface of I1 is I3"; |
| |
| tvs = I2.class.getTypeParameters(); |
| assert |
| tvs.length == 3 : |
| "I3 has three formal type parameters"; |
| assert |
| tvs[0].getName().equals("E1") : |
| "Name of first formal type arg of I2 is E1"; |
| assert |
| tvs[1].getName().equals("E2") : |
| "Name of second formal type arg of I2 is E2"; |
| assert |
| tvs[2].getName().equals("E3") : |
| "Name of third formal type arg of I2 is E3"; |
| |
| assert |
| I2.class.getGenericSuperclass() == I2.class.getSuperclass() : |
| "The generic and non-generic superclasses of an interface must be the same"; |
| |
| tvs = I3.class.getTypeParameters(); |
| assert |
| tvs.length == 0 : |
| "I3 has no formal type parameters"; |
| |
| assert |
| I3.class.getGenericSuperclass() == I3.class.getSuperclass() : |
| "The generic and non-generic superclasses of an interface must be the same"; |
| |
| |
| } |
| |
| static void testTypeParameters() { |
| System.out.println("testing type parameters"); |
| TypeVariable[] tvs = cls.getTypeParameters(); |
| assert |
| tvs.length == 3 : |
| "C2 should have three type parameters"; |
| TypeVariable tv = tvs[0]; |
| Type[] bs = tv.getBounds(); |
| assert |
| bs.length == 1 : |
| "T1 should have one bound"; |
| assert |
| bs[0] instanceof ParameterizedType : |
| "The bound of T1 should be a parameterized type"; |
| |
| tv = tvs[1]; |
| bs = tv.getBounds(); |
| assert |
| bs.length == 1 : |
| "T2 should have one bound"; |
| assert |
| bs[0] instanceof ParameterizedType : |
| "The bound of T2 should be a parameterized type"; |
| |
| tv = tvs[2]; |
| bs = tv.getBounds(); |
| assert |
| bs.length == 1 : |
| "T3 should have one bound"; |
| assert |
| bs[0] == Throwable.class : |
| "The bound of T3 should be Throwable"; |
| } |
| |
| static void testMethods() throws NoSuchMethodException { |
| System.out.println("testing methods"); |
| |
| |
| |
| Class[] params1 = new Class[3]; |
| params1[0] = Throwable.class; |
| params1[1] = C0.class; |
| params1[2] = C0.class; |
| |
| Class[] params2 = new Class[1]; |
| params2[0] = Object.class; |
| |
| Class[] params3 = new Class[1]; |
| params3[0] = C0.class; |
| |
| Method mc1t = cls.getMethod("mc1t", params1); |
| Method mc1 = cls.getMethod("mc1", params2); |
| Method mt = cls.getMethod("mt", params3); |
| |
| Type rt_mc1t = mc1t.getGenericReturnType(); |
| assert |
| rt_mc1t instanceof ParameterizedType : |
| "The return type of mc1t should be a parameterized type"; |
| ParameterizedType pt = (ParameterizedType) rt_mc1t; |
| |
| assert |
| pt.getRawType() == C0.class : |
| "The raw return type of mc1t should be C0"; |
| |
| Type[] tas = pt.getActualTypeArguments(); |
| assert |
| tas.length == 1 : |
| "Return type of mc1t should have one type argument"; |
| assert |
| tas[0] instanceof TypeVariable : |
| "Type argument of return type of mc1t is a type variable"; |
| |
| Type rt_mc1 = mc1.getGenericReturnType(); |
| assert |
| rt_mc1 == C0.class : |
| "Return type of mc1 is C0"; |
| |
| Type rt_mt = mt.getGenericReturnType(); |
| assert |
| rt_mt instanceof TypeVariable : |
| "Return type of mt is a type variable"; |
| |
| Type[] pt_mc1t = mc1t.getGenericParameterTypes(); |
| |
| assert |
| pt_mc1t.length == 3 : |
| "C0.mc1t has three parameters"; |
| Type p1_mc1t = pt_mc1t[0]; |
| assert p1_mc1t != null; |
| assert |
| p1_mc1t instanceof TypeVariable : |
| "Generic type of the 1st parameter of mc1t(T) is a type variable"; |
| TypeVariable tv = (TypeVariable) p1_mc1t; |
| |
| assert |
| tv.getName().equals("T3") : |
| "Name of 1st type parameter of mc1t is T3, not " + tv.getName(); |
| Type[] bs = tv.getBounds(); |
| assert |
| bs.length == 1 : |
| "T3 should have one bound (mc1t)"; |
| assert |
| bs[0] == Throwable.class : |
| "The bound of T3 should be Throwable(mc1t)"; |
| |
| Type p2_mc1t = pt_mc1t[1]; |
| assert |
| p2_mc1t instanceof ParameterizedType : |
| "The type of parameter 2 of mc1t is a parameterized type"; |
| pt = (ParameterizedType) p2_mc1t; |
| assert |
| pt.getRawType() == C0.class : |
| "Type of parameter 2 of mc1t is instantiation of C0"; |
| assert |
| pt.getOwnerType() == null : |
| "Type of parameter 2 of mc1t is has null owner"; |
| |
| tas = pt.getActualTypeArguments(); |
| assert |
| tas.length == 1 : |
| "The type of parameter 2 of mc1t has one type argument"; |
| Type ta = tas[0]; |
| |
| assert |
| ta instanceof TypeVariable : |
| "The actual type arg of C0<T> is a type variable (mc1t)"; |
| tv = (TypeVariable) ta; |
| assert |
| tv.getName().equals("T") : |
| "mc1t: Name of the type arg of C0<T> is T, not " + tv.getName(); |
| bs = tv.getBounds(); |
| assert |
| bs.length == 1 : |
| "mc1t: The type argument of C0<T> should have one bound"; |
| assert |
| bs[0] == Object.class : |
| "mc1t: The bound of the type arg of C0<T> should be Object"; |
| |
| Type p3_mc1t = pt_mc1t[2]; |
| assert |
| p3_mc1t == C0.class : |
| "Type of parameter 3 of mc1t is C0"; |
| |
| Type[] pt_mc1 = mc1.getGenericParameterTypes(); |
| assert |
| pt_mc1.length == 1 : |
| "C2.mc1 has one parameter"; |
| |
| Type[] pt_mt = mt.getGenericParameterTypes(); |
| assert |
| pt_mt.length == 1 : |
| "C2.mt has one parameter"; |
| Type p_mt = pt_mt[0]; |
| assert |
| p_mt instanceof TypeVariable : |
| "The generic type of the parameter of mt(T) is a type variable"; |
| tv = (TypeVariable) p_mt; |
| assert |
| tv.getName().equals("T2") : |
| "The name of the type parameter of mt is T2, not " + tv.getName(); |
| bs = tv.getBounds(); |
| assert |
| bs.length == 1 : |
| "T2 should have one bound"; |
| assert |
| bs[0] instanceof ParameterizedType: |
| "The bound of T2 should be parameterized type"; |
| |
| Type[] et_mc1t = mc1t.getGenericExceptionTypes(); |
| assert |
| et_mc1t.length == 0 : |
| "Method C0.mc1t should have no generic exception types"; |
| |
| Type[] et_mc1 = mc1.getGenericExceptionTypes(); |
| assert |
| et_mc1.length == 0 : |
| "Method C0.mc1 should have no generic exception types"; |
| |
| Type[] et_mt = mt.getGenericExceptionTypes(); |
| assert |
| et_mt.length == 0 : |
| "Method C0.mt should have no generic exception types"; |
| |
| |
| TypeVariable[] tv_mc1t = mc1t.getTypeParameters(); |
| assert |
| tv_mc1t.length == 1 : |
| "Method C2.mc1t should have one type parameter"; |
| |
| TypeVariable[] tv_mc1 = mc1.getTypeParameters(); |
| assert |
| tv_mc1.length == 2 : |
| "Method C2.mc1 should have two type parameters"; |
| |
| TypeVariable[] tv_mt = mt.getTypeParameters(); |
| assert |
| tv_mt.length == 0 : |
| "Method C2.mt should have no type parameters"; |
| } |
| |
| |
| static void testFields() throws NoSuchFieldException{ |
| System.out.println("testing fields"); |
| Field ft = cls. getField("ft"); |
| Field fc1t = cls. getField("fc1t"); |
| Field fc1 = cls. getField("fc1"); |
| Field fi = cls. getField("fi"); |
| |
| Type gt_ft = ft.getGenericType(); |
| assert |
| gt_ft instanceof TypeVariable : |
| "The generic type of C0.ft is a type variable"; |
| TypeVariable tv = (TypeVariable) gt_ft; |
| assert |
| tv.getName().equals("T1") : |
| "The name of the type of ft is T1, not " + tv.getName(); |
| Type[] bs = tv.getBounds(); |
| assert |
| bs.length == 1 : |
| "The type of ft should have one bound"; |
| |
| |
| Type gt_fc1t = fc1t.getGenericType(); |
| assert |
| gt_fc1t instanceof ParameterizedType : |
| "The generic type of C0.fc1t is a parameterized type"; |
| ParameterizedType pt = (ParameterizedType) gt_fc1t; |
| assert |
| pt.getRawType() == C0.class : |
| "Type of C2.fc1t is an instantiation of C0"; |
| assert |
| pt.getOwnerType() == null : |
| "Type of C2.fc1t is has null owner"; |
| Type[] tas = pt.getActualTypeArguments(); |
| assert |
| tas.length == 1 : |
| "The type of fc1t has one type argument"; |
| Type ta = tas[0]; |
| |
| assert |
| ta == String.class : |
| "The actual type arg of C0<String> is String"; |
| |
| |
| Type gt_fc1 = fc1.getGenericType(); |
| assert |
| gt_fc1 == C0.class : |
| " Type of C2.fc1 should be C0"; |
| |
| Type gt_fi = fi.getGenericType(); |
| assert |
| gt_fi == int.class: |
| " Type of C2.fi should be int"; |
| |
| } |
| |
| static void testConstructors() throws NoSuchMethodException { |
| System.out.println("testing constructors"); |
| Class[] params1 = new Class[1]; |
| params1[0] = C0.class; |
| Constructor<C2> con = cls.getDeclaredConstructor(params1); |
| |
| Type[] pt_con = con.getGenericParameterTypes(); |
| assert |
| pt_con.length == 1 : |
| "Constructor C0(T) should have one generic parameter type"; |
| Type pt = pt_con[0]; |
| assert |
| pt instanceof TypeVariable : |
| "The generic type of the parameter of C0(T2) is a type variable"; |
| TypeVariable tv = (TypeVariable) pt; |
| assert |
| tv.getName().equals("T2") : |
| "The name of the type parameter of C2 is T2, not " + tv.getName(); |
| Type[] bs = tv.getBounds(); |
| assert |
| bs.length == 1 : |
| "T should have one bound"; |
| |
| |
| Type[] et_con = con.getGenericExceptionTypes(); |
| assert |
| et_con.length == 0 : |
| "Constructor C2(T2) should have no generic exception types"; |
| |
| TypeVariable[] tv_con = con.getTypeParameters(); |
| assert |
| tv_con.length == 0 : |
| "Constructor C2(T2) should have no type parameters"; |
| |
| |
| Class[] params2 = new Class[1]; |
| params2[0] = Object.class; |
| con = cls.getDeclaredConstructor(params2); |
| |
| pt_con = con.getGenericParameterTypes(); |
| assert |
| pt_con.length == 1 : |
| "Constructor C0(T) should have one generic parameter type"; |
| pt = pt_con[0]; |
| assert |
| pt instanceof TypeVariable : |
| "The generic type of the parameter of C2(T) is a type variable"; |
| tv = (TypeVariable) pt; |
| assert |
| tv.getName().equals("T") : |
| "The name of the type parameter of C2 is T, not " + tv.getName(); |
| bs = tv.getBounds(); |
| assert |
| bs.length == 1 : |
| "T should have one bound"; |
| |
| |
| et_con = con.getGenericExceptionTypes(); |
| assert |
| et_con.length == 0 : |
| "Constructor C2(T) should have no generic exception types"; |
| |
| tv_con = con.getTypeParameters(); |
| assert |
| tv_con.length == 1 : |
| "Constructor C2(T) should have one type parameter"; |
| |
| Class[] params3 = new Class[3]; |
| params3[0] = Object.class; |
| params3[1] = Object.class; |
| params3[2] = Object.class; |
| |
| con = cls.getDeclaredConstructor(params3); |
| |
| pt_con = con.getGenericParameterTypes(); |
| assert |
| pt_con.length == 3 : |
| "Constructor C2(T1,T2,T4) should have three generic parameter types"; |
| pt = pt_con[0]; |
| assert |
| pt instanceof TypeVariable : |
| "The generic type of the first parameter of C2(T1,T2,T4) is a type variable"; |
| tv = (TypeVariable) pt; |
| assert |
| tv.getName().equals("T1") : |
| "The name of the type parameter of C2(T1,T2,T4) is T1, not " + tv.getName(); |
| bs = tv.getBounds(); |
| assert |
| bs.length == 1 : |
| "T should have one bound"; |
| |
| |
| et_con = con.getGenericExceptionTypes(); |
| assert |
| et_con.length == 0 : |
| "Constructor C2(T1,T2,T4) should have no generic exception types"; |
| |
| tv_con = con.getTypeParameters(); |
| assert |
| tv_con.length == 4 : |
| "Constructor C2(T1,T2,T4) should have four type parameters"; |
| |
| Class[] params4 = new Class[0]; |
| con = cls.getDeclaredConstructor(params4); |
| |
| pt_con = con.getGenericParameterTypes(); |
| assert |
| pt_con.length == 0 : |
| "Constructor C2() should have no generic parameter types"; |
| |
| |
| et_con = con.getGenericExceptionTypes(); |
| assert |
| et_con.length == 1 : |
| "Constructor C2() should have one generic exception type"; |
| |
| tv_con = con.getTypeParameters(); |
| assert |
| tv_con.length == 0 : |
| "Constructor C2() should have no type parameters"; |
| |
| |
| } |
| } |
