Polish AopProxyUtilsTests

spring-aop/src/test/java/org/springframework/aop/framework/AopProxyUtilsTests.java

@@ -17,8 +17,6 @@
 package org.springframework.aop.framework;
 
 import java.lang.reflect.Proxy;
-import java.util.Arrays;
-import java.util.List;
 
 import org.junit.jupiter.api.Test;
 
@@ -30,107 +28,84 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 
 /**
+ * Tests for {@link AopProxyUtils}.
+ *
  * @author Rod Johnson
  * @author Chris Beams
  * @author Sam Brannen
  */
-public class AopProxyUtilsTests {
+class AopProxyUtilsTests {
 
 	@Test
-	public void testCompleteProxiedInterfacesWorksWithNull() {
+	void completeProxiedInterfacesWorksWithNull() {
 		AdvisedSupport as = new AdvisedSupport();
 		Class<?>[] completedInterfaces = AopProxyUtils.completeProxiedInterfaces(as);
-		assertThat(completedInterfaces.length).isEqualTo(2);
+		assertThat(completedInterfaces).containsExactly(SpringProxy.class, Advised.class);
-		List<?> ifaces = Arrays.asList(completedInterfaces);
-		assertThat(ifaces.contains(Advised.class)).isTrue();
-		assertThat(ifaces.contains(SpringProxy.class)).isTrue();
 	}
 
 	@Test
-	public void testCompleteProxiedInterfacesWorksWithNullOpaque() {
+	void completeProxiedInterfacesWorksWithNullOpaque() {
 		AdvisedSupport as = new AdvisedSupport();
 		as.setOpaque(true);
 		Class<?>[] completedInterfaces = AopProxyUtils.completeProxiedInterfaces(as);
-		assertThat(completedInterfaces.length).isEqualTo(1);
+		assertThat(completedInterfaces).containsExactly(SpringProxy.class);
 	}
 
 	@Test
-	public void testCompleteProxiedInterfacesAdvisedNotIncluded() {
+	void completeProxiedInterfacesAdvisedNotIncluded() {
 		AdvisedSupport as = new AdvisedSupport();
 		as.addInterface(ITestBean.class);
 		as.addInterface(Comparable.class);
 		Class<?>[] completedInterfaces = AopProxyUtils.completeProxiedInterfaces(as);
-		assertThat(completedInterfaces.length).isEqualTo(4);
+		assertThat(completedInterfaces).containsExactly(
-
+				ITestBean.class, Comparable.class, SpringProxy.class, Advised.class);
-		// Can't assume ordering for others, so use a list
-		List<?> l = Arrays.asList(completedInterfaces);
-		assertThat(l.contains(Advised.class)).isTrue();
-		assertThat(l.contains(ITestBean.class)).isTrue();
-		assertThat(l.contains(Comparable.class)).isTrue();
 	}
 
 	@Test
-	public void testCompleteProxiedInterfacesAdvisedIncluded() {
+	void completeProxiedInterfacesAdvisedIncluded() {
 		AdvisedSupport as = new AdvisedSupport();
-		as.addInterface(ITestBean.class);
-		as.addInterface(Comparable.class);
 		as.addInterface(Advised.class);
+		as.addInterface(ITestBean.class);
+		as.addInterface(Comparable.class);
 		Class<?>[] completedInterfaces = AopProxyUtils.completeProxiedInterfaces(as);
-		assertThat(completedInterfaces.length).isEqualTo(4);
+		assertThat(completedInterfaces).containsExactly(
-
+				Advised.class, ITestBean.class, Comparable.class, SpringProxy.class);
-		// Can't assume ordering for others, so use a list
-		List<?> l = Arrays.asList(completedInterfaces);
-		assertThat(l.contains(Advised.class)).isTrue();
-		assertThat(l.contains(ITestBean.class)).isTrue();
-		assertThat(l.contains(Comparable.class)).isTrue();
 	}
 
 	@Test
-	public void testCompleteProxiedInterfacesAdvisedNotIncludedOpaque() {
+	void completeProxiedInterfacesAdvisedNotIncludedOpaque() {
 		AdvisedSupport as = new AdvisedSupport();
 		as.setOpaque(true);
 		as.addInterface(ITestBean.class);
 		as.addInterface(Comparable.class);
 		Class<?>[] completedInterfaces = AopProxyUtils.completeProxiedInterfaces(as);
-		assertThat(completedInterfaces.length).isEqualTo(3);
+		assertThat(completedInterfaces).containsExactly(ITestBean.class, Comparable.class, SpringProxy.class);
-
-		// Can't assume ordering for others, so use a list
-		List<?> l = Arrays.asList(completedInterfaces);
-		assertThat(l.contains(Advised.class)).isFalse();
-		assertThat(l.contains(ITestBean.class)).isTrue();
-		assertThat(l.contains(Comparable.class)).isTrue();
 	}
 
 	@Test
-	public void testProxiedUserInterfacesWithSingleInterface() {
+	void proxiedUserInterfacesWithSingleInterface() {
 		ProxyFactory pf = new ProxyFactory();
 		pf.setTarget(new TestBean());
 		pf.addInterface(ITestBean.class);
-		Object proxy = pf.getProxy();
+		Class<?>[] userInterfaces = AopProxyUtils.proxiedUserInterfaces(pf.getProxy());
-		Class<?>[] userInterfaces = AopProxyUtils.proxiedUserInterfaces(proxy);
+		assertThat(userInterfaces).containsExactly(ITestBean.class);
-		assertThat(userInterfaces.length).isEqualTo(1);
-		assertThat(userInterfaces[0]).isEqualTo(ITestBean.class);
 	}
 
 	@Test
-	public void testProxiedUserInterfacesWithMultipleInterfaces() {
+	void proxiedUserInterfacesWithMultipleInterfaces() {
 		ProxyFactory pf = new ProxyFactory();
 		pf.setTarget(new TestBean());
 		pf.addInterface(ITestBean.class);
 		pf.addInterface(Comparable.class);
-		Object proxy = pf.getProxy();
+		Class<?>[] userInterfaces = AopProxyUtils.proxiedUserInterfaces(pf.getProxy());
-		Class<?>[] userInterfaces = AopProxyUtils.proxiedUserInterfaces(proxy);
+		assertThat(userInterfaces).containsExactly(ITestBean.class, Comparable.class);
-		assertThat(userInterfaces.length).isEqualTo(2);
-		assertThat(userInterfaces[0]).isEqualTo(ITestBean.class);
-		assertThat(userInterfaces[1]).isEqualTo(Comparable.class);
 	}
 
 	@Test
-	public void testProxiedUserInterfacesWithNoInterface() {
+	void proxiedUserInterfacesWithNoInterface() {
 		Object proxy = Proxy.newProxyInstance(getClass().getClassLoader(), new Class[0],
 				(proxy1, method, args) -> null);
-		assertThatIllegalArgumentException().isThrownBy(() ->
+		assertThatIllegalArgumentException().isThrownBy(() -> AopProxyUtils.proxiedUserInterfaces(proxy));
-				AopProxyUtils.proxiedUserInterfaces(proxy));
 	}
 
 }