From d3c64a2b50f3d7c95231b6166ca8b6d72a707842 Mon Sep 17 00:00:00 2001 From: Chris Beams Date: Fri, 12 Dec 2008 00:57:14 +0000 Subject: [PATCH] moving unit tests from .testsuite -> .aop git-svn-id: https://src.springframework.org/svn/spring-framework/trunk@376 50f2f4bb-b051-0410-bef5-90022cba6387 --- .../annotations/EmptySpringAnnotation.java | 15 +++ .../example/annotations/transaction/Tx.java | 31 +++++ .../TigerAspectJExpressionPointcutTests.java | 119 ++++++++++-------- 3 files changed, 115 insertions(+), 50 deletions(-) create mode 100644 org.springframework.aop/src/test/java/example/annotations/EmptySpringAnnotation.java create mode 100644 org.springframework.aop/src/test/java/example/annotations/transaction/Tx.java rename {org.springframework.testsuite => org.springframework.aop}/src/test/java/org/springframework/aop/aspectj/TigerAspectJExpressionPointcutTests.java (68%) diff --git a/org.springframework.aop/src/test/java/example/annotations/EmptySpringAnnotation.java b/org.springframework.aop/src/test/java/example/annotations/EmptySpringAnnotation.java new file mode 100644 index 00000000000..455352c8d13 --- /dev/null +++ b/org.springframework.aop/src/test/java/example/annotations/EmptySpringAnnotation.java @@ -0,0 +1,15 @@ +/** + * + */ +package example.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.TYPE) +public @interface EmptySpringAnnotation { + +} \ No newline at end of file diff --git a/org.springframework.aop/src/test/java/example/annotations/transaction/Tx.java b/org.springframework.aop/src/test/java/example/annotations/transaction/Tx.java new file mode 100644 index 00000000000..31f96df9c63 --- /dev/null +++ b/org.springframework.aop/src/test/java/example/annotations/transaction/Tx.java @@ -0,0 +1,31 @@ +/* + * Copyright 2002-2006 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package example.annotations.transaction; + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target({ElementType.METHOD, ElementType.TYPE}) +@Retention(RetentionPolicy.RUNTIME) +@Inherited +@Documented +public @interface Tx { +} diff --git a/org.springframework.testsuite/src/test/java/org/springframework/aop/aspectj/TigerAspectJExpressionPointcutTests.java b/org.springframework.aop/src/test/java/org/springframework/aop/aspectj/TigerAspectJExpressionPointcutTests.java similarity index 68% rename from org.springframework.testsuite/src/test/java/org/springframework/aop/aspectj/TigerAspectJExpressionPointcutTests.java rename to org.springframework.aop/src/test/java/org/springframework/aop/aspectj/TigerAspectJExpressionPointcutTests.java index 93a5470c3b1..607d68f5e5d 100644 --- a/org.springframework.testsuite/src/test/java/org/springframework/aop/aspectj/TigerAspectJExpressionPointcutTests.java +++ b/org.springframework.aop/src/test/java/org/springframework/aop/aspectj/TigerAspectJExpressionPointcutTests.java @@ -16,12 +16,9 @@ package org.springframework.aop.aspectj; -import static org.junit.Assert.*; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; import java.lang.reflect.Method; import java.util.HashMap; import java.util.List; @@ -30,12 +27,9 @@ import java.util.Map; import org.junit.Before; import org.junit.Test; import org.springframework.beans.TestBean; -import org.springframework.jdbc.core.JdbcTemplate; -import org.springframework.jdbc.core.simple.SimpleJdbcTemplate; -import org.springframework.transaction.annotation.AnnotationTransactionAttributeSourceTests; -import org.springframework.transaction.annotation.AnnotationTransactionAttributeSourceTests.TestBean3; -import org.springframework.transaction.annotation.AnnotationTransactionAttributeSourceTests.TestBean4; -import org.springframework.transaction.annotation.Transactional; + +import example.annotations.EmptySpringAnnotation; +import example.annotations.transaction.Tx; /** * Java5-specific AspectJExpressionPointcutTests. @@ -67,7 +61,7 @@ public class TigerAspectJExpressionPointcutTests { } public void setEnemies(List enemies) { } - public void setPartners(List partners) { + public void setPartners(List partners) { } public void setPhoneNumbers(List numbers) { } @@ -94,6 +88,12 @@ public class TigerAspectJExpressionPointcutTests { @Test public void testMatchVarargs() throws SecurityException, NoSuchMethodException { + class MyTemplate { + public int queryForInt(String sql, Object... params) { + return 0; + } + } + String expression = "execution(int *.*(String, Object...))"; AspectJExpressionPointcut jdbcVarArgs = new AspectJExpressionPointcut(); jdbcVarArgs.setExpression(expression); @@ -104,8 +104,8 @@ public class TigerAspectJExpressionPointcutTests { // JdbcTemplate.class)); assertTrue(jdbcVarArgs.matches( - SimpleJdbcTemplate.class.getMethod("queryForInt", String.class, Object[].class), - SimpleJdbcTemplate.class)); + MyTemplate.class.getMethod("queryForInt", String.class, Object[].class), + MyTemplate.class)); Method takesGenericList = methodsOnHasGeneric.get("setFriends"); assertFalse(jdbcVarArgs.matches(takesGenericList, HasGeneric.class)); @@ -117,26 +117,26 @@ public class TigerAspectJExpressionPointcutTests { @Test public void testMatchAnnotationOnClassWithAtWithin() throws SecurityException, NoSuchMethodException { - String expression = "@within(org.springframework.transaction.annotation.Transactional)"; + String expression = "@within(example.annotations.transaction.Tx)"; testMatchAnnotationOnClass(expression); } @Test public void testMatchAnnotationOnClassWithoutBinding() throws SecurityException, NoSuchMethodException { - String expression = "within(@org.springframework.transaction.annotation.Transactional *)"; + String expression = "within(@example.annotations.transaction.Tx *)"; testMatchAnnotationOnClass(expression); } @Test public void testMatchAnnotationOnClassWithSubpackageWildcard() throws SecurityException, NoSuchMethodException { - String expression = "within(@(org.springframework..*) *)"; + String expression = "within(@(example.annotations..*) *)"; AspectJExpressionPointcut springAnnotatedPc = testMatchAnnotationOnClass(expression); assertFalse(springAnnotatedPc.matches(TestBean.class.getMethod("setName", String.class), TestBean.class)); assertTrue(springAnnotatedPc.matches(SpringAnnotated.class.getMethod("foo", (Class[]) null), SpringAnnotated.class)); - expression = "within(@(org.springframework.transaction..*) *)"; + expression = "within(@(example.annotations.transaction..*) *)"; AspectJExpressionPointcut springTxAnnotatedPc = testMatchAnnotationOnClass(expression); assertFalse(springTxAnnotatedPc.matches(SpringAnnotated.class.getMethod("foo", (Class[]) null), SpringAnnotated.class)); @@ -144,7 +144,7 @@ public class TigerAspectJExpressionPointcutTests { @Test public void testMatchAnnotationOnClassWithExactPackageWildcard() throws SecurityException, NoSuchMethodException { - String expression = "within(@(org.springframework.transaction.annotation.*) *)"; + String expression = "within(@(example.annotations.transaction.*) *)"; testMatchAnnotationOnClass(expression); } @@ -155,51 +155,51 @@ public class TigerAspectJExpressionPointcutTests { assertFalse(ajexp.matches(getAge, TestBean.class)); assertTrue(ajexp.matches(HasTransactionalAnnotation.class.getMethod("foo", (Class[]) null), HasTransactionalAnnotation.class)); assertTrue(ajexp.matches(HasTransactionalAnnotation.class.getMethod("bar", String.class), HasTransactionalAnnotation.class)); - assertTrue(ajexp.matches(AnnotationTransactionAttributeSourceTests.TestBean4.class.getMethod("setName", String.class), TestBean4.class)); - assertFalse(ajexp.matches(AnnotationTransactionAttributeSourceTests.TestBean3.class.getMethod("setName", String.class), TestBean3.class)); + assertTrue(ajexp.matches(BeanB.class.getMethod("setName", String.class), BeanB.class)); + assertFalse(ajexp.matches(BeanA.class.getMethod("setName", String.class), BeanA.class)); return ajexp; } @Test public void testAnnotationOnMethodWithFQN() throws SecurityException, NoSuchMethodException { - String expression = "@annotation(org.springframework.transaction.annotation.Transactional)"; + String expression = "@annotation(example.annotations.transaction.Tx)"; AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut(); ajexp.setExpression(expression); assertFalse(ajexp.matches(getAge, TestBean.class)); assertFalse(ajexp.matches(HasTransactionalAnnotation.class.getMethod("foo", (Class[]) null), HasTransactionalAnnotation.class)); assertFalse(ajexp.matches(HasTransactionalAnnotation.class.getMethod("bar", String.class), HasTransactionalAnnotation.class)); - assertFalse(ajexp.matches(AnnotationTransactionAttributeSourceTests.TestBean3.class.getMethod("setName", String.class), TestBean3.class)); - assertTrue(ajexp.matches(AnnotationTransactionAttributeSourceTests.TestBean3.class.getMethod("getAge", (Class[]) null), TestBean3.class)); - assertFalse(ajexp.matches(AnnotationTransactionAttributeSourceTests.TestBean3.class.getMethod("setName", String.class), TestBean3.class)); + assertFalse(ajexp.matches(BeanA.class.getMethod("setName", String.class), BeanA.class)); + assertTrue(ajexp.matches(BeanA.class.getMethod("getAge", (Class[]) null), BeanA.class)); + assertFalse(ajexp.matches(BeanA.class.getMethod("setName", String.class), BeanA.class)); } @Test public void testAnnotationOnMethodWithWildcard() throws SecurityException, NoSuchMethodException { - String expression = "execution(@(org.springframework..*) * *(..))"; + String expression = "execution(@(example.annotations..*) * *(..))"; AspectJExpressionPointcut anySpringMethodAnnotation = new AspectJExpressionPointcut(); anySpringMethodAnnotation.setExpression(expression); assertFalse(anySpringMethodAnnotation.matches(getAge, TestBean.class)); assertFalse(anySpringMethodAnnotation.matches(HasTransactionalAnnotation.class.getMethod("foo", (Class[]) null), HasTransactionalAnnotation.class)); assertFalse(anySpringMethodAnnotation.matches(HasTransactionalAnnotation.class.getMethod("bar", String.class), HasTransactionalAnnotation.class)); - assertFalse(anySpringMethodAnnotation.matches(AnnotationTransactionAttributeSourceTests.TestBean3.class.getMethod("setName", String.class), TestBean3.class)); - assertTrue(anySpringMethodAnnotation.matches(AnnotationTransactionAttributeSourceTests.TestBean3.class.getMethod("getAge", (Class[]) null), TestBean3.class)); - assertFalse(anySpringMethodAnnotation.matches(AnnotationTransactionAttributeSourceTests.TestBean3.class.getMethod("setName", String.class), TestBean3.class)); + assertFalse(anySpringMethodAnnotation.matches(BeanA.class.getMethod("setName", String.class), BeanA.class)); + assertTrue(anySpringMethodAnnotation.matches(BeanA.class.getMethod("getAge", (Class[]) null), BeanA.class)); + assertFalse(anySpringMethodAnnotation.matches(BeanA.class.getMethod("setName", String.class), BeanA.class)); } @Test public void testAnnotationOnMethodArgumentsWithFQN() throws SecurityException, NoSuchMethodException { - String expression = "@args(*, org.springframework.aop.aspectj.TigerAspectJExpressionPointcutTests.EmptySpringAnnotation))"; + String expression = "@args(*, example.annotations.EmptySpringAnnotation))"; AspectJExpressionPointcut takesSpringAnnotatedArgument2 = new AspectJExpressionPointcut(); takesSpringAnnotatedArgument2.setExpression(expression); assertFalse(takesSpringAnnotatedArgument2.matches(getAge, TestBean.class)); assertFalse(takesSpringAnnotatedArgument2.matches(HasTransactionalAnnotation.class.getMethod("foo", (Class[]) null), HasTransactionalAnnotation.class)); assertFalse(takesSpringAnnotatedArgument2.matches(HasTransactionalAnnotation.class.getMethod("bar", String.class), HasTransactionalAnnotation.class)); - assertFalse(takesSpringAnnotatedArgument2.matches(AnnotationTransactionAttributeSourceTests.TestBean3.class.getMethod("setName", String.class), TestBean3.class)); - assertFalse(takesSpringAnnotatedArgument2.matches(AnnotationTransactionAttributeSourceTests.TestBean3.class.getMethod("getAge", (Class[]) null), TestBean3.class)); - assertFalse(takesSpringAnnotatedArgument2.matches(AnnotationTransactionAttributeSourceTests.TestBean3.class.getMethod("setName", String.class), TestBean3.class)); + assertFalse(takesSpringAnnotatedArgument2.matches(BeanA.class.getMethod("setName", String.class), BeanA.class)); + assertFalse(takesSpringAnnotatedArgument2.matches(BeanA.class.getMethod("getAge", (Class[]) null), BeanA.class)); + assertFalse(takesSpringAnnotatedArgument2.matches(BeanA.class.getMethod("setName", String.class), BeanA.class)); assertTrue(takesSpringAnnotatedArgument2.matches( ProcessesSpringAnnotatedParameters.class.getMethod("takesAnnotatedParameters", TestBean.class, SpringAnnotated.class), @@ -207,34 +207,34 @@ public class TigerAspectJExpressionPointcutTests { // True because it maybeMatches with potential argument subtypes assertTrue(takesSpringAnnotatedArgument2.matches( - ProcessesSpringAnnotatedParameters.class.getMethod("takesNoAnnotatedParameters", TestBean.class, TestBean3.class), + ProcessesSpringAnnotatedParameters.class.getMethod("takesNoAnnotatedParameters", TestBean.class, BeanA.class), ProcessesSpringAnnotatedParameters.class)); assertFalse(takesSpringAnnotatedArgument2.matches( - ProcessesSpringAnnotatedParameters.class.getMethod("takesNoAnnotatedParameters", TestBean.class, TestBean3.class), + ProcessesSpringAnnotatedParameters.class.getMethod("takesNoAnnotatedParameters", TestBean.class, BeanA.class), ProcessesSpringAnnotatedParameters.class, - new Object[] { new TestBean(), new TestBean3()}) + new Object[] { new TestBean(), new BeanA()}) ); } @Test public void testAnnotationOnMethodArgumentsWithWildcards() throws SecurityException, NoSuchMethodException { - String expression = "execution(* *(*, @(org.springframework..*) *))"; + String expression = "execution(* *(*, @(example..*) *))"; AspectJExpressionPointcut takesSpringAnnotatedArgument2 = new AspectJExpressionPointcut(); takesSpringAnnotatedArgument2.setExpression(expression); assertFalse(takesSpringAnnotatedArgument2.matches(getAge, TestBean.class)); assertFalse(takesSpringAnnotatedArgument2.matches(HasTransactionalAnnotation.class.getMethod("foo", (Class[]) null), HasTransactionalAnnotation.class)); assertFalse(takesSpringAnnotatedArgument2.matches(HasTransactionalAnnotation.class.getMethod("bar", String.class), HasTransactionalAnnotation.class)); - assertFalse(takesSpringAnnotatedArgument2.matches(AnnotationTransactionAttributeSourceTests.TestBean3.class.getMethod("setName", String.class), TestBean3.class)); - assertFalse(takesSpringAnnotatedArgument2.matches(AnnotationTransactionAttributeSourceTests.TestBean3.class.getMethod("getAge", (Class[]) null), TestBean3.class)); - assertFalse(takesSpringAnnotatedArgument2.matches(AnnotationTransactionAttributeSourceTests.TestBean3.class.getMethod("setName", String.class), TestBean3.class)); + assertFalse(takesSpringAnnotatedArgument2.matches(BeanA.class.getMethod("setName", String.class), BeanA.class)); + assertFalse(takesSpringAnnotatedArgument2.matches(BeanA.class.getMethod("getAge", (Class[]) null), BeanA.class)); + assertFalse(takesSpringAnnotatedArgument2.matches(BeanA.class.getMethod("setName", String.class), BeanA.class)); assertTrue(takesSpringAnnotatedArgument2.matches( ProcessesSpringAnnotatedParameters.class.getMethod("takesAnnotatedParameters", TestBean.class, SpringAnnotated.class), ProcessesSpringAnnotatedParameters.class)); assertFalse(takesSpringAnnotatedArgument2.matches( - ProcessesSpringAnnotatedParameters.class.getMethod("takesNoAnnotatedParameters", TestBean.class, TestBean3.class), + ProcessesSpringAnnotatedParameters.class.getMethod("takesNoAnnotatedParameters", TestBean.class, BeanA.class), ProcessesSpringAnnotatedParameters.class)); } @@ -244,12 +244,12 @@ public class TigerAspectJExpressionPointcutTests { public void takesAnnotatedParameters(TestBean tb, SpringAnnotated sa) { } - public void takesNoAnnotatedParameters(TestBean tb, TestBean3 tb3) { + public void takesNoAnnotatedParameters(TestBean tb, BeanA tb3) { } } - @Transactional + @Tx public static class HasTransactionalAnnotation { public void foo() { @@ -260,17 +260,36 @@ public class TigerAspectJExpressionPointcutTests { } - @Retention(RetentionPolicy.RUNTIME) - @Target(ElementType.TYPE) - public @interface EmptySpringAnnotation { - - } - - @EmptySpringAnnotation public static class SpringAnnotated { public void foo() { } } + + static class BeanA { + private String name; + + private int age; + + public void setName(String name) { + this.name = name; + } + + @Tx + public int getAge() { + return age; + } + } + + + @Tx + static class BeanB { + private String name; + + public void setName(String name) { + this.name = name; + } + } + }