From 08f1be7f85bc148f83b85a2f18d43f9b4e9b2c95 Mon Sep 17 00:00:00 2001 From: Chris Beams Date: Thu, 11 Dec 2008 22:37:31 +0000 Subject: [PATCH] moving unit tests from .testsuite -> .aop --- ...ctJAdviceParameterNameDiscovererTests.java | 41 ++++++++++++++++--- 1 file changed, 36 insertions(+), 5 deletions(-) rename {org.springframework.testsuite => org.springframework.aop}/src/test/java/org/springframework/aop/aspectj/AspectJAdviceParameterNameDiscovererTests.java (96%) diff --git a/org.springframework.testsuite/src/test/java/org/springframework/aop/aspectj/AspectJAdviceParameterNameDiscovererTests.java b/org.springframework.aop/src/test/java/org/springframework/aop/aspectj/AspectJAdviceParameterNameDiscovererTests.java similarity index 96% rename from org.springframework.testsuite/src/test/java/org/springframework/aop/aspectj/AspectJAdviceParameterNameDiscovererTests.java rename to org.springframework.aop/src/test/java/org/springframework/aop/aspectj/AspectJAdviceParameterNameDiscovererTests.java index b061363a1e2..85e26e21083 100644 --- a/org.springframework.testsuite/src/test/java/org/springframework/aop/aspectj/AspectJAdviceParameterNameDiscovererTests.java +++ b/org.springframework.aop/src/test/java/org/springframework/aop/aspectj/AspectJAdviceParameterNameDiscovererTests.java @@ -13,11 +13,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package org.springframework.aop.aspectj; -import junit.framework.TestCase; +import static org.junit.Assert.*; + import org.aspectj.lang.JoinPoint; +import org.junit.Test; import org.springframework.aop.aspectj.AspectJAdviceParameterNameDiscoverer.AmbiguousBindingException; import java.lang.reflect.Method; @@ -30,7 +31,7 @@ import java.lang.reflect.Method; * * @author Adrian Colyer */ -public class AspectJAdviceParameterNameDiscovererTests extends TestCase { +public class AspectJAdviceParameterNameDiscovererTests { // methods to discover parameter names for public void noArgs() { @@ -73,58 +74,71 @@ public class AspectJAdviceParameterNameDiscovererTests extends TestCase { } + @Test public void testNoArgs() { assertParameterNames(getMethod("noArgs"), "execution(* *(..))", new String[0]); } + @Test public void testJoinPointOnly() { assertParameterNames(getMethod("tjp"), "execution(* *(..))", new String[]{"thisJoinPoint"}); } + @Test public void testJoinPointStaticPartOnly() { assertParameterNames(getMethod("tjpsp"), "execution(* *(..))", new String[]{"thisJoinPointStaticPart"}); } + @Test public void testTwoJoinPoints() { assertException(getMethod("twoJoinPoints"), "foo()", IllegalStateException.class, "Failed to bind all argument names: 1 argument(s) could not be bound"); } + @Test public void testOneThrowable() { assertParameterNames(getMethod("oneThrowable"), "foo()", null, "ex", new String[]{"ex"}); } + @Test public void testOneJPAndOneThrowable() { assertParameterNames(getMethod("jpAndOneThrowable"), "foo()", null, "ex", new String[]{"thisJoinPoint", "ex"}); } + @Test public void testOneJPAndTwoThrowables() { assertException(getMethod("jpAndTwoThrowables"), "foo()", null, "ex", AmbiguousBindingException.class, "Binding of throwing parameter 'ex' is ambiguous: could be bound to argument 1 or argument 2"); } + @Test public void testThrowableNoCandidates() { assertException(getMethod("noArgs"), "foo()", null, "ex", IllegalStateException.class, "Not enough arguments in method to satisfy binding of returning and throwing variables"); } + @Test public void testReturning() { assertParameterNames(getMethod("oneObject"), "foo()", "obj", null, new String[]{"obj"}); } + @Test public void testAmbiguousReturning() { assertException(getMethod("twoObjects"), "foo()", "obj", null, AmbiguousBindingException.class, "Binding of returning parameter 'obj' is ambiguous, there are 2 candidates."); } + @Test public void testReturningNoCandidates() { assertException(getMethod("noArgs"), "foo()", "obj", null, IllegalStateException.class, "Not enough arguments in method to satisfy binding of returning and throwing variables"); } + @Test public void testThisBindingOneCandidate() { assertParameterNames(getMethod("oneObject"), "this(x)", new String[]{"x"}); } + @Test public void testThisBindingWithAlternateTokenizations() { assertParameterNames(getMethod("oneObject"), "this( x )", new String[]{"x"}); assertParameterNames(getMethod("oneObject"), "this( x)", new String[]{"x"}); @@ -133,11 +147,13 @@ public class AspectJAdviceParameterNameDiscovererTests extends TestCase { assertParameterNames(getMethod("oneObject"), "foo() && this(x)", new String[]{"x"}); } + @Test public void testThisBindingTwoCandidates() { assertException(getMethod("oneObject"), "this(x) || this(y)", AmbiguousBindingException.class, "Found 2 candidate this(), target() or args() variables but only one unbound argument slot"); } + @Test public void testThisBindingWithBadPointcutExpressions() { assertException(getMethod("oneObject"), "this(", IllegalStateException.class, "Failed to bind all argument names: 1 argument(s) could not be bound"); @@ -145,10 +161,12 @@ public class AspectJAdviceParameterNameDiscovererTests extends TestCase { "Failed to bind all argument names: 1 argument(s) could not be bound"); } + @Test public void testTargetBindingOneCandidate() { assertParameterNames(getMethod("oneObject"), "target(x)", new String[]{"x"}); } + @Test public void testTargetBindingWithAlternateTokenizations() { assertParameterNames(getMethod("oneObject"), "target( x )", new String[]{"x"}); assertParameterNames(getMethod("oneObject"), "target( x)", new String[]{"x"}); @@ -157,11 +175,13 @@ public class AspectJAdviceParameterNameDiscovererTests extends TestCase { assertParameterNames(getMethod("oneObject"), "foo() && target(x)", new String[]{"x"}); } + @Test public void testTargetBindingTwoCandidates() { assertException(getMethod("oneObject"), "target(x) || target(y)", AmbiguousBindingException.class, "Found 2 candidate this(), target() or args() variables but only one unbound argument slot"); } + @Test public void testTargetBindingWithBadPointcutExpressions() { assertException(getMethod("oneObject"), "target(", IllegalStateException.class, "Failed to bind all argument names: 1 argument(s) could not be bound"); @@ -169,49 +189,60 @@ public class AspectJAdviceParameterNameDiscovererTests extends TestCase { "Failed to bind all argument names: 1 argument(s) could not be bound"); } + @Test public void testArgsBindingOneObject() { assertParameterNames(getMethod("oneObject"), "args(x)", new String[]{"x"}); } + @Test public void testArgsBindingOneObjectTwoCandidates() { assertException(getMethod("oneObject"), "args(x,y)", AmbiguousBindingException.class, "Found 2 candidate this(), target() or args() variables but only one unbound argument slot"); } + @Test public void testAmbiguousArgsBinding() { assertException(getMethod("twoObjects"), "args(x,y)", AmbiguousBindingException.class, "Still 2 unbound args at this(),target(),args() binding stage, with no way to determine between them"); } + @Test public void testArgsOnePrimitive() { assertParameterNames(getMethod("onePrimitive"), "args(count)", new String[]{"count"}); } + @Test public void testArgsOnePrimitiveOneObject() { assertException(getMethod("oneObjectOnePrimitive"), "args(count,obj)", AmbiguousBindingException.class, "Found 2 candidate variable names but only one candidate binding slot when matching primitive args"); } + @Test public void testThisAndPrimitive() { assertParameterNames(getMethod("oneObjectOnePrimitive"), "args(count) && this(obj)", new String[]{"obj", "count"}); } + @Test public void testTargetAndPrimitive() { assertParameterNames(getMethod("oneObjectOnePrimitive"), "args(count) && target(obj)", new String[]{"obj", "count"}); } + @Test public void testThrowingAndPrimitive() { assertParameterNames(getMethod("oneThrowableOnePrimitive"), "args(count)", null, "ex", new String[]{"ex", "count"}); } + @Test public void testAllTogetherNow() { assertParameterNames(getMethod("theBigOne"), "this(foo) && args(x)", null, "ex", new String[]{"thisJoinPoint", "ex", "x", "foo"}); } + @Test public void testReferenceBinding() { assertParameterNames(getMethod("onePrimitive"),"somepc(foo)",new String[] {"foo"}); } + @Test public void testReferenceBindingWithAlternateTokenizations() { assertParameterNames(getMethod("onePrimitive"),"call(bar *) && somepc(foo)",new String[] {"foo"}); assertParameterNames(getMethod("onePrimitive"),"somepc ( foo )",new String[] {"foo"}); @@ -261,11 +292,11 @@ public class AspectJAdviceParameterNameDiscovererTests extends TestCase { } } - protected void assertException(Method m, String pointcut, Class exceptionType, String message) { + protected void assertException(Method m, String pointcut, Class exceptionType, String message) { assertException(m, pointcut, null, null, exceptionType, message); } - protected void assertException(Method m, String pointcut, String returning, String throwing, Class exceptionType, String message) { + protected void assertException(Method m, String pointcut, String returning, String throwing, Class exceptionType, String message) { AspectJAdviceParameterNameDiscoverer discoverer = new AspectJAdviceParameterNameDiscoverer(pointcut); discoverer.setRaiseExceptions(true); discoverer.setReturningName(returning);