ParameterizedTypeTest.java revision f6c387128427e121477c1b32ad35cdcaa5101ba3 
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.TestTargets;
20import dalvik.annotation.TestLevel;
21import dalvik.annotation.TestTargetNew;
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    @TestTargets({
38        @TestTargetNew(
39            level = TestLevel.SUFFICIENT,
40            notes = "Missing tests for TypeNotPresentException, MalformedParametrizedTypeException",
41            method = "getActualTypeArguments",
42            args = {}
43        ),
44        @TestTargetNew(
45            level = TestLevel.SUFFICIENT,
46            notes = "Missing tests for TypeNotPresentException, MalformedParametrizedTypeException",
47            method = "getOwnerType",
48            args = {}
49        ),
50        @TestTargetNew(
51            level = TestLevel.SUFFICIENT,
52            notes = "Missing tests for TypeNotPresentException, MalformedParametrizedTypeException",
53            method = "getRawType",
54            args = {}
55        )
56    })
57    public void testStringParameterizedSuperClass() {
58        Class<? extends B> clazz = B.class;
59        Type genericSuperclass = clazz.getGenericSuperclass();
60        assertInstanceOf(ParameterizedType.class, genericSuperclass);
61        ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
62        assertEquals(ParameterizedTypeTest.class, parameterizedType.getOwnerType());
63        assertEquals(A.class, parameterizedType.getRawType());
64
65        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
66        assertLenghtOne(actualTypeArguments);
67        assertEquals(String.class, actualTypeArguments[0]);
68    }
69
70    static class C<T>{}
71    static class D<T> extends C<T>{}
72
73    @TestTargets({
74        @TestTargetNew(
75            level = TestLevel.SUFFICIENT,
76            notes = "Missing tests for TypeNotPresentException, MalformedParametrizedTypeException",
77            method = "getActualTypeArguments",
78            args = {}
79        ),
80        @TestTargetNew(
81            level = TestLevel.SUFFICIENT,
82            notes = "Missing tests for TypeNotPresentException, MalformedParametrizedTypeException",
83            method = "getOwnerType",
84            args = {}
85        ),
86        @TestTargetNew(
87            level = TestLevel.SUFFICIENT,
88            notes = "Missing tests for TypeNotPresentException, MalformedParametrizedTypeException",
89            method = "getRawType",
90            args = {}
91        )
92    })
93    public void testTypeParameterizedSuperClass() {
94        Class<? extends D> clazz = D.class;
95        Type genericSuperclass = clazz.getGenericSuperclass();
96        assertInstanceOf(ParameterizedType.class, genericSuperclass);
97        ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
98        assertEquals(ParameterizedTypeTest.class, parameterizedType.getOwnerType());
99        assertEquals(C.class, parameterizedType.getRawType());
100
101        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
102        assertLenghtOne(actualTypeArguments);
103        assertEquals(getTypeParameter(D.class), actualTypeArguments[0]);
104    }
105
106    static class E<T>{}
107    static class F<T>{
108        E<T> e;
109    }
110
111    @TestTargets({
112        @TestTargetNew(
113            level = TestLevel.SUFFICIENT,
114            notes = "Missing tests for TypeNotPresentException, MalformedParametrizedTypeException",
115            method = "getActualTypeArguments",
116            args = {}
117        ),
118        @TestTargetNew(
119            level = TestLevel.SUFFICIENT,
120            notes = "Missing tests for TypeNotPresentException, MalformedParametrizedTypeException",
121            method = "getOwnerType",
122            args = {}
123        ),
124        @TestTargetNew(
125            level = TestLevel.SUFFICIENT,
126            notes = "Missing tests for TypeNotPresentException, MalformedParametrizedTypeException",
127            method = "getRawType",
128            args = {}
129        )
130    })
131    public void testParameterizedMemeber() throws Exception{
132        Class<? extends F> clazz = F.class;
133        Field field = clazz.getDeclaredField("e");
134        assertInstanceOf(ParameterizedType.class, field.getGenericType());
135        ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();
136        assertEquals(ParameterizedTypeTest.class, parameterizedType.getOwnerType());
137        assertEquals(E.class, parameterizedType.getRawType());
138
139        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
140        assertLenghtOne(actualTypeArguments);
141        assertEquals(getTypeParameter(clazz), actualTypeArguments[0]);
142    }
143}
144