1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package org.apache.harmony.tests.java.lang.reflect;
18
19import java.lang.reflect.Field;
20import java.lang.reflect.ParameterizedType;
21import java.lang.reflect.Type;
22
23/**
24 * Tests parameterized types and their properties.
25 */
26public class ParameterizedTypeTest extends GenericReflectionTestsBase {
27
28    static class A<T>{}
29    static class B extends A<String>{}
30
31    public void testStringParameterizedSuperClass() {
32        Class<? extends B> clazz = B.class;
33        Type genericSuperclass = clazz.getGenericSuperclass();
34        assertInstanceOf(ParameterizedType.class, genericSuperclass);
35
36        String aName = A.class.getName();
37        assertEquals(aName + "<java.lang.String>", genericSuperclass.toString());
38        assertEquals(aName + "<java.lang.String>", genericSuperclass.getTypeName());
39
40        ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
41        assertEquals(ParameterizedTypeTest.class, parameterizedType.getOwnerType());
42        assertEquals(A.class, parameterizedType.getRawType());
43
44        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
45        assertLenghtOne(actualTypeArguments);
46        assertEquals(String.class, actualTypeArguments[0]);
47    }
48
49    static class C<T>{}
50    static class D<T> extends C<T>{}
51
52    public void testTypeParameterizedSuperClass() {
53        Class<? extends D> clazz = D.class;
54        Type genericSuperclass = clazz.getGenericSuperclass();
55        assertInstanceOf(ParameterizedType.class, genericSuperclass);
56
57        String cName = C.class.getName();
58        assertEquals(cName + "<T>", genericSuperclass.toString());
59        assertEquals(cName + "<T>", genericSuperclass.getTypeName());
60
61        ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
62        assertEquals(ParameterizedTypeTest.class, parameterizedType.getOwnerType());
63        assertEquals(C.class, parameterizedType.getRawType());
64
65        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
66        assertLenghtOne(actualTypeArguments);
67        assertEquals(getTypeParameter(D.class), actualTypeArguments[0]);
68    }
69
70    static class E<T>{}
71    static class F<T>{
72        E<T> e;
73    }
74
75    public void testParameterizedMemeber() throws Exception{
76        Class<? extends F> clazz = F.class;
77        Field field = clazz.getDeclaredField("e");
78        assertInstanceOf(ParameterizedType.class, field.getGenericType());
79        ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();
80        assertEquals(ParameterizedTypeTest.class, parameterizedType.getOwnerType());
81        assertEquals(E.class, parameterizedType.getRawType());
82
83        String eName = E.class.getName();
84        assertEquals(eName + "<T>", parameterizedType.toString());
85        assertEquals(eName + "<T>", parameterizedType.getTypeName());
86
87        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
88        assertLenghtOne(actualTypeArguments);
89        assertEquals(getTypeParameter(clazz), actualTypeArguments[0]);
90    }
91}
92