ParameterizedTypeTest.java revision 89c1feb0a69a7707b271086e749975b3f7acacf7 
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 tests.api.java.lang.reflect;
18
19import dalvik.annotation.TestInfo;
20import dalvik.annotation.TestLevel;
21import dalvik.annotation.TestTarget;
22import dalvik.annotation.TestTargetClass;
23
24import java.lang.reflect.Field;
25import java.lang.reflect.ParameterizedType;
26import java.lang.reflect.Type;
27
28/**
29 * Tests parameterized types and their properties.
30 */
31@TestTargetClass(ParameterizedType.class)
32public class ParameterizedTypeTest extends GenericReflectionTestsBase {
33
34    static class A<T>{}
35    static class B extends A<String>{}
36
37    @TestInfo(
38            level = TestLevel.PARTIAL,
39            purpose = "Doesn't check exceptions.",
40            targets = {
41              @TestTarget(
42                methodName = "getActualTypeArguments",
43                methodArgs = {}
44              ),
45              @TestTarget(
46                methodName = "getOwnerType",
47                methodArgs = {}
48              ),
49              @TestTarget(
50                methodName = "getRawType",
51                methodArgs = {}
52              )
53          })
54    public void testStringParameterizedSuperClass() {
55        Class<? extends B> clazz = B.class;
56        Type genericSuperclass = clazz.getGenericSuperclass();
57        assertInstanceOf(ParameterizedType.class, genericSuperclass);
58        ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
59        assertEquals(ParameterizedTypeTest.class, parameterizedType.getOwnerType());
60        assertEquals(A.class, parameterizedType.getRawType());
61
62        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
63        assertLenghtOne(actualTypeArguments);
64        assertEquals(String.class, actualTypeArguments[0]);
65    }
66
67    static class C<T>{}
68    static class D<T> extends C<T>{}
69
70    @TestInfo(
71            level = TestLevel.PARTIAL,
72            purpose = "Doesn't check exceptions.",
73            targets = {
74              @TestTarget(
75                methodName = "getActualTypeArguments",
76                methodArgs = {}
77              ),
78              @TestTarget(
79                methodName = "getOwnerType",
80                methodArgs = {}
81              ),
82              @TestTarget(
83                methodName = "getRawType",
84                methodArgs = {}
85              )
86          })
87    public void testTypeParameterizedSuperClass() {
88        Class<? extends D> clazz = D.class;
89        Type genericSuperclass = clazz.getGenericSuperclass();
90        assertInstanceOf(ParameterizedType.class, genericSuperclass);
91        ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
92        assertEquals(ParameterizedTypeTest.class, parameterizedType.getOwnerType());
93        assertEquals(C.class, parameterizedType.getRawType());
94
95        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
96        assertLenghtOne(actualTypeArguments);
97        assertEquals(getTypeParameter(D.class), actualTypeArguments[0]);
98    }
99
100    static class E<T>{}
101    static class F<T>{
102        E<T> e;
103    }
104
105    @TestInfo(
106      level = TestLevel.PARTIAL,
107      purpose = "Doesn't check exceptions.",
108      targets = {
109        @TestTarget(
110          methodName = "getActualTypeArguments",
111          methodArgs = {}
112        ),
113        @TestTarget(
114          methodName = "getOwnerType",
115          methodArgs = {}
116        ),
117        @TestTarget(
118          methodName = "getRawType",
119          methodArgs = {}
120        )
121    })
122    public void testParameterizedMemeber() throws Exception{
123        Class<? extends F> clazz = F.class;
124        Field field = clazz.getDeclaredField("e");
125        assertInstanceOf(ParameterizedType.class, field.getGenericType());
126        ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();
127        assertEquals(ParameterizedTypeTest.class, parameterizedType.getOwnerType());
128        assertEquals(E.class, parameterizedType.getRawType());
129
130        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
131        assertLenghtOne(actualTypeArguments);
132        assertEquals(getTypeParameter(clazz), actualTypeArguments[0]);
133    }
134}
135