}
	
	
	@Aspect
	public static class ManyValuedArgs {
		public String mungeArgs(String a, int b, int c, String d, StringBuffer e) {
			return a + b + c + d + e;
		}
		
		@Around(value="execution(String mungeArgs(..)) && args(a, b, c, d, e)",
				argNames="b,c,d,e,a")
		public String reverseAdvice(ProceedingJoinPoint pjp, int b, int c, String d, StringBuffer e, String a) throws Throwable {
			assertEquals(a + b+ c+ d+ e, pjp.proceed());
			return a + b + c + d + e;
		}
	}
	
	public void testBindingWithMultipleArgsDifferentlyOrdered() {
		ManyValuedArgs target = new ManyValuedArgs();
		ManyValuedArgs mva = (ManyValuedArgs) createProxy(target, 
				getFixture().getAdvisors(new SingletonMetadataAwareAspectInstanceFactory(new ManyValuedArgs(),"someBean")), 
				ManyValuedArgs.class);
		
		String a = "a";
		int b = 12;
		int c = 25;
		String d = "d";
		StringBuffer e = new StringBuffer("stringbuf");
		String expectedResult = a + b+ c + d + e;
		assertEquals(expectedResult, mva.mungeArgs(a, b, c, d, e));
	}
	
	/**
	 * In this case the introduction will be made.
	 */
	public void testIntroductionOnTargetNotImplementingInterface() {
		NotLockable notLockableTarget = new NotLockable();
		assertFalse(notLockableTarget instanceof Lockable);
		NotLockable notLockable1 = (NotLockable) createProxy(notLockableTarget,
				getFixture().getAdvisors(
						new SingletonMetadataAwareAspectInstanceFactory(new MakeLockable(),"someBean")),
				NotLockable.class);
		assertTrue(notLockable1 instanceof Lockable);
		Lockable lockable = (Lockable) notLockable1;
		assertFalse(lockable.locked());
		lockable.lock();
		assertTrue(lockable.locked());
		
		NotLockable notLockable2Target = new NotLockable();
		NotLockable notLockable2 = (NotLockable) createProxy(notLockable2Target,
				getFixture().getAdvisors(
						new SingletonMetadataAwareAspectInstanceFactory(new MakeLockable(),"someBean")),
				NotLockable.class);
		assertTrue(notLockable2 instanceof Lockable);
		Lockable lockable2 = (Lockable) notLockable2;
		assertFalse(lockable2.locked());
		notLockable2.setIntValue(1);
		lockable2.lock();
		try {
			notLockable2.setIntValue(32);
			fail();
		}
		catch (IllegalStateException ex) {
		}
		assertTrue(lockable2.locked());
	}
	
	public void testIntroductionAdvisorExcludedFromTargetImplementingInterface() {
		assertTrue(AopUtils.findAdvisorsThatCanApply(
						getFixture().getAdvisors(
									new SingletonMetadataAwareAspectInstanceFactory(
											new MakeLockable(),"someBean")), 
						CannotBeUnlocked.class).isEmpty());
		assertEquals(2, AopUtils.findAdvisorsThatCanApply(getFixture().getAdvisors(new SingletonMetadataAwareAspectInstanceFactory(new MakeLockable(),"someBean")), NotLockable.class).size());
	}
	
	@SuppressWarnings("unchecked")
	public void testIntroductionOnTargetImplementingInterface() {
		CannotBeUnlocked target = new CannotBeUnlocked();
		Lockable proxy = (Lockable) createProxy(target,
				// Ensure that we exclude
				AopUtils.findAdvisorsThatCanApply(
						getFixture().getAdvisors(
								new SingletonMetadataAwareAspectInstanceFactory(new MakeLockable(),"someBean")),
						CannotBeUnlocked.class
				),
				CannotBeUnlocked.class);
		assertTrue(proxy instanceof Lockable);
		Lockable lockable = (Lockable) proxy;
		assertTrue("Already locked", lockable.locked());
		lockable.lock();
		assertTrue("Real target ignores locking", lockable.locked());
		try {
			lockable.unlock();
			fail();
		}
		catch (UnsupportedOperationException ex) {
			// Ok
		}
	}
	
	@SuppressWarnings("unchecked")
	public void testIntroductionOnTargetExcludedByTypePattern() {
		LinkedList target = new LinkedList();
		List proxy = (List) createProxy(target,
				AopUtils.findAdvisorsThatCanApply(
						getFixture().getAdvisors(new SingletonMetadataAwareAspectInstanceFactory(new MakeLockable(),"someBean")),
						List.class
				),
				CannotBeUnlocked.class);
		assertFalse("Type pattern must have excluded mixin", proxy instanceof Lockable);
	}

	// TODO: Why does this test fail? It hasn't been run before, so it maybe never actually passed...
	public void XtestIntroductionWithArgumentBinding() {
		TestBean target = new TestBean();
		
		List<Advisor> advisors = getFixture().getAdvisors(
				new SingletonMetadataAwareAspectInstanceFactory(new MakeITestBeanModifiable(),"someBean"));
		advisors.addAll(getFixture().getAdvisors(
				new SingletonMetadataAwareAspectInstanceFactory(new MakeLockable(),"someBean")));
		
		Modifiable modifiable = (Modifiable) createProxy(target,
				advisors,
				ITestBean.class);
		assertTrue(modifiable instanceof Modifiable);
		Lockable lockable = (Lockable) modifiable;
		assertFalse(lockable.locked());
		
		ITestBean itb = (ITestBean) modifiable;
		assertFalse(modifiable.isModified());
		int oldAge = itb.getAge();
		itb.setAge(oldAge + 1);
		assertTrue(modifiable.isModified());
		modifiable.acceptChanges();
		assertFalse(modifiable.isModified());
		itb.setAge(itb.getAge());
		assertFalse("Setting same value does not modify", modifiable.isModified());
		itb.setName("And now for something completely different");
		assertTrue(modifiable.isModified());
		
		lockable.lock();
		assertTrue(lockable.locked());
		try {
			itb.setName("Else");
			fail("Should be locked");
		}
		catch (IllegalStateException ex) {
			// Ok
		}
		lockable.unlock();
		itb.setName("Tony");
	}
	
	@Aspect
	public static class ExceptionAspect {
		private final Exception ex;
		
		public ExceptionAspect(Exception ex) {
			this.ex = ex;
		}
		
		@Before("execution(* getAge())")		
		public void throwException() throws Exception {
			throw ex;
		}
	}
		
	public void testAspectMethodThrowsExceptionLegalOnSignature() {
		TestBean target = new TestBean();
		UnsupportedOperationException expectedException = new UnsupportedOperationException();
		List<Advisor> advisors = getFixture().getAdvisors(new SingletonMetadataAwareAspectInstanceFactory(new ExceptionAspect(expectedException),"someBean"));
		assertEquals("One advice method was found", 1, advisors.size());
		ITestBean itb = (ITestBean) createProxy(target, 
				advisors, 
				ITestBean.class);
		try {
			itb.getAge();
			fail();
		}
		catch (UnsupportedOperationException ex) {
			assertSame(expectedException, ex);
		}
	}
	
	// TODO document this behaviour.
	// Is it different AspectJ behaviour, at least for checked exceptions?
	public void testAspectMethodThrowsExceptionIllegalOnSignature() {
		TestBean target = new TestBean();
		RemoteException expectedException = new RemoteException();
		List<Advisor> advisors = getFixture().getAdvisors(new SingletonMetadataAwareAspectInstanceFactory(new ExceptionAspect(expectedException),"someBean"));
		assertEquals("One advice method was found", 1, advisors.size());
		ITestBean itb = (ITestBean) createProxy(target, 
				advisors, 
				ITestBean.class);
		try {
			itb.getAge();
			fail();
		}
		catch (UndeclaredThrowableException ex) {
			assertSame(expectedException, ex.getCause());
		}
	}
	
	protected Object createProxy(Object target, List<Advisor> advisors, Class ... interfaces) {
		ProxyFactory pf = new ProxyFactory(target);
		if (interfaces.length > 1 || interfaces[0].isInterface()) {
			pf.setInterfaces(interfaces);
		}
		else {
			pf.setProxyTargetClass(true);
		}
		
		// Required everywhere we use AspectJ proxies
		pf.addAdvice(ExposeInvocationInterceptor.INSTANCE);
		
		for (Advisor a : advisors) {
			pf.addAdvisor(a);
		}
		
		pf.setExposeProxy(true);
		return pf.getProxy();
	}
	
	@Aspect
	public static class TwoAdviceAspect {
		private int totalCalls;
		
		@Around("execution(* getAge())")		
		public int returnCallCount(ProceedingJoinPoint pjp) throws Exception {
			return totalCalls;
		}
		
		@Before("execution(* setAge(int)) && args(newAge)")		
		public void countSet(int newAge) throws Exception {
			++totalCalls;
		}
	}
		
	public void testTwoAdvicesOnOneAspect() {
		TestBean target = new TestBean();
	
		TwoAdviceAspect twoAdviceAspect = new TwoAdviceAspect();
		List<Advisor> advisors = getFixture().getAdvisors(new SingletonMetadataAwareAspectInstanceFactory(twoAdviceAspect,"someBean"));
		assertEquals("Two advice methods found", 2, advisors.size());
		ITestBean itb = (ITestBean) createProxy(target, 
				advisors, 
				ITestBean.class);
		itb.setName("");
		assertEquals(0, itb.getAge());
		int newAge = 32;
		itb.setAge(newAge);
		assertEquals(1, itb.getAge());
	}

	public static class Echo {
		public Object echo(Object o) throws Exception {
			if (o instanceof Exception) {
				throw (Exception) o;
			}
			return o;
		}
	}
	
	@Aspect
	public static class ExceptionHandling {
		public int successCount;
		public int failureCount;
		public int afterCount;
		
		@AfterReturning("execution(* echo(*))")
		public void succeeded() {
			++successCount;
		}
		
		@AfterThrowing("execution(* echo(*))")
		public void failed() {
			++failureCount;
		}
		
		@After("execution(* echo(*))")
		public void invoked() {
			++afterCount;
		}
	}
	
	public void testAfterAdviceTypes() throws Exception {
		Echo target = new Echo();
	
		ExceptionHandling afterReturningAspect = new ExceptionHandling();
		List<Advisor> advisors = getFixture().getAdvisors(new SingletonMetadataAwareAspectInstanceFactory(afterReturningAspect,"someBean"));
		Echo echo = (Echo) createProxy(target, 
				advisors, 
				Echo.class);
		assertEquals(0, afterReturningAspect.successCount);
		assertEquals("", echo.echo(""));
		assertEquals(1, afterReturningAspect.successCount);
		assertEquals(0, afterReturningAspect.failureCount);
		try {
			echo.echo(new ServletException());
			fail();
		}
		catch (ServletException ex) {
			// Ok
		}
		catch (Exception ex) {
			fail();
		}
		assertEquals(1, afterReturningAspect.successCount);
		assertEquals(1, afterReturningAspect.failureCount);
		assertEquals(afterReturningAspect.failureCount + afterReturningAspect.successCount, afterReturningAspect.afterCount);
	}
	
	@Aspect
	public static class NoDeclarePrecedenceShouldFail {
		
		@Pointcut("execution(int *.getAge())")
		public void getAge() {
		}
		
		@Before("getAge()")
		public void blowUpButDoesntMatterBecauseAroundAdviceWontLetThisBeInvoked() {
			throw new IllegalStateException();
		}
		
		@Around("getAge()")
		public int preventExecution(ProceedingJoinPoint pjp) {
			return 666;
		}
	}
	
	@Aspect
	@DeclarePrecedence("org.springframework..*")
	public static class DeclarePrecedenceShouldSucceed {
		
		@Pointcut("execution(int *.getAge())")
		public void getAge() {
		}
		
//		@Before("getAge()")
//		public void blowUpButDoesntMatterBecauseAroundAdviceWontLetThisBeInvoked() {
//			throw new IllegalStateException();
//		}
//		
//		@Around("getAge()")
//
//		public int preventExecution(ProceedingJoinPoint pjp) {
//			return 666;
//		}
	}
	
	public void testFailureWithoutExplicitDeclarePrecedence() {
		TestBean target = new TestBean();
		ITestBean itb = (ITestBean) createProxy(target, 
				getFixture().getAdvisors(new SingletonMetadataAwareAspectInstanceFactory(new NoDeclarePrecedenceShouldFail(),"someBean")), 
				ITestBean.class);
		try {
			itb.getAge();
			fail();
		}
		catch (IllegalStateException ex) {
			
		}
	}
	
	public void testDeclarePrecedenceNotSupported() {
		TestBean target = new TestBean();
		try {
			createProxy(target, 
				getFixture().getAdvisors(new SingletonMetadataAwareAspectInstanceFactory(
						new DeclarePrecedenceShouldSucceed(),"someBean")), 
				ITestBean.class);
			fail();
		}
		catch (IllegalArgumentException ex) {
			// Not supported in M1
		}
	}

// TODO in 2.0M1 precedence is out of scope
//	public void testExplicitDeclarePrecedencePreventsFailure() {
//		TestBean target = new TestBean();
//		ITestBean itb = (ITestBean) createProxy(target, 
//				getFixture().getAdvisors(new SingletonMetadataAwareAspectInstanceFactory(
//						new DeclarePrecedenceShouldSucceed())), 
//				ITestBean.class);
//		assertEquals(666, itb.getAge());
//	}

}