moving unit tests from .testsuite -> .aop

git-svn-id: https://src.springframework.org/svn/spring-framework/trunk@369 50f2f4bb-b051-0410-bef5-90022cba6387

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);