libcore/luni/src/test/java/tests/api/java/lang/reflect/GenericReflectionCornerCases.java

   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
  17 package tests.api.java.lang.reflect;
  18
  19 import dalvik.annotation.BrokenTest;
  20 import dalvik.annotation.KnownFailure;
  21 import dalvik.annotation.TestTargets;
  22 import dalvik.annotation.TestLevel;
  23 import dalvik.annotation.TestTargetNew;
  24 import dalvik.annotation.TestTargetClass;
  25
  26 import java.lang.reflect.Method;
  27 import java.lang.reflect.ParameterizedType;
  28 import java.lang.reflect.Type;
  29 import java.lang.reflect.TypeVariable;
  30 import java.lang.reflect.WildcardType;
  31
  32 /**
  33  * Tests generic reflection in more complicated cases. In particular: Scoping of
  34  * type parameters, equality of type parameters, wildcard types, parameterized
  35  * types and multiple bounds.
  36  */
  37 @TestTargetClass(Method.class)
  38 public class GenericReflectionCornerCases extends GenericReflectionTestsBase {
  39
  40     static class Pair<T, S> {}
  41
  42     static class WildcardEquality<T> {
  43         void wildcardEquality(Pair<? extends T, ? extends T> param) {}
  44     }
  45     @TestTargets({
  46         @TestTargetNew(
  47             level = TestLevel.PARTIAL,
  48             notes = "Stress test.",
  49             method = "getTypeParameters",
  50             args = {}
  51         ),
  52         @TestTargetNew(
  53             level = TestLevel.PARTIAL,
  54             notes = "Stress test.",
  55             method = "getGenericParameterTypes",
  56             args = {}
  57         )
  58     })
  59     @SuppressWarnings("unchecked")
  60     public void testWildcardEquality() throws Exception {
  61         Class<? extends WildcardEquality> clazz = WildcardEquality.class;
  62
  63         Method method = clazz.getDeclaredMethod("wildcardEquality", Pair.class);
  64         TypeVariable<?>[] typeParameters = clazz.getTypeParameters();
  65         assertLenghtOne(typeParameters);
  66         TypeVariable<?> typeParameter = typeParameters[0];
  67
  68         Type[] parameterTypes = method.getGenericParameterTypes();
  69         assertLenghtOne(parameterTypes);
  70         Type parameter = parameterTypes[0];
  71         assertInstanceOf(ParameterizedType.class, parameter);
  72         ParameterizedType paramType = (ParameterizedType) parameter;
  73         Type[] actualTypeArguments = paramType.getActualTypeArguments();
  74         assertEquals(2, actualTypeArguments.length);
  75
  76         Type firstArgument = actualTypeArguments[0];
  77         assertInstanceOf(WildcardType.class, firstArgument);
  78         WildcardType firstWildcardArgument = (WildcardType) firstArgument;
  79         Type secondArgument = actualTypeArguments[1];
  80         assertInstanceOf(WildcardType.class, secondArgument);
  81         WildcardType secondWildcardArgument = (WildcardType) secondArgument;
  82
  83         assertEquals(firstWildcardArgument, secondWildcardArgument);
  84
  85         Type[] firstWildcardArgumentUpperBounds = firstWildcardArgument.getUpperBounds();
  86         assertLenghtOne(firstWildcardArgumentUpperBounds);
  87         Type firstWildcardArgumentUpperBoundsType = firstWildcardArgumentUpperBounds[0];
  88
  89         Type[] secondWildcardArgumentUpperBounds = secondWildcardArgument.getUpperBounds();
  90         assertLenghtOne(secondWildcardArgumentUpperBounds);
  91         Type secondWildcardArgumentUpperBoundsType = secondWildcardArgumentUpperBounds[0];
  92
  93         assertEquals(firstWildcardArgumentUpperBoundsType, secondWildcardArgumentUpperBoundsType);
  94
  95         assertEquals(typeParameter, firstWildcardArgumentUpperBoundsType);
  96         assertEquals(typeParameter, secondWildcardArgumentUpperBoundsType);
  97     }
  98
  99     static class WildcardUnEquality<T> {
 100         void wildcardUnEquality(Pair<? extends T, ? super T> param) {}
 101     }
 102     @TestTargets({
 103         @TestTargetNew(
 104             level = TestLevel.PARTIAL,
 105             notes = "Stress test.",
 106             method = "getTypeParameters",
 107             args = {}
 108         ),
 109         @TestTargetNew(
 110             level = TestLevel.PARTIAL,
 111             notes = "Stress test.",
 112             method = "getGenericParameterTypes",
 113             args = {}
 114         )
 115     })
 116     @SuppressWarnings("unchecked")
 117     public void testWildcardUnEquality() throws Exception {
 118         Class<? extends WildcardUnEquality> clazz = WildcardUnEquality.class;
 119
 120         Method method = clazz.getDeclaredMethod("wildcardUnEquality", Pair.class);
 121         TypeVariable<?>[] typeParameters = clazz.getTypeParameters();
 122         assertLenghtOne(typeParameters);
 123         TypeVariable<?> typeParameter = typeParameters[0];
 124
 125         Type[] parameterTypes = method.getGenericParameterTypes();
 126         assertLenghtOne(parameterTypes);
 127         Type parameter = parameterTypes[0];
 128         assertInstanceOf(ParameterizedType.class, parameter);
 129         ParameterizedType paramType = (ParameterizedType) parameter;
 130         Type[] actualTypeArguments = paramType.getActualTypeArguments();
 131         assertEquals(2, actualTypeArguments.length);
 132
 133         Type firstArgument = actualTypeArguments[0];
 134         assertInstanceOf(WildcardType.class, firstArgument);
 135         WildcardType firstWildcardArgument = (WildcardType) firstArgument;
 136         Type secondArgument = actualTypeArguments[1];
 137         assertInstanceOf(WildcardType.class, secondArgument);
 138         WildcardType secondWildcardArgument = (WildcardType) secondArgument;
 139
 140         assertNotEquals(firstWildcardArgument, secondWildcardArgument);
 141
 142         Type[] firstWildcardArgumentUpperBounds = firstWildcardArgument.getUpperBounds();
 143         assertLenghtOne(firstWildcardArgumentUpperBounds);
 144         Type firstWildcardArgumentUpperBoundsType = firstWildcardArgumentUpperBounds[0];
 145
 146         Type[] secondWildcardArgumentLowerBounds = secondWildcardArgument.getLowerBounds();
 147         assertLenghtOne(secondWildcardArgumentLowerBounds);
 148         Type secondWildcardArgumentLoweroundsType = secondWildcardArgumentLowerBounds[0];
 149
 150         assertEquals(firstWildcardArgumentUpperBoundsType, secondWildcardArgumentLoweroundsType);
 151         assertEquals(typeParameter, firstWildcardArgumentUpperBoundsType);
 152         assertEquals(typeParameter, secondWildcardArgumentLoweroundsType);
 153     }
 154
 155     static class MultipleBoundedWildcardUnEquality<T extends Object & Comparable<MultipleBoundedWildcardUnEquality<T>>> {
 156         void multipleBoundedWildcardUnEquality(Pair<? extends T, ? super T> param) {}
 157     }
 158     @TestTargets({
 159         @TestTargetNew(
 160             level = TestLevel.PARTIAL,
 161             notes = "Stress test.",
 162             method = "getTypeParameters",
 163             args = {}
 164         ),
 165         @TestTargetNew(
 166             level = TestLevel.PARTIAL,
 167             notes = "Stress test.",
 168             method = "getGenericParameterTypes",
 169             args = {}
 170         )
 171     })
 172     @SuppressWarnings("unchecked")
 173     @BrokenTest(value = "fails when run using CTS harness bug 2155700")
 174     public void testMultipleBoundedWildcardUnEquality() throws Exception {
 175         Class<? extends MultipleBoundedWildcardUnEquality> clazz = MultipleBoundedWildcardUnEquality.class;
 176
 177         // new WildcardEquality<Object>().wildcardEquality(new Pair<String,
 178         // Integer>());
 179
 180         Method method = clazz.getDeclaredMethod("multipleBoundedWildcardUnEquality", Pair.class);
 181         TypeVariable<?>[] typeParameters = clazz.getTypeParameters();
 182         assertLenghtOne(typeParameters);
 183         TypeVariable<?> typeParameter = typeParameters[0];
 184         Type[] typeParameterBounds = typeParameter.getBounds();
 185         assertEquals(2, typeParameterBounds.length);
 186         assertEquals(Object.class, typeParameterBounds[0]);
 187         assertInstanceOf(ParameterizedType.class, typeParameterBounds[1]);
 188         ParameterizedType parameterizedType = (ParameterizedType) typeParameterBounds[1];
 189         assertEquals(Comparable.class, parameterizedType.getRawType());
 190         Type[] typeArguments = parameterizedType.getActualTypeArguments();
 191         assertLenghtOne(typeArguments);
 192         assertInstanceOf(ParameterizedType.class, typeArguments[0]);
 193         ParameterizedType type = (ParameterizedType) typeArguments[0];
 194         assertEquals(typeParameter, type.getActualTypeArguments()[0]);
 195         assertEquals(MultipleBoundedWildcardUnEquality.class, type.getRawType());
 196
 197         Type[] parameterTypes = method.getGenericParameterTypes();
 198         assertLenghtOne(parameterTypes);
 199         Type parameter = parameterTypes[0];
 200         assertInstanceOf(ParameterizedType.class, parameter);
 201         ParameterizedType paramType = (ParameterizedType) parameter;
 202         Type[] actualTypeArguments = paramType.getActualTypeArguments();
 203         assertEquals(2, actualTypeArguments.length);
 204
 205         Type firstArgument = actualTypeArguments[0];
 206         assertInstanceOf(WildcardType.class, firstArgument);
 207         WildcardType firstWildcardArgument = (WildcardType) firstArgument;
 208         Type secondArgument = actualTypeArguments[1];
 209         assertInstanceOf(WildcardType.class, secondArgument);
 210         WildcardType secondWildcardArgument = (WildcardType) secondArgument;
 211
 212         assertNotEquals(firstWildcardArgument, secondWildcardArgument);
 213
 214         Type[] firstWildcardArgumentUpperBounds = firstWildcardArgument.getUpperBounds();
 215         assertLenghtOne(firstWildcardArgumentUpperBounds);
 216         Type firstWildcardArgumentUpperBoundsType = firstWildcardArgumentUpperBounds[0];
 217
 218         Type[] secondWildcardArgumentLowerBounds = secondWildcardArgument.getLowerBounds();
 219         assertLenghtOne(secondWildcardArgumentLowerBounds);
 220         Type secondWildcardArgumentLoweroundsType = secondWildcardArgumentLowerBounds[0];
 221
 222         assertEquals(firstWildcardArgumentUpperBoundsType, secondWildcardArgumentLoweroundsType);
 223     }
 224
 225     static class MultipleBoundedWildcardEquality<T extends Object & Comparable<MultipleBoundedWildcardEquality<T>>> {
 226         void multipleBoundedWildcardEquality(Pair<? extends T, ? extends T> param) {}
 227     }
 228     @TestTargets({
 229         @TestTargetNew(
 230             level = TestLevel.PARTIAL,
 231             notes = "Stress test.",
 232             method = "getTypeParameters",
 233             args = {}
 234         ),
 235         @TestTargetNew(
 236             level = TestLevel.PARTIAL,
 237             notes = "Stress test.",
 238             method = "getGenericParameterTypes",
 239             args = {}
 240         )
 241     })
 242     @SuppressWarnings("unchecked")
 243     @BrokenTest(value = "fails when run using CTS harness bug 2155700")
 244     public void testMultipleBoundedWildcard() throws Exception {
 245         Class<? extends MultipleBoundedWildcardEquality> clazz = MultipleBoundedWildcardEquality.class;
 246
 247         Method method = clazz.getDeclaredMethod("multipleBoundedWildcardEquality", Pair.class);
 248         TypeVariable<?>[] typeParameters = clazz.getTypeParameters();
 249         assertLenghtOne(typeParameters);
 250         TypeVariable<?> typeParameter = typeParameters[0];
 251         Type[] typeParameterBounds = typeParameter.getBounds();
 252         assertEquals(2, typeParameterBounds.length);
 253         assertEquals(Object.class, typeParameterBounds[0]);
 254         assertInstanceOf(ParameterizedType.class, typeParameterBounds[1]);
 255         ParameterizedType parameterizedType = (ParameterizedType) typeParameterBounds[1];
 256         assertEquals(Comparable.class, parameterizedType.getRawType());
 257         Type[] typeArguments = parameterizedType.getActualTypeArguments();
 258         assertLenghtOne(typeArguments);
 259         assertInstanceOf(ParameterizedType.class, typeArguments[0]);
 260         ParameterizedType type = (ParameterizedType) typeArguments[0];
 261         assertEquals(typeParameter, type.getActualTypeArguments()[0]);
 262         assertEquals(MultipleBoundedWildcardEquality.class, type.getRawType());
 263
 264         Type[] parameterTypes = method.getGenericParameterTypes();
 265         assertLenghtOne(parameterTypes);
 266         Type parameter = parameterTypes[0];
 267         assertInstanceOf(ParameterizedType.class, parameter);
 268         ParameterizedType paramType = (ParameterizedType) parameter;
 269         Type[] actualTypeArguments = paramType.getActualTypeArguments();
 270         assertEquals(2, actualTypeArguments.length);
 271
 272         Type firstArgument = actualTypeArguments[0];
 273         assertInstanceOf(WildcardType.class, firstArgument);
 274         WildcardType firstWildcardArgument = (WildcardType) firstArgument;
 275         Type secondArgument = actualTypeArguments[1];
 276         assertInstanceOf(WildcardType.class, secondArgument);
 277         WildcardType secondWildcardArgument = (WildcardType) secondArgument;
 278
 279         assertEquals(firstWildcardArgument, secondWildcardArgument);
 280
 281         Type[] firstWildcardArgumentUpperBounds = firstWildcardArgument.getUpperBounds();
 282         assertLenghtOne(firstWildcardArgumentUpperBounds);
 283         Type firstWildcardArgumentUpperBoundsType = firstWildcardArgumentUpperBounds[0];
 284
 285         Type[] secondWildcardArgumentUpperBounds = secondWildcardArgument.getUpperBounds();
 286         assertLenghtOne(secondWildcardArgumentUpperBounds);
 287         Type secondWildcardArgumentLoweroundsType = secondWildcardArgumentUpperBounds[0];
 288
 289         assertEquals(firstWildcardArgumentUpperBoundsType, secondWildcardArgumentLoweroundsType);
 290     }
 291 }