Migrate JUnit 4 assertions to AssertJ

Migrate all existing JUnit 4 `assert...` based assertions to AssertJ
and add a checkstyle rule to ensure they don't return.

See gh-23022

Author: philwebb

spring-aop/src/test/java/org/springframework/aop/aspectj/AspectJAdviceParameterNameDiscovererTests.java

@@ -23,9 +23,8 @@
 
 import org.springframework.aop.aspectj.AspectJAdviceParameterNameDiscoverer.AmbiguousBindingException;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
 
 /**
  * Unit tests for the {@link AspectJAdviceParameterNameDiscoverer} class.
@@ -236,8 +235,7 @@ protected void assertParameterNames(Method method, String pointcut, String[] par
 	protected void assertParameterNames(
 			Method method, String pointcut, String returning, String throwing, String[] parameterNames) {
 
-		assertEquals("bad test specification, must have same number of parameter names as method arguments",
-				method.getParameterCount(), parameterNames.length);
+		assertThat(parameterNames.length).as("bad test specification, must have same number of parameter names as method arguments").isEqualTo(method.getParameterCount());
 
 		AspectJAdviceParameterNameDiscoverer discoverer = new AspectJAdviceParameterNameDiscoverer(pointcut);
 		discoverer.setRaiseExceptions(true);
@@ -248,16 +246,14 @@ protected void assertParameterNames(
 		String formattedExpectedNames = format(parameterNames);
 		String formattedActualNames = format(discoveredNames);
 
-		assertEquals("Expecting " + parameterNames.length + " parameter names in return set '" +
+		assertThat(discoveredNames.length).as("Expecting " + parameterNames.length + " parameter names in return set '" +
 				formattedExpectedNames + "', but found " + discoveredNames.length +
-				" '" + formattedActualNames + "'",
-				parameterNames.length, discoveredNames.length);
+				" '" + formattedActualNames + "'").isEqualTo(parameterNames.length);
 
 		for (int i = 0; i < discoveredNames.length; i++) {
-			assertNotNull("Parameter names must never be null", discoveredNames[i]);
-			assertEquals("Expecting parameter " + i + " to be named '" +
-					parameterNames[i] + "' but was '" + discoveredNames[i] + "'",
-					parameterNames[i], discoveredNames[i]);
+			assertThat(discoveredNames[i]).as("Parameter names must never be null").isNotNull();
+			assertThat(discoveredNames[i]).as("Expecting parameter " + i + " to be named '" +
+						parameterNames[i] + "' but was '" + discoveredNames[i] + "'").isEqualTo(parameterNames[i]);
 		}
 	}
 

spring-aop/src/test/java/org/springframework/aop/aspectj/AspectJExpressionPointcutTests.java

@@ -40,9 +40,6 @@
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
 
 /**
  * @author Rob Harrop
@@ -81,9 +78,9 @@ public void testMatchExplicit() {
 		// not currently testable in a reliable fashion
 		//assertDoesNotMatchStringClass(classFilter);
 
-		assertFalse("Should not be a runtime match", methodMatcher.isRuntime());
+		assertThat(methodMatcher.isRuntime()).as("Should not be a runtime match").isFalse();
 		assertMatchesGetAge(methodMatcher);
-		assertFalse("Expression should match setAge() method", methodMatcher.matches(setAge, TestBean.class));
+		assertThat(methodMatcher.matches(setAge, TestBean.class)).as("Expression should match setAge() method").isFalse();
 	}
 
 	@Test
@@ -99,9 +96,9 @@ public void testMatchWithTypePattern() throws Exception {
 		// not currently testable in a reliable fashion
 		//assertDoesNotMatchStringClass(classFilter);
 
-		assertFalse("Should not be a runtime match", methodMatcher.isRuntime());
+		assertThat(methodMatcher.isRuntime()).as("Should not be a runtime match").isFalse();
 		assertMatchesGetAge(methodMatcher);
-		assertTrue("Expression should match setAge(int) method", methodMatcher.matches(setAge, TestBean.class));
+		assertThat(methodMatcher.matches(setAge, TestBean.class)).as("Expression should match setAge(int) method").isTrue();
 	}
 
 
@@ -128,10 +125,10 @@ private void testThisOrTarget(String which) throws SecurityException, NoSuchMeth
 		AspectJExpressionPointcut iOtherPc = new AspectJExpressionPointcut();
 		iOtherPc.setExpression(matchesIOther);
 
-		assertTrue(testBeanPc.matches(TestBean.class));
-		assertTrue(testBeanPc.matches(getAge, TestBean.class));
-		assertTrue(iOtherPc.matches(OtherIOther.class.getMethod("absquatulate"), OtherIOther.class));
-		assertFalse(testBeanPc.matches(OtherIOther.class.getMethod("absquatulate"), OtherIOther.class));
+		assertThat(testBeanPc.matches(TestBean.class)).isTrue();
+		assertThat(testBeanPc.matches(getAge, TestBean.class)).isTrue();
+		assertThat(iOtherPc.matches(OtherIOther.class.getMethod("absquatulate"), OtherIOther.class)).isTrue();
+		assertThat(testBeanPc.matches(OtherIOther.class.getMethod("absquatulate"), OtherIOther.class)).isFalse();
 	}
 
 	@Test
@@ -154,13 +151,13 @@ private void testWithinPackage(boolean matchSubpackages) throws SecurityExceptio
 		AspectJExpressionPointcut withinBeansPc = new AspectJExpressionPointcut();
 		withinBeansPc.setExpression(withinBeansPackage);
 
-		assertTrue(withinBeansPc.matches(TestBean.class));
-		assertTrue(withinBeansPc.matches(getAge, TestBean.class));
-		assertEquals(matchSubpackages, withinBeansPc.matches(DeepBean.class));
-		assertEquals(matchSubpackages, withinBeansPc.matches(
-				DeepBean.class.getMethod("aMethod", String.class), DeepBean.class));
-		assertFalse(withinBeansPc.matches(String.class));
-		assertFalse(withinBeansPc.matches(OtherIOther.class.getMethod("absquatulate"), OtherIOther.class));
+		assertThat(withinBeansPc.matches(TestBean.class)).isTrue();
+		assertThat(withinBeansPc.matches(getAge, TestBean.class)).isTrue();
+		assertThat(withinBeansPc.matches(DeepBean.class)).isEqualTo(matchSubpackages);
+		assertThat(withinBeansPc.matches(
+				DeepBean.class.getMethod("aMethod", String.class), DeepBean.class)).isEqualTo(matchSubpackages);
+		assertThat(withinBeansPc.matches(String.class)).isFalse();
+		assertThat(withinBeansPc.matches(OtherIOther.class.getMethod("absquatulate"), OtherIOther.class)).isFalse();
 	}
 
 	@Test
@@ -201,12 +198,10 @@ public void testMatchWithArgs() throws Exception {
 		// not currently testable in a reliable fashion
 		//assertDoesNotMatchStringClass(classFilter);
 
-		assertTrue("Should match with setSomeNumber with Double input",
-				methodMatcher.matches(setSomeNumber, TestBean.class, new Double(12)));
-		assertFalse("Should not match setSomeNumber with Integer input",
-				methodMatcher.matches(setSomeNumber, TestBean.class, new Integer(11)));
-		assertFalse("Should not match getAge", methodMatcher.matches(getAge, TestBean.class));
-		assertTrue("Should be a runtime match", methodMatcher.isRuntime());
+		assertThat(methodMatcher.matches(setSomeNumber, TestBean.class, new Double(12))).as("Should match with setSomeNumber with Double input").isTrue();
+		assertThat(methodMatcher.matches(setSomeNumber, TestBean.class, new Integer(11))).as("Should not match setSomeNumber with Integer input").isFalse();
+		assertThat(methodMatcher.matches(getAge, TestBean.class)).as("Should not match getAge").isFalse();
+		assertThat(methodMatcher.isRuntime()).as("Should be a runtime match").isTrue();
 	}
 
 	@Test
@@ -215,11 +210,11 @@ public void testSimpleAdvice() {
 		CallCountingInterceptor interceptor = new CallCountingInterceptor();
 		TestBean testBean = getAdvisedProxy(expression, interceptor);
 
-		assertEquals("Calls should be 0", 0, interceptor.getCount());
+		assertThat(interceptor.getCount()).as("Calls should be 0").isEqualTo(0);
 		testBean.getAge();
-		assertEquals("Calls should be 1", 1, interceptor.getCount());
+		assertThat(interceptor.getCount()).as("Calls should be 1").isEqualTo(1);
 		testBean.setAge(90);
-		assertEquals("Calls should still be 1", 1, interceptor.getCount());
+		assertThat(interceptor.getCount()).as("Calls should still be 1").isEqualTo(1);
 	}
 
 	@Test
@@ -228,12 +223,12 @@ public void testDynamicMatchingProxy() {
 		CallCountingInterceptor interceptor = new CallCountingInterceptor();
 		TestBean testBean = getAdvisedProxy(expression, interceptor);
 
-		assertEquals("Calls should be 0", 0, interceptor.getCount());
+		assertThat(interceptor.getCount()).as("Calls should be 0").isEqualTo(0);
 		testBean.setSomeNumber(new Double(30));
-		assertEquals("Calls should be 1", 1, interceptor.getCount());
+		assertThat(interceptor.getCount()).as("Calls should be 1").isEqualTo(1);
 
 		testBean.setSomeNumber(new Integer(90));
-		assertEquals("Calls should be 1", 1, interceptor.getCount());
+		assertThat(interceptor.getCount()).as("Calls should be 1").isEqualTo(1);
 	}
 
 	@Test
@@ -260,11 +255,11 @@ private TestBean getAdvisedProxy(String pointcutExpression, CallCountingIntercep
 	}
 
 	private void assertMatchesGetAge(MethodMatcher methodMatcher) {
-		assertTrue("Expression should match getAge() method", methodMatcher.matches(getAge, TestBean.class));
+		assertThat(methodMatcher.matches(getAge, TestBean.class)).as("Expression should match getAge() method").isTrue();
 	}
 
 	private void assertMatchesTestBeanClass(ClassFilter classFilter) {
-		assertTrue("Expression should match TestBean class", classFilter.matches(TestBean.class));
+		assertThat(classFilter.matches(TestBean.class)).as("Expression should match TestBean class").isTrue();
 	}
 
 	@Test
@@ -279,14 +274,14 @@ public void testWithUnsupportedPointcutPrimitive() {
 	public void testAndSubstitution() {
 		Pointcut pc = getPointcut("execution(* *(..)) and args(String)");
 		PointcutExpression expr = ((AspectJExpressionPointcut) pc).getPointcutExpression();
-		assertEquals("execution(* *(..)) && args(String)",expr.getPointcutExpression());
+		assertThat(expr.getPointcutExpression()).isEqualTo("execution(* *(..)) && args(String)");
 	}
 
 	@Test
 	public void testMultipleAndSubstitutions() {
 		Pointcut pc = getPointcut("execution(* *(..)) and args(String) and this(Object)");
 		PointcutExpression expr = ((AspectJExpressionPointcut) pc).getPointcutExpression();
-		assertEquals("execution(* *(..)) && args(String) && this(Object)",expr.getPointcutExpression());
+		assertThat(expr.getPointcutExpression()).isEqualTo("execution(* *(..)) && args(String) && this(Object)");
 	}
 
 	private Pointcut getPointcut(String expression) {

spring-aop/src/test/java/org/springframework/aop/aspectj/BeanNamePointcutMatchingTests.java

@@ -20,8 +20,7 @@
 
 import org.springframework.tests.sample.beans.TestBean;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for matching of bean() pointcut designator.
@@ -80,13 +79,11 @@ public void testNonMatchingPointcuts() {
 
 
 	private void assertMatch(String beanName, String pcExpression) {
-		assertTrue("Unexpected mismatch for bean \"" + beanName + "\" for pcExpression \"" + pcExpression + "\"",
-				matches(beanName, pcExpression));
+		assertThat(matches(beanName, pcExpression)).as("Unexpected mismatch for bean \"" + beanName + "\" for pcExpression \"" + pcExpression + "\"").isTrue();
 	}
 
 	private void assertMisMatch(String beanName, String pcExpression) {
-		assertFalse("Unexpected match for bean \"" + beanName + "\" for pcExpression \"" + pcExpression + "\"",
-				matches(beanName, pcExpression));
+		assertThat(matches(beanName, pcExpression)).as("Unexpected match for bean \"" + beanName + "\" for pcExpression \"" + pcExpression + "\"").isFalse();
 	}
 
 	private static boolean matches(final String beanName, String pcExpression) {

spring-aop/src/test/java/org/springframework/aop/aspectj/MethodInvocationProceedingJoinPointTests.java

@@ -37,13 +37,9 @@
 import org.springframework.tests.sample.beans.ITestBean;
 import org.springframework.tests.sample.beans.TestBean;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
 
 /**
  * @author Rod Johnson
@@ -80,21 +76,21 @@ public void testCanGetMethodSignatureFromJoinPoint() {
 			@Override
 			public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
 				JoinPoint jp = AbstractAspectJAdvice.currentJoinPoint();
-				assertTrue("Method named in toString", jp.toString().contains(method.getName()));
+				assertThat(jp.toString().contains(method.getName())).as("Method named in toString").isTrue();
 				// Ensure that these don't cause problems
 				jp.toShortString();
 				jp.toLongString();
 
-				assertSame(target, AbstractAspectJAdvice.currentJoinPoint().getTarget());
-				assertFalse(AopUtils.isAopProxy(AbstractAspectJAdvice.currentJoinPoint().getTarget()));
+				assertThat(AbstractAspectJAdvice.currentJoinPoint().getTarget()).isSameAs(target);
+				assertThat(AopUtils.isAopProxy(AbstractAspectJAdvice.currentJoinPoint().getTarget())).isFalse();
 
 				ITestBean thisProxy = (ITestBean) AbstractAspectJAdvice.currentJoinPoint().getThis();
-				assertTrue(AopUtils.isAopProxy(AbstractAspectJAdvice.currentJoinPoint().getThis()));
+				assertThat(AopUtils.isAopProxy(AbstractAspectJAdvice.currentJoinPoint().getThis())).isTrue();
 
-				assertNotSame(target, thisProxy);
+				assertThat(thisProxy).isNotSameAs(target);
 
 				// Check getting again doesn't cause a problem
-				assertSame(thisProxy, AbstractAspectJAdvice.currentJoinPoint().getThis());
+				assertThat(AbstractAspectJAdvice.currentJoinPoint().getThis()).isSameAs(thisProxy);
 
 				// Try reentrant call--will go through this advice.
 				// Be sure to increment depth to avoid infinite recursion
@@ -103,29 +99,29 @@ public void before(Method method, Object[] args, @Nullable Object target) throws
 					thisProxy.toString();
 					// Change age, so this will be returned by invocation
 					thisProxy.setAge(newAge);
-					assertEquals(newAge, thisProxy.getAge());
+					assertThat(thisProxy.getAge()).isEqualTo(newAge);
 				}
 
-				assertSame(AopContext.currentProxy(), thisProxy);
-				assertSame(target, raw);
+				assertThat(thisProxy).isSameAs(AopContext.currentProxy());
+				assertThat(raw).isSameAs(target);
 
-				assertSame(method.getName(), AbstractAspectJAdvice.currentJoinPoint().getSignature().getName());
-				assertEquals(method.getModifiers(), AbstractAspectJAdvice.currentJoinPoint().getSignature().getModifiers());
+				assertThat(AbstractAspectJAdvice.currentJoinPoint().getSignature().getName()).isSameAs(method.getName());
+				assertThat(AbstractAspectJAdvice.currentJoinPoint().getSignature().getModifiers()).isEqualTo(method.getModifiers());
 
 				MethodSignature msig = (MethodSignature) AbstractAspectJAdvice.currentJoinPoint().getSignature();
-				assertSame("Return same MethodSignature repeatedly", msig, AbstractAspectJAdvice.currentJoinPoint().getSignature());
-				assertSame("Return same JoinPoint repeatedly", AbstractAspectJAdvice.currentJoinPoint(), AbstractAspectJAdvice.currentJoinPoint());
-				assertEquals(method.getDeclaringClass(), msig.getDeclaringType());
-				assertTrue(Arrays.equals(method.getParameterTypes(), msig.getParameterTypes()));
-				assertEquals(method.getReturnType(), msig.getReturnType());
-				assertTrue(Arrays.equals(method.getExceptionTypes(), msig.getExceptionTypes()));
+				assertThat(AbstractAspectJAdvice.currentJoinPoint().getSignature()).as("Return same MethodSignature repeatedly").isSameAs(msig);
+				assertThat(AbstractAspectJAdvice.currentJoinPoint()).as("Return same JoinPoint repeatedly").isSameAs(AbstractAspectJAdvice.currentJoinPoint());
+				assertThat(msig.getDeclaringType()).isEqualTo(method.getDeclaringClass());
+				assertThat(Arrays.equals(method.getParameterTypes(), msig.getParameterTypes())).isTrue();
+				assertThat(msig.getReturnType()).isEqualTo(method.getReturnType());
+				assertThat(Arrays.equals(method.getExceptionTypes(), msig.getExceptionTypes())).isTrue();
 				msig.toLongString();
 				msig.toShortString();
 			}
 		});
 		ITestBean itb = (ITestBean) pf.getProxy();
 		// Any call will do
-		assertEquals("Advice reentrantly set age", newAge, itb.getAge());
+		assertThat(itb.getAge()).as("Advice reentrantly set age").isEqualTo(newAge);
 	}
 
 	@Test
@@ -137,8 +133,8 @@ public void testCanGetSourceLocationFromJoinPoint() {
 			@Override
 			public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
 				SourceLocation sloc = AbstractAspectJAdvice.currentJoinPoint().getSourceLocation();
-				assertEquals("Same source location must be returned on subsequent requests", sloc, AbstractAspectJAdvice.currentJoinPoint().getSourceLocation());
-				assertEquals(TestBean.class, sloc.getWithinType());
+				assertThat(AbstractAspectJAdvice.currentJoinPoint().getSourceLocation()).as("Same source location must be returned on subsequent requests").isEqualTo(sloc);
+				assertThat(sloc.getWithinType()).isEqualTo(TestBean.class);
 				assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(sloc::getLine);
 				assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(sloc::getFileName);
 			}
@@ -157,10 +153,10 @@ public void testCanGetStaticPartFromJoinPoint() {
 			@Override
 			public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
 				StaticPart staticPart = AbstractAspectJAdvice.currentJoinPoint().getStaticPart();
-				assertEquals("Same static part must be returned on subsequent requests", staticPart, AbstractAspectJAdvice.currentJoinPoint().getStaticPart());
-				assertEquals(ProceedingJoinPoint.METHOD_EXECUTION, staticPart.getKind());
-				assertSame(AbstractAspectJAdvice.currentJoinPoint().getSignature(), staticPart.getSignature());
-				assertEquals(AbstractAspectJAdvice.currentJoinPoint().getSourceLocation(), staticPart.getSourceLocation());
+				assertThat(AbstractAspectJAdvice.currentJoinPoint().getStaticPart()).as("Same static part must be returned on subsequent requests").isEqualTo(staticPart);
+				assertThat(staticPart.getKind()).isEqualTo(ProceedingJoinPoint.METHOD_EXECUTION);
+				assertThat(staticPart.getSignature()).isSameAs(AbstractAspectJAdvice.currentJoinPoint().getSignature());
+				assertThat(staticPart.getSourceLocation()).isEqualTo(AbstractAspectJAdvice.currentJoinPoint().getSourceLocation());
 			}
 		});
 		ITestBean itb = (ITestBean) pf.getProxy();
@@ -181,13 +177,13 @@ public void before(Method method, Object[] args, @Nullable Object target) throws
 				JoinPoint.StaticPart aspectJVersionJp = Factory.makeEncSJP(method);
 				JoinPoint jp = AbstractAspectJAdvice.currentJoinPoint();
 
-				assertEquals(aspectJVersionJp.getSignature().toLongString(), jp.getSignature().toLongString());
-				assertEquals(aspectJVersionJp.getSignature().toShortString(), jp.getSignature().toShortString());
-				assertEquals(aspectJVersionJp.getSignature().toString(), jp.getSignature().toString());
+				assertThat(jp.getSignature().toLongString()).isEqualTo(aspectJVersionJp.getSignature().toLongString());
+				assertThat(jp.getSignature().toShortString()).isEqualTo(aspectJVersionJp.getSignature().toShortString());
+				assertThat(jp.getSignature().toString()).isEqualTo(aspectJVersionJp.getSignature().toString());
 
-				assertEquals(aspectJVersionJp.toLongString(), jp.toLongString());
-				assertEquals(aspectJVersionJp.toShortString(), jp.toShortString());
-				assertEquals(aspectJVersionJp.toString(), jp.toString());
+				assertThat(jp.toLongString()).isEqualTo(aspectJVersionJp.toLongString());
+				assertThat(jp.toShortString()).isEqualTo(aspectJVersionJp.toShortString());
+				assertThat(jp.toString()).isEqualTo(aspectJVersionJp.toString());
 			}
 		});
 		ITestBean itb = (ITestBean) pf.getProxy();