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