From 1a0a381559822a3707b9cb6ca8782e0dc8e13f45 Mon Sep 17 00:00:00 2001 From: Juergen Hoeller Date: Sun, 5 Jan 2014 02:30:04 +0100 Subject: [PATCH] Made findMethodAnnotationOnBridgeMethod compatible with Java 8 --- .../core/annotation/AnnotationUtilsTests.java | 90 ++++++++----------- 1 file changed, 37 insertions(+), 53 deletions(-) diff --git a/spring-core/src/test/java/org/springframework/core/annotation/AnnotationUtilsTests.java b/spring-core/src/test/java/org/springframework/core/annotation/AnnotationUtilsTests.java index 9f7e76b0c92..d4b6d5ee905 100644 --- a/spring-core/src/test/java/org/springframework/core/annotation/AnnotationUtilsTests.java +++ b/spring-core/src/test/java/org/springframework/core/annotation/AnnotationUtilsTests.java @@ -16,15 +16,11 @@ package org.springframework.core.annotation; -import static org.junit.Assert.*; -import static org.springframework.core.annotation.AnnotationUtils.*; - import java.lang.annotation.Annotation; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.reflect.Method; - import java.util.Arrays; import java.util.List; @@ -33,6 +29,9 @@ import org.junit.Test; import org.springframework.core.Ordered; import org.springframework.stereotype.Component; +import static org.junit.Assert.*; +import static org.springframework.core.annotation.AnnotationUtils.*; + /** * Unit tests for {@link AnnotationUtils}. * @@ -44,54 +43,49 @@ import org.springframework.stereotype.Component; public class AnnotationUtilsTests { @Test - public void testFindMethodAnnotationOnLeaf() throws SecurityException, NoSuchMethodException { - - final Method m = Leaf.class.getMethod("annotatedOnLeaf", (Class[]) null); + public void findMethodAnnotationOnLeaf() throws Exception { + Method m = Leaf.class.getMethod("annotatedOnLeaf", (Class[]) null); assertNotNull(m.getAnnotation(Order.class)); assertNotNull(getAnnotation(m, Order.class)); assertNotNull(findAnnotation(m, Order.class)); } @Test - public void testFindMethodAnnotationOnRoot() throws SecurityException, NoSuchMethodException { - - final Method m = Leaf.class.getMethod("annotatedOnRoot", (Class[]) null); + public void findMethodAnnotationOnRoot() throws Exception { + Method m = Leaf.class.getMethod("annotatedOnRoot", (Class[]) null); assertNotNull(m.getAnnotation(Order.class)); assertNotNull(getAnnotation(m, Order.class)); assertNotNull(findAnnotation(m, Order.class)); } @Test - public void testFindMethodAnnotationOnRootButOverridden() throws SecurityException, NoSuchMethodException { - - final Method m = Leaf.class.getMethod("overrideWithoutNewAnnotation", (Class[]) null); + public void findMethodAnnotationOnRootButOverridden() throws Exception { + Method m = Leaf.class.getMethod("overrideWithoutNewAnnotation", (Class[]) null); assertNull(m.getAnnotation(Order.class)); assertNull(getAnnotation(m, Order.class)); assertNotNull(findAnnotation(m, Order.class)); } @Test - public void testFindMethodAnnotationNotAnnotated() throws SecurityException, NoSuchMethodException { - - final Method m = Leaf.class.getMethod("notAnnotated", (Class[]) null); + public void findMethodAnnotationNotAnnotated() throws Exception { + Method m = Leaf.class.getMethod("notAnnotated", (Class[]) null); assertNull(findAnnotation(m, Order.class)); } @Test - public void testFindMethodAnnotationOnBridgeMethod() throws Exception { - - final Method m = SimpleFoo.class.getMethod("something", Object.class); + public void findMethodAnnotationOnBridgeMethod() throws Exception { + Method m = SimpleFoo.class.getMethod("something", Object.class); assertTrue(m.isBridge()); assertNull(m.getAnnotation(Order.class)); assertNull(getAnnotation(m, Order.class)); assertNotNull(findAnnotation(m, Order.class)); - assertNull(m.getAnnotation(Transactional.class)); + // TODO: actually found on OpenJDK 8 b99! assertNull(m.getAnnotation(Transactional.class)); assertNotNull(getAnnotation(m, Transactional.class)); assertNotNull(findAnnotation(m, Transactional.class)); } // TODO consider whether we want this to handle annotations on interfaces - // public void testFindMethodAnnotationFromInterfaceImplementedByRoot() + // public void findMethodAnnotationFromInterfaceImplementedByRoot() // throws Exception { // Method m = Leaf.class.getMethod("fromInterfaceImplementedByRoot", // (Class[]) null); @@ -101,7 +95,6 @@ public class AnnotationUtilsTests { @Test public void testFindAnnotationDeclaringClass() throws Exception { - // no class-level annotation assertNull(findAnnotationDeclaringClass(Transactional.class, NonAnnotatedInterface.class)); assertNull(findAnnotationDeclaringClass(Transactional.class, NonAnnotatedClass.class)); @@ -128,7 +121,6 @@ public class AnnotationUtilsTests { @Test public void findAnnotationDeclaringClassForTypesWithSingleCandidateType() { - // no class-level annotation List> transactionalCandidateList = Arrays.> asList(Transactional.class); assertNull(findAnnotationDeclaringClassForTypes(transactionalCandidateList, NonAnnotatedInterface.class)); @@ -137,8 +129,7 @@ public class AnnotationUtilsTests { // inherited class-level annotation; note: @Transactional is inherited assertEquals(InheritedAnnotationInterface.class, findAnnotationDeclaringClassForTypes(transactionalCandidateList, InheritedAnnotationInterface.class)); - assertNull(findAnnotationDeclaringClassForTypes(transactionalCandidateList, - SubInheritedAnnotationInterface.class)); + assertNull(findAnnotationDeclaringClassForTypes(transactionalCandidateList, SubInheritedAnnotationInterface.class)); assertEquals(InheritedAnnotationClass.class, findAnnotationDeclaringClassForTypes(transactionalCandidateList, InheritedAnnotationClass.class)); assertEquals(InheritedAnnotationClass.class, @@ -158,9 +149,7 @@ public class AnnotationUtilsTests { @Test public void findAnnotationDeclaringClassForTypesWithMultipleCandidateTypes() { - - List> candidates = Arrays.> asList(Transactional.class, - Order.class); + List> candidates = Arrays.> asList(Transactional.class, Order.class); // no class-level annotation assertNull(findAnnotationDeclaringClassForTypes(candidates, NonAnnotatedInterface.class)); @@ -196,7 +185,6 @@ public class AnnotationUtilsTests { @Test public void testIsAnnotationDeclaredLocally() throws Exception { - // no class-level annotation assertFalse(isAnnotationDeclaredLocally(Transactional.class, NonAnnotatedInterface.class)); assertFalse(isAnnotationDeclaredLocally(Transactional.class, NonAnnotatedClass.class)); @@ -216,7 +204,6 @@ public class AnnotationUtilsTests { @Test public void testIsAnnotationInherited() throws Exception { - // no class-level annotation assertFalse(isAnnotationInherited(Transactional.class, NonAnnotatedInterface.class)); assertFalse(isAnnotationInherited(Transactional.class, NonAnnotatedClass.class)); @@ -238,51 +225,48 @@ public class AnnotationUtilsTests { } @Test - public void testGetValueFromAnnotation() throws Exception { - - final Method method = SimpleFoo.class.getMethod("something", Object.class); - final Order order = findAnnotation(method, Order.class); + public void getValueFromAnnotation() throws Exception { + Method method = SimpleFoo.class.getMethod("something", Object.class); + Order order = findAnnotation(method, Order.class); assertEquals(1, AnnotationUtils.getValue(order, AnnotationUtils.VALUE)); assertEquals(1, AnnotationUtils.getValue(order)); } @Test - public void testGetDefaultValueFromAnnotation() throws Exception { - - final Method method = SimpleFoo.class.getMethod("something", Object.class); - final Order order = findAnnotation(method, Order.class); + public void getValueFromNonPublicAnnotation() throws Exception { + Method method = SimpleFoo.class.getMethod("something", Object.class); + Order order = findAnnotation(method, Order.class); assertEquals(Ordered.LOWEST_PRECEDENCE, AnnotationUtils.getDefaultValue(order, AnnotationUtils.VALUE)); assertEquals(Ordered.LOWEST_PRECEDENCE, AnnotationUtils.getDefaultValue(order)); } @Test - public void testGetDefaultValueFromAnnotationType() throws Exception { + public void getDefaultValueFromAnnotation() throws Exception { + Method method = SimpleFoo.class.getMethod("something", Object.class); + Order order = findAnnotation(method, Order.class); - assertEquals(Ordered.LOWEST_PRECEDENCE, AnnotationUtils.getDefaultValue(Order.class, AnnotationUtils.VALUE)); - assertEquals(Ordered.LOWEST_PRECEDENCE, AnnotationUtils.getDefaultValue(Order.class)); + assertEquals(Ordered.LOWEST_PRECEDENCE, AnnotationUtils.getDefaultValue(order, AnnotationUtils.VALUE)); + assertEquals(Ordered.LOWEST_PRECEDENCE, AnnotationUtils.getDefaultValue(order)); } @Test - public void testFindAnnotationFromInterface() throws Exception { - + public void getDefaultValueFromNonPublicAnnotation() throws Exception { Method method = ImplementsInterfaceWithAnnotatedMethod.class.getMethod("foo"); Order order = findAnnotation(method, Order.class); assertNotNull(order); } @Test - public void testFindAnnotationFromInterfaceOnSuper() throws Exception { - + public void findAnnotationFromInterfaceOnSuper() throws Exception { Method method = SubOfImplementsInterfaceWithAnnotatedMethod.class.getMethod("foo"); Order order = findAnnotation(method, Order.class); assertNotNull(order); } @Test - public void testFindAnnotationFromInterfaceWhenSuperDoesNotImplementMethod() throws Exception { - + public void findAnnotationFromInterfaceWhenSuperDoesNotImplementMethod() throws Exception { Method method = SubOfAbstractImplementsInterfaceWithAnnotatedMethod.class.getMethod("foo"); Order order = findAnnotation(method, Order.class); assertNotNull(order); @@ -356,6 +340,12 @@ public class AnnotationUtilsTests { } } + @Retention(RetentionPolicy.RUNTIME) + @Inherited + @interface Transactional { + + } + public static abstract class Foo { @Order(1) @@ -449,9 +439,3 @@ public class AnnotationUtilsTests { } } - -@Retention(RetentionPolicy.RUNTIME) -@Inherited -@interface Transactional { - -}