From 83fe1bfaa5f5bb25518c5d9c723978b497891d89 Mon Sep 17 00:00:00 2001 From: darcy Date: Tue, 6 Sep 2011 21:19:31 -0700 Subject: [PATCH] 7086192: (reflect) Have TypeVariable extend AnnotatedElement Reviewed-by: mcimadamore --- .../java/lang/reflect/TypeVariable.java | 2 +- .../reflectiveObjects/TypeVariableImpl.java | 25 ++++++ .../TypeVariable/TestAnnotatedElement.java | 88 +++++++++++++++++++ 3 files changed, 114 insertions(+), 1 deletion(-) create mode 100644 test/java/lang/reflect/TypeVariable/TestAnnotatedElement.java diff --git a/src/share/classes/java/lang/reflect/TypeVariable.java b/src/share/classes/java/lang/reflect/TypeVariable.java index 4c5d3deaf..b55a99f01 100644 --- a/src/share/classes/java/lang/reflect/TypeVariable.java +++ b/src/share/classes/java/lang/reflect/TypeVariable.java @@ -48,7 +48,7 @@ package java.lang.reflect; * * @since 1.5 */ -public interface TypeVariable extends Type { +public interface TypeVariable extends Type, AnnotatedElement { /** * Returns an array of {@code Type} objects representing the * upper bound(s) of this type variable. Note that if no upper bound is diff --git a/src/share/classes/sun/reflect/generics/reflectiveObjects/TypeVariableImpl.java b/src/share/classes/sun/reflect/generics/reflectiveObjects/TypeVariableImpl.java index 20f94755b..5eab5e8ed 100644 --- a/src/share/classes/sun/reflect/generics/reflectiveObjects/TypeVariableImpl.java +++ b/src/share/classes/sun/reflect/generics/reflectiveObjects/TypeVariableImpl.java @@ -25,9 +25,11 @@ package sun.reflect.generics.reflectiveObjects; +import java.lang.annotation.Annotation; import java.lang.reflect.GenericDeclaration; import java.lang.reflect.Type; import java.lang.reflect.TypeVariable; +import java.util.Objects; import sun.reflect.generics.factory.GenericsFactory; import sun.reflect.generics.tree.FieldTypeSignature; @@ -178,4 +180,27 @@ public class TypeVariableImpl public int hashCode() { return genericDeclaration.hashCode() ^ name.hashCode(); } + + // Currently vacuous implementations of AnnotatedElement methods. + public boolean isAnnotationPresent(Class annotationClass) { + Objects.requireNonNull(annotationClass); + return false; + } + + public T getAnnotation(Class annotationClass) { + Objects.requireNonNull(annotationClass); + return null; + } + + public Annotation[] getAnnotations() { + // Since zero-length, don't need defensive clone + return EMPTY_ANNOTATION_ARRAY; + } + + public Annotation[] getDeclaredAnnotations() { + // Since zero-length, don't need defensive clone + return EMPTY_ANNOTATION_ARRAY; + } + + private static final Annotation[] EMPTY_ANNOTATION_ARRAY = new Annotation[0]; } diff --git a/test/java/lang/reflect/TypeVariable/TestAnnotatedElement.java b/test/java/lang/reflect/TypeVariable/TestAnnotatedElement.java new file mode 100644 index 000000000..94f8d459c --- /dev/null +++ b/test/java/lang/reflect/TypeVariable/TestAnnotatedElement.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 7086192 + * @summary Verify functionality of AnnotatedElement methods on type variables + * @author Joseph D. Darcy + */ + +import java.lang.reflect.*; +import java.lang.annotation.*; + +public class TestAnnotatedElement { + // Type variable on a method + private static B m(B b) {return null;} + + // Type variable on a construtor + private TestAnnotatedElement(){super();} + + public static void main(String... argv) throws ReflectiveOperationException { + int errors = 0; + + Class clazz = TestAnnotatedElement.class; + errors += testTypeVariable(clazz.getTypeParameters()); + errors += testTypeVariable(clazz.getDeclaredConstructor().getTypeParameters()); + errors += testTypeVariable(clazz.getDeclaredMethod("m", Object.class).getTypeParameters()); + + if (errors > 0) + throw new RuntimeException(errors + " failures"); + } + + + private static int testTypeVariable(TypeVariable[] typeVars) { + int errors = 0; + if (typeVars.length == 0) + return ++errors; + + for(TypeVariable typeVar : typeVars) { + try { + typeVar.getAnnotation(null); + errors++; + } catch(NullPointerException npe) { + ; // Expected + } + + if (typeVar.getAnnotation(SuppressWarnings.class) != null) + errors++; + + try { + typeVar.isAnnotationPresent(null); + errors++; + } catch(NullPointerException npe) { + ; // Expected + } + + if (typeVar.isAnnotationPresent(SuppressWarnings.class)) + errors++; + + if(typeVar.getAnnotations().length != 0) + errors++; + + if(typeVar.getDeclaredAnnotations().length != 0) + errors++; + } + return errors; + } +} -- GitLab