User AssertJ's hasSize() for arrays

Achieved via global search-and-replace.

spring-aop/src/test/java/org/springframework/aop/aspectj/annotation/AbstractAspectJAdvisorFactoryTests.java

@@ -195,7 +195,7 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 
 		Advised advised = (Advised) itb;
 		// Will be ExposeInvocationInterceptor, synthetic instantiation advisor, 2 method advisors
-		assertThat(advised.getAdvisors().length).isEqualTo(4);
+		assertThat(advised.getAdvisors()).hasSize(4);
 		ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor sia =
 				(ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor) advised.getAdvisors()[1];
 		assertThat(sia.getPointcut().getMethodMatcher().matches(TestBean.class.getMethod("getSpouse"), null)).isTrue();
@@ -231,7 +231,7 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 
 		Advised advised = (Advised) itb;
 		// Will be ExposeInvocationInterceptor, synthetic instantiation advisor, 2 method advisors
-		assertThat(advised.getAdvisors().length).isEqualTo(4);
+		assertThat(advised.getAdvisors()).hasSize(4);
 		ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor sia =
 				(ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor) advised.getAdvisors()[1];
 		assertThat(sia.getPointcut().getMethodMatcher().matches(TestBean.class.getMethod("getSpouse"), null)).isTrue();

spring-aop/src/test/java/org/springframework/aop/support/AbstractRegexpMethodPointcutTests.java

@@ -56,7 +56,7 @@ public abstract class AbstractRegexpMethodPointcutTests {
 	protected void noPatternSuppliedTests(AbstractRegexpMethodPointcut rpc) throws Exception {
 		assertThat(rpc.matches(Object.class.getMethod("hashCode"), String.class)).isFalse();
 		assertThat(rpc.matches(Object.class.getMethod("wait"), Object.class)).isFalse();
-		assertThat(rpc.getPatterns().length).isEqualTo(0);
+		assertThat(rpc.getPatterns()).hasSize(0);
 	}
 
 	@Test

spring-beans/src/test/java/org/springframework/beans/BeanWrapperAutoGrowingTests.java

@@ -63,7 +63,7 @@ public class BeanWrapperAutoGrowingTests {
 	@Test
 	public void getPropertyValueAutoGrowArray() {
 		assertNotNull(wrapper.getPropertyValue("array[0]"));
-		assertThat(bean.getArray().length).isEqualTo(1);
+		assertThat(bean.getArray()).hasSize(1);
 		assertThat(bean.getArray()[0]).isInstanceOf(Bean.class);
 	}
 
@@ -76,7 +76,7 @@ public class BeanWrapperAutoGrowingTests {
 	@Test
 	public void getPropertyValueAutoGrowArrayBySeveralElements() {
 		assertNotNull(wrapper.getPropertyValue("array[4]"));
-		assertThat(bean.getArray().length).isEqualTo(5);
+		assertThat(bean.getArray()).hasSize(5);
 		assertThat(bean.getArray()[0]).isInstanceOf(Bean.class);
 		assertThat(bean.getArray()[1]).isInstanceOf(Bean.class);
 		assertThat(bean.getArray()[2]).isInstanceOf(Bean.class);
@@ -91,7 +91,7 @@ public class BeanWrapperAutoGrowingTests {
 	@Test
 	public void getPropertyValueAutoGrow2dArray() {
 		assertNotNull(wrapper.getPropertyValue("multiArray[0][0]"));
-		assertThat(bean.getMultiArray()[0].length).isEqualTo(1);
+		assertThat(bean.getMultiArray()[0]).hasSize(1);
 		assertThat(bean.getMultiArray()[0][0]).isInstanceOf(Bean.class);
 	}
 

spring-beans/src/test/java/org/springframework/beans/BeanWrapperEnumTests.java

@@ -62,7 +62,7 @@ public class BeanWrapperEnumTests {
 		GenericBean<?> gb = new GenericBean<>();
 		BeanWrapper bw = new BeanWrapperImpl(gb);
 		bw.setPropertyValue("customEnumArray", "VALUE_1");
-		assertThat(gb.getCustomEnumArray().length).isEqualTo(1);
+		assertThat(gb.getCustomEnumArray()).hasSize(1);
 		assertThat(gb.getCustomEnumArray()[0]).isEqualTo(CustomEnum.VALUE_1);
 	}
 
@@ -71,7 +71,7 @@ public class BeanWrapperEnumTests {
 		GenericBean<?> gb = new GenericBean<>();
 		BeanWrapper bw = new BeanWrapperImpl(gb);
 		bw.setPropertyValue("customEnumArray", new String[] {"VALUE_1", "VALUE_2"});
-		assertThat(gb.getCustomEnumArray().length).isEqualTo(2);
+		assertThat(gb.getCustomEnumArray()).hasSize(2);
 		assertThat(gb.getCustomEnumArray()[0]).isEqualTo(CustomEnum.VALUE_1);
 		assertThat(gb.getCustomEnumArray()[1]).isEqualTo(CustomEnum.VALUE_2);
 	}
@@ -81,7 +81,7 @@ public class BeanWrapperEnumTests {
 		GenericBean<?> gb = new GenericBean<>();
 		BeanWrapper bw = new BeanWrapperImpl(gb);
 		bw.setPropertyValue("customEnumArray", "VALUE_1,VALUE_2");
-		assertThat(gb.getCustomEnumArray().length).isEqualTo(2);
+		assertThat(gb.getCustomEnumArray()).hasSize(2);
 		assertThat(gb.getCustomEnumArray()[0]).isEqualTo(CustomEnum.VALUE_1);
 		assertThat(gb.getCustomEnumArray()[1]).isEqualTo(CustomEnum.VALUE_2);
 	}

spring-beans/src/test/java/org/springframework/beans/ExtendedBeanInfoTests.java

@@ -200,11 +200,11 @@ class ExtendedBeanInfoTests {
 		}
 		{ // always passes
 			BeanInfo info = Introspector.getBeanInfo(Bean.class);
-			assertThat(info.getPropertyDescriptors().length).isEqualTo(2);
+			assertThat(info.getPropertyDescriptors()).hasSize(2);
 		}
 		{ // failed prior to fix for SPR-9453
 			BeanInfo info = new ExtendedBeanInfo(Introspector.getBeanInfo(Bean.class));
-			assertThat(info.getPropertyDescriptors().length).isEqualTo(2);
+			assertThat(info.getPropertyDescriptors()).hasSize(2);
 		}
 	}
 
@@ -585,7 +585,7 @@ class ExtendedBeanInfoTests {
 		assertThat(hasReadMethodForProperty(ebi, "foo")).isTrue();
 		assertThat(hasWriteMethodForProperty(ebi, "foo")).isTrue();
 
-		assertThat(ebi.getPropertyDescriptors().length).isEqualTo(bi.getPropertyDescriptors().length);
+		assertThat(ebi.getPropertyDescriptors()).hasSize(bi.getPropertyDescriptors().length);
 	}
 
 	@Test
@@ -711,7 +711,7 @@ class ExtendedBeanInfoTests {
 		BeanInfo bi = Introspector.getBeanInfo(TestBean.class);
 		BeanInfo ebi = new ExtendedBeanInfo(bi);
 
-		assertThat(ebi.getPropertyDescriptors().length).isEqualTo(bi.getPropertyDescriptors().length);
+		assertThat(ebi.getPropertyDescriptors()).hasSize(bi.getPropertyDescriptors().length);
 	}
 
 	@Test
@@ -731,7 +731,7 @@ class ExtendedBeanInfoTests {
 			}
 		}
 		assertThat(found).isTrue();
-		assertThat(ebi.getPropertyDescriptors().length).isEqualTo(bi.getPropertyDescriptors().length+1);
+		assertThat(ebi.getPropertyDescriptors()).hasSize(bi.getPropertyDescriptors().length+1);
 	}
 
 	/**

spring-beans/src/test/java/org/springframework/beans/factory/annotation/AutowiredAnnotationBeanPostProcessorTests.java

@@ -159,7 +159,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getBeanFactory()).isSameAs(bf);
 
 		String[] depBeans = bf.getDependenciesForBean("annotatedBean");
-		assertThat(depBeans.length).isEqualTo(2);
+		assertThat(depBeans).hasSize(2);
 		assertThat(depBeans[0]).isEqualTo("testBean");
 		assertThat(depBeans[1]).isEqualTo("nestedTestBean");
 	}
@@ -266,10 +266,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isSameAs(tb);
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
-		assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
 		assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
-		assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
+		assertThat(bean.nestedTestBeansField).hasSize(2);
 		assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb2);
 	}
@@ -294,10 +294,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isSameAs(tb);
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
-		assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
 		assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
-		assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
+		assertThat(bean.nestedTestBeansField).hasSize(2);
 		assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb2);
 
@@ -309,10 +309,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isNull();
 		assertThat(bean.getTestBean4()).isNull();
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
-		assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
 		assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
-		assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
+		assertThat(bean.nestedTestBeansField).hasSize(2);
 		assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb2);
 
@@ -324,10 +324,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isSameAs(tb);
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
-		assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
 		assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
-		assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
+		assertThat(bean.nestedTestBeansField).hasSize(2);
 		assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb2);
 	}
@@ -351,10 +351,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isSameAs(bf.getBean("testBean"));
 		assertThat(bean.getTestBean4()).isSameAs(bf.getBean("testBean"));
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
-		assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
 		assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
-		assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
+		assertThat(bean.nestedTestBeansField).hasSize(2);
 		assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb2);
 
@@ -366,10 +366,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isNull();
 		assertThat(bean.getTestBean4()).isNull();
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
-		assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
 		assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
-		assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
+		assertThat(bean.nestedTestBeansField).hasSize(2);
 		assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb2);
 
@@ -381,10 +381,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isSameAs(bf.getBean("testBean"));
 		assertThat(bean.getTestBean4()).isSameAs(bf.getBean("testBean"));
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
-		assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
 		assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
-		assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
+		assertThat(bean.nestedTestBeansField).hasSize(2);
 		assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb2);
 	}
@@ -496,10 +496,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isSameAs(tb);
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
-		assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb2);
 		assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb1);
-		assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
+		assertThat(bean.nestedTestBeansField).hasSize(2);
 		assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb2);
 		assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb1);
 	}
@@ -522,10 +522,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isSameAs(tb);
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
-		assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb2);
 		assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb1);
-		assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
+		assertThat(bean.nestedTestBeansField).hasSize(2);
 		assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb2);
 		assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb1);
 	}
@@ -772,7 +772,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		ConstructorsResourceInjectionBean bean = (ConstructorsResourceInjectionBean) bf.getBean("annotatedBean");
 		assertThat(bean.getTestBean3()).isNull();
 		assertThat(bean.getTestBean4()).isSameAs(tb);
-		assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
 		assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
 	}
@@ -838,7 +838,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		ConstructorsResourceInjectionBean bean = (ConstructorsResourceInjectionBean) bf.getBean("annotatedBean");
 		assertThat(bean.getTestBean3()).isNull();
 		assertThat(bean.getTestBean4()).isSameAs(tb);
-		assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb2);
 		assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb1);
 	}

spring-beans/src/test/java/org/springframework/beans/factory/config/PropertyResourceConfigurerTests.java

@@ -401,7 +401,7 @@ public class PropertyResourceConfigurerTests {
 		assertThat(tb1.getSpouse()).isEqualTo(tb2);
 		assertThat(tb1.getSomeMap()).hasSize(1);
 		assertThat(tb1.getSomeMap().get("myKey")).isEqualTo("myValue");
-		assertThat(tb2.getStringArray().length).isEqualTo(2);
+		assertThat(tb2.getStringArray()).hasSize(2);
 		assertThat(tb2.getStringArray()[0]).isEqualTo(System.getProperty("os.name"));
 		assertThat(tb2.getStringArray()[1]).isEqualTo("98");
 		assertThat(tb2.getFriends()).hasSize(2);
@@ -577,7 +577,7 @@ public class PropertyResourceConfigurerTests {
 
 		TestBean tb = (TestBean) factory.getBean("tb");
 		assertThat(tb).isNotNull();
-		assertThat(factory.getAliases("tb").length).isEqualTo(0);
+		assertThat(factory.getAliases("tb")).hasSize(0);
 	}
 
 	@Test

spring-beans/src/test/java/org/springframework/beans/factory/config/SimpleScopeTests.java

@@ -63,7 +63,7 @@ public class SimpleScopeTests {
 		beanFactory.registerScope("myScope", scope);
 
 		String[] scopeNames = beanFactory.getRegisteredScopeNames();
-		assertThat(scopeNames.length).isEqualTo(1);
+		assertThat(scopeNames).hasSize(1);
 		assertThat(scopeNames[0]).isEqualTo("myScope");
 		assertThat(beanFactory.getRegisteredScope("myScope")).isSameAs(scope);
 

spring-beans/src/test/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistryTests.java

@@ -45,13 +45,13 @@ public class DefaultSingletonBeanRegistryTests {
 		assertThat(beanRegistry.getSingleton("tb2")).isSameAs(tb2);
 		assertThat(beanRegistry.getSingletonCount()).isEqualTo(2);
 		String[] names = beanRegistry.getSingletonNames();
-		assertThat(names.length).isEqualTo(2);
+		assertThat(names).hasSize(2);
 		assertThat(names[0]).isEqualTo("tb");
 		assertThat(names[1]).isEqualTo("tb2");
 
 		beanRegistry.destroySingletons();
 		assertThat(beanRegistry.getSingletonCount()).isEqualTo(0);
-		assertThat(beanRegistry.getSingletonNames().length).isEqualTo(0);
+		assertThat(beanRegistry.getSingletonNames()).hasSize(0);
 	}
 
 	@Test
@@ -66,13 +66,13 @@ public class DefaultSingletonBeanRegistryTests {
 		assertThat(beanRegistry.getSingleton("tb")).isSameAs(tb);
 		assertThat(beanRegistry.getSingletonCount()).isEqualTo(1);
 		String[] names = beanRegistry.getSingletonNames();
-		assertThat(names.length).isEqualTo(1);
+		assertThat(names).hasSize(1);
 		assertThat(names[0]).isEqualTo("tb");
 		assertThat(tb.wasDestroyed()).isFalse();
 
 		beanRegistry.destroySingletons();
 		assertThat(beanRegistry.getSingletonCount()).isEqualTo(0);
-		assertThat(beanRegistry.getSingletonNames().length).isEqualTo(0);
+		assertThat(beanRegistry.getSingletonNames()).hasSize(0);
 		assertThat(tb.wasDestroyed()).isTrue();
 	}
 

spring-beans/src/test/java/org/springframework/beans/factory/xml/EventPublicationTests.java

@@ -75,23 +75,23 @@ class EventPublicationTests {
 	void beanEventReceived() throws Exception {
 		ComponentDefinition componentDefinition1 = this.eventListener.getComponentDefinition("testBean");
 		assertThat(componentDefinition1).isInstanceOf(BeanComponentDefinition.class);
-		assertThat(componentDefinition1.getBeanDefinitions().length).isEqualTo(1);
+		assertThat(componentDefinition1.getBeanDefinitions()).hasSize(1);
 		BeanDefinition beanDefinition1 = componentDefinition1.getBeanDefinitions()[0];
 		assertThat(beanDefinition1.getConstructorArgumentValues().getGenericArgumentValue(String.class).getValue()).isEqualTo(new TypedStringValue("Rob Harrop"));
-		assertThat(componentDefinition1.getBeanReferences().length).isEqualTo(1);
+		assertThat(componentDefinition1.getBeanReferences()).hasSize(1);
 		assertThat(componentDefinition1.getBeanReferences()[0].getBeanName()).isEqualTo("testBean2");
-		assertThat(componentDefinition1.getInnerBeanDefinitions().length).isEqualTo(1);
+		assertThat(componentDefinition1.getInnerBeanDefinitions()).hasSize(1);
 		BeanDefinition innerBd1 = componentDefinition1.getInnerBeanDefinitions()[0];
 		assertThat(innerBd1.getConstructorArgumentValues().getGenericArgumentValue(String.class).getValue()).isEqualTo(new TypedStringValue("ACME"));
 		assertThat(componentDefinition1.getSource()).isInstanceOf(Element.class);
 
 		ComponentDefinition componentDefinition2 = this.eventListener.getComponentDefinition("testBean2");
 		assertThat(componentDefinition2).isInstanceOf(BeanComponentDefinition.class);
-		assertThat(componentDefinition1.getBeanDefinitions().length).isEqualTo(1);
+		assertThat(componentDefinition1.getBeanDefinitions()).hasSize(1);
 		BeanDefinition beanDefinition2 = componentDefinition2.getBeanDefinitions()[0];
 		assertThat(beanDefinition2.getPropertyValues().getPropertyValue("name").getValue()).isEqualTo(new TypedStringValue("Juergen Hoeller"));
-		assertThat(componentDefinition2.getBeanReferences().length).isEqualTo(0);
-		assertThat(componentDefinition2.getInnerBeanDefinitions().length).isEqualTo(1);
+		assertThat(componentDefinition2.getBeanReferences()).hasSize(0);
+		assertThat(componentDefinition2.getInnerBeanDefinitions()).hasSize(1);
 		BeanDefinition innerBd2 = componentDefinition2.getInnerBeanDefinitions()[0];
 		assertThat(innerBd2.getPropertyValues().getPropertyValue("name").getValue()).isEqualTo(new TypedStringValue("Eva Schallmeiner"));
 		assertThat(componentDefinition2.getSource()).isInstanceOf(Element.class);

spring-beans/src/test/java/org/springframework/beans/factory/xml/UtilNamespaceHandlerTests.java

@@ -203,7 +203,7 @@ public class UtilNamespaceHandlerTests {
 	void testNestedShortcutCollections() {
 		TestBean bean = (TestBean) this.beanFactory.getBean("nestedShortcutCollections");
 
-		assertThat(bean.getStringArray().length).isEqualTo(1);
+		assertThat(bean.getStringArray()).hasSize(1);
 		assertThat(bean.getStringArray()[0]).isEqualTo("fooStr");
 
 		List<?> list = bean.getSomeList();

spring-beans/src/test/java/org/springframework/beans/factory/xml/XmlBeanDefinitionReaderTests.java

@@ -109,7 +109,7 @@ public class XmlBeanDefinitionReaderTests {
 
 	private void testBeanDefinitions(BeanDefinitionRegistry registry) {
 		assertThat(registry.getBeanDefinitionCount()).isEqualTo(24);
-		assertThat(registry.getBeanDefinitionNames().length).isEqualTo(24);
+		assertThat(registry.getBeanDefinitionNames()).hasSize(24);
 		assertThat(Arrays.asList(registry.getBeanDefinitionNames()).contains("rod")).isTrue();
 		assertThat(Arrays.asList(registry.getBeanDefinitionNames()).contains("aliased")).isTrue();
 		assertThat(registry.containsBeanDefinition("rod")).isTrue();
@@ -118,7 +118,7 @@ public class XmlBeanDefinitionReaderTests {
 		assertThat(registry.getBeanDefinition("aliased").getBeanClassName()).isEqualTo(TestBean.class.getName());
 		assertThat(registry.isAlias("youralias")).isTrue();
 		String[] aliases = registry.getAliases("aliased");
-		assertThat(aliases.length).isEqualTo(2);
+		assertThat(aliases).hasSize(2);
 		assertThat(ObjectUtils.containsElement(aliases, "myalias")).isTrue();
 		assertThat(ObjectUtils.containsElement(aliases, "youralias")).isTrue();
 	}

spring-beans/src/test/java/org/springframework/beans/propertyeditors/CustomEditorTests.java

@@ -1393,7 +1393,7 @@ class CustomEditorTests {
 			}
 		});
 		bw.setPropertyValue("array", new String[] {"a", "b"});
-		assertThat(tb.getArray().length).isEqualTo(2);
+		assertThat(tb.getArray()).hasSize(2);
 		assertThat(tb.getArray()[0].getName()).isEqualTo("a");
 		assertThat(tb.getArray()[1].getName()).isEqualTo("b");
 	}

spring-context-support/src/test/java/org/springframework/cache/jcache/interceptor/CachePutOperationTests.java

@@ -45,7 +45,7 @@ public class CachePutOperationTests extends AbstractCacheOperationTests<CachePut
 		CachePutOperation operation = createSimpleOperation();
 
 		CacheInvocationParameter[] allParameters = operation.getAllParameters(2L, sampleInstance);
-		assertThat(allParameters.length).isEqualTo(2);
+		assertThat(allParameters).hasSize(2);
 		assertCacheInvocationParameter(allParameters[0], Long.class, 2L, 0);
 		assertCacheInvocationParameter(allParameters[1], SampleObject.class, sampleInstance, 1);
 

spring-context-support/src/test/java/org/springframework/cache/jcache/interceptor/CacheRemoveAllOperationTests.java

@@ -42,7 +42,7 @@ public class CacheRemoveAllOperationTests extends AbstractCacheOperationTests<Ca
 		CacheRemoveAllOperation operation = createSimpleOperation();
 
 		CacheInvocationParameter[] allParameters = operation.getAllParameters();
-		assertThat(allParameters.length).isEqualTo(0);
+		assertThat(allParameters).hasSize(0);
 	}
 
 }

spring-context-support/src/test/java/org/springframework/cache/jcache/interceptor/CacheRemoveOperationTests.java

@@ -42,7 +42,7 @@ public class CacheRemoveOperationTests extends AbstractCacheOperationTests<Cache
 		CacheRemoveOperation operation = createSimpleOperation();
 
 		CacheInvocationParameter[] allParameters = operation.getAllParameters(2L);
-		assertThat(allParameters.length).isEqualTo(1);
+		assertThat(allParameters).hasSize(1);
 		assertCacheInvocationParameter(allParameters[0], Long.class, 2L, 0);
 	}
 

spring-context-support/src/test/java/org/springframework/cache/jcache/interceptor/CacheResultOperationTests.java

@@ -57,11 +57,11 @@ public class CacheResultOperationTests extends AbstractCacheOperationTests<Cache
 		assertThat(operation.getExceptionCacheResolver()).isEqualTo(defaultExceptionCacheResolver);
 
 		CacheInvocationParameter[] allParameters = operation.getAllParameters(2L);
-		assertThat(allParameters.length).isEqualTo(1);
+		assertThat(allParameters).hasSize(1);
 		assertCacheInvocationParameter(allParameters[0], Long.class, 2L, 0);
 
 		CacheInvocationParameter[] keyParameters = operation.getKeyParameters(2L);
-		assertThat(keyParameters.length).isEqualTo(1);
+		assertThat(keyParameters).hasSize(1);
 		assertCacheInvocationParameter(keyParameters[0], Long.class, 2L, 0);
 	}
 
@@ -72,7 +72,7 @@ public class CacheResultOperationTests extends AbstractCacheOperationTests<Cache
 		CacheResultOperation operation = createDefaultOperation(methodDetails);
 
 		CacheInvocationParameter[] keyParameters = operation.getKeyParameters(3L, Boolean.TRUE, "Foo");
-		assertThat(keyParameters.length).isEqualTo(2);
+		assertThat(keyParameters).hasSize(2);
 		assertCacheInvocationParameter(keyParameters[0], Long.class, 3L, 0);
 		assertCacheInvocationParameter(keyParameters[1], String.class, "Foo", 2);
 	}

spring-context/src/test/java/org/springframework/aop/aspectj/autoproxy/AtAspectJAnnotationBindingTests.java

@@ -51,7 +51,7 @@ public class AtAspectJAnnotationBindingTests {
 	public void testAnnotationBindingInAroundAdvice() {
 		assertThat(testBean.doThis()).isEqualTo("this value doThis");
 		assertThat(testBean.doThat()).isEqualTo("that value doThat");
-		assertThat(testBean.doArray().length).isEqualTo(2);
+		assertThat(testBean.doArray()).hasSize(2);
 	}
 
 	@Test

spring-context/src/test/java/org/springframework/aop/framework/AbstractAopProxyTests.java

@@ -214,7 +214,7 @@ public abstract class AbstractAopProxyTests {
 		Advised a1 = (Advised) p;
 		Advised a2 = (Advised) p2;
 		// Check we can manipulate state of p2
-		assertThat(a2.getAdvisors().length).isEqualTo(a1.getAdvisors().length);
+		assertThat(a2.getAdvisors()).hasSize(a1.getAdvisors().length);
 
 		// This should work as SerializablePerson is equal
 		assertThat(p2).as("Proxies should be equal, even after one was serialized").isEqualTo(p);
@@ -748,7 +748,7 @@ public abstract class AbstractAopProxyTests {
 			.withMessageContaining("frozen");
 		// Check it still works: proxy factory state shouldn't have been corrupted
 		assertThat(proxied.getAge()).isEqualTo(target.getAge());
-		assertThat(((Advised) proxied).getAdvisors().length).isEqualTo(1);
+		assertThat(((Advised) proxied).getAdvisors()).hasSize(1);
 	}
 
 	/**
@@ -771,7 +771,7 @@ public abstract class AbstractAopProxyTests {
 			.withMessageContaining("frozen");
 		// Check it still works: proxy factory state shouldn't have been corrupted
 		assertThat(proxied.getAge()).isEqualTo(target.getAge());
-		assertThat(advised.getAdvisors().length).isEqualTo(1);
+		assertThat(advised.getAdvisors()).hasSize(1);
 	}
 
 	@Test
@@ -790,13 +790,13 @@ public abstract class AbstractAopProxyTests {
 			.isThrownBy(() -> advised.removeAdvisor(0))
 			.withMessageContaining("frozen");
 		// Didn't get removed
-		assertThat(advised.getAdvisors().length).isEqualTo(1);
+		assertThat(advised.getAdvisors()).hasSize(1);
 		pc.setFrozen(false);
 		// Can now remove it
 		advised.removeAdvisor(0);
 		// Check it still works: proxy factory state shouldn't have been corrupted
 		assertThat(proxied.getAge()).isEqualTo(target.getAge());
-		assertThat(advised.getAdvisors().length).isEqualTo(0);
+		assertThat(advised.getAdvisors()).hasSize(0);
 	}
 
 	@Test
@@ -1173,7 +1173,7 @@ public abstract class AbstractAopProxyTests {
 		IOther proxyA = (IOther) createProxy(pfa);
 		IOther proxyB = (IOther) createProxy(pfb);
 
-		assertThat(pfb.getAdvisors().length).isEqualTo(pfa.getAdvisors().length);
+		assertThat(pfb.getAdvisors()).hasSize(pfa.getAdvisors().length);
 		assertThat(b).isEqualTo(a);
 		assertThat(i2).isEqualTo(i1);
 		assertThat(proxyB).isEqualTo(proxyA);

spring-context/src/test/java/org/springframework/beans/factory/xml/XmlBeanFactoryTests.java

@@ -190,7 +190,7 @@ class XmlBeanFactoryTests {
 
 		assertThat(hasInnerBeans.getFriends()).isNotNull();
 		Object[] friends = hasInnerBeans.getFriends().toArray();
-		assertThat(friends.length).isEqualTo(3);
+		assertThat(friends).hasSize(3);
 		DerivedTestBean inner2 = (DerivedTestBean) friends[0];
 		assertThat(inner2.getName()).isEqualTo("inner2");
 		assertThat(inner2.getBeanName().startsWith(DerivedTestBean.class.getName())).isTrue();
@@ -261,7 +261,7 @@ class XmlBeanFactoryTests {
 
 		assertThat(hasInnerBeans.getFriends()).isNotNull();
 		Object[] friends = hasInnerBeans.getFriends().toArray();
-		assertThat(friends.length).isEqualTo(3);
+		assertThat(friends).hasSize(3);
 		DerivedTestBean inner2 = (DerivedTestBean) friends[0];
 		assertThat(inner2.getName()).isEqualTo("inner2");
 		assertThat(inner2.getBeanName().startsWith(DerivedTestBean.class.getName())).isTrue();
@@ -1510,7 +1510,7 @@ class XmlBeanFactoryTests {
 		new XmlBeanDefinitionReader(xbf).loadBeanDefinitions(CONSTRUCTOR_ARG_CONTEXT);
 		ConstructorArrayTestBean bean = (ConstructorArrayTestBean) xbf.getBean("constructorArray");
 		assertThat(bean.array instanceof int[]).isTrue();
-		assertThat(((int[]) bean.array).length).isEqualTo(1);
+		assertThat(((int[]) bean.array)).hasSize(1);
 		assertThat(((int[]) bean.array)[0]).isEqualTo(1);
 	}
 
@@ -1520,7 +1520,7 @@ class XmlBeanFactoryTests {
 		new XmlBeanDefinitionReader(xbf).loadBeanDefinitions(CONSTRUCTOR_ARG_CONTEXT);
 		ConstructorArrayTestBean bean = (ConstructorArrayTestBean) xbf.getBean("indexedConstructorArray");
 		assertThat(bean.array instanceof int[]).isTrue();
-		assertThat(((int[]) bean.array).length).isEqualTo(1);
+		assertThat(((int[]) bean.array)).hasSize(1);
 		assertThat(((int[]) bean.array)[0]).isEqualTo(1);
 	}
 
@@ -1530,7 +1530,7 @@ class XmlBeanFactoryTests {
 		new XmlBeanDefinitionReader(xbf).loadBeanDefinitions(CONSTRUCTOR_ARG_CONTEXT);
 		ConstructorArrayTestBean bean = (ConstructorArrayTestBean) xbf.getBean("constructorArrayNoType");
 		assertThat(bean.array instanceof String[]).isTrue();
-		assertThat(((String[]) bean.array).length).isEqualTo(0);
+		assertThat(((String[]) bean.array)).hasSize(0);
 	}
 
 	@Test
@@ -1541,7 +1541,7 @@ class XmlBeanFactoryTests {
 		bd.setLenientConstructorResolution(false);
 		ConstructorArrayTestBean bean = (ConstructorArrayTestBean) xbf.getBean("constructorArrayNoType");
 		assertThat(bean.array instanceof String[]).isTrue();
-		assertThat(((String[]) bean.array).length).isEqualTo(0);
+		assertThat(((String[]) bean.array)).hasSize(0);
 	}
 
 	@Test
@@ -1596,7 +1596,7 @@ class XmlBeanFactoryTests {
 
 		@Override
 		public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
-			assertThat(args.length).isEqualTo(1);
+			assertThat(args).hasSize(1);
 			assertThat(method.getName()).isEqualTo("doSomething");
 			lastArg = args[0];
 			return null;

spring-context/src/test/java/org/springframework/context/annotation/ClassPathBeanDefinitionScannerTests.java

@@ -473,7 +473,7 @@ public class ClassPathBeanDefinitionScannerTests {
 		assertThat(fooService.eventPublisher).isSameAs(context);
 		assertThat(fooService.messageSource).isSameAs(ms);
 		assertThat(fooService.context).isSameAs(context);
-		assertThat(fooService.configurableContext.length).isEqualTo(1);
+		assertThat(fooService.configurableContext).hasSize(1);
 		assertThat(fooService.configurableContext[0]).isSameAs(context);
 		assertThat(fooService.genericContext).isSameAs(context);
 	}

spring-context/src/test/java/org/springframework/context/annotation/CommonAnnotationBeanPostProcessorTests.java

@@ -232,7 +232,7 @@ public class CommonAnnotationBeanPostProcessorTests {
 		assertThat(tb).isNotSameAs(anotherBean.getTestBean6());
 
 		String[] depBeans = bf.getDependenciesForBean("annotatedBean");
-		assertThat(depBeans.length).isEqualTo(1);
+		assertThat(depBeans).hasSize(1);
 		assertThat(depBeans[0]).isEqualTo("testBean4");
 	}
 

spring-context/src/test/java/org/springframework/context/annotation/ConfigurationClassPostProcessorTests.java

@@ -647,11 +647,11 @@ class ConfigurationClassPostProcessorTests {
 		assertThat(beanNames).contains("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 	}
 
@@ -665,11 +665,11 @@ class ConfigurationClassPostProcessorTests {
 		assertThat(beanNames).contains("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 	}
 
@@ -682,10 +682,10 @@ class ConfigurationClassPostProcessorTests {
 		assertThat(beanNames).contains("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(0);
+		assertThat(beanNames).hasSize(0);
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(0);
+		assertThat(beanNames).hasSize(0);
 	}
 
 	@Test
@@ -698,11 +698,11 @@ class ConfigurationClassPostProcessorTests {
 		assertThat(beanNames).contains("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 	}
 
@@ -715,11 +715,11 @@ class ConfigurationClassPostProcessorTests {
 		assertThat(beanNames).contains("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 	}
 
@@ -733,11 +733,11 @@ class ConfigurationClassPostProcessorTests {
 		assertThat(beanNames).contains("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 	}
 
@@ -755,11 +755,11 @@ class ConfigurationClassPostProcessorTests {
 		assertThat(beanNames).contains("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		assertThat(AopUtils.isCglibProxy(beanFactory.getBean("stringRepo"))).isTrue();
@@ -780,11 +780,11 @@ class ConfigurationClassPostProcessorTests {
 		assertThat(beanNames).contains("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		assertThat(AopUtils.isCglibProxy(beanFactory.getBean("stringRepo"))).isTrue();
@@ -805,11 +805,11 @@ class ConfigurationClassPostProcessorTests {
 		assertThat(beanNames).contains("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		assertThat(AopUtils.isCglibProxy(beanFactory.getBean("stringRepo"))).isTrue();
@@ -830,11 +830,11 @@ class ConfigurationClassPostProcessorTests {
 		assertThat(beanNames).contains("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		assertThat(AopUtils.isCglibProxy(beanFactory.getBean("stringRepo"))).isTrue();
@@ -853,11 +853,11 @@ class ConfigurationClassPostProcessorTests {
 		assertThat(beanNames).contains("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		assertThat(AopUtils.isJdkDynamicProxy(beanFactory.getBean("stringRepo"))).isTrue();
@@ -877,11 +877,11 @@ class ConfigurationClassPostProcessorTests {
 		assertThat(beanNames).contains("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		assertThat(AopUtils.isJdkDynamicProxy(beanFactory.getBean("stringRepo"))).isTrue();
@@ -901,11 +901,11 @@ class ConfigurationClassPostProcessorTests {
 		assertThat(beanNames).contains("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		assertThat(AopUtils.isJdkDynamicProxy(beanFactory.getBean("stringRepo"))).isTrue();
@@ -925,11 +925,11 @@ class ConfigurationClassPostProcessorTests {
 		assertThat(beanNames).contains("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("stringRepo");
 
 		assertThat(AopUtils.isJdkDynamicProxy(beanFactory.getBean("stringRepo"))).isTrue();
@@ -1030,7 +1030,7 @@ class ConfigurationClassPostProcessorTests {
 		ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(VarargConfiguration.class, TestBean.class);
 		VarargConfiguration bean = ctx.getBean(VarargConfiguration.class);
 		assertThat(bean.testBeans).isNotNull();
-		assertThat(bean.testBeans.length).isEqualTo(1);
+		assertThat(bean.testBeans).hasSize(1);
 		assertThat(bean.testBeans[0]).isSameAs(ctx.getBean(TestBean.class));
 		ctx.close();
 	}
@@ -1040,7 +1040,7 @@ class ConfigurationClassPostProcessorTests {
 		ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(VarargConfiguration.class);
 		VarargConfiguration bean = ctx.getBean(VarargConfiguration.class);
 		assertThat(bean.testBeans).isNotNull();
-		assertThat(bean.testBeans.length).isEqualTo(0);
+		assertThat(bean.testBeans).hasSize(0);
 		ctx.close();
 	}
 

spring-context/src/test/java/org/springframework/context/annotation/configuration/ConfigurationClassProcessingTests.java

@@ -172,15 +172,15 @@ class ConfigurationClassProcessingTests {
 		assertThat(condition).isTrue();
 
 		String[] beanNames = factory.getBeanNamesForType(FactoryBean.class);
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("&factoryBean");
 
 		beanNames = factory.getBeanNamesForType(BeanClassLoaderAware.class);
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("&factoryBean");
 
 		beanNames = factory.getBeanNamesForType(ListFactoryBean.class);
-		assertThat(beanNames.length).isEqualTo(1);
+		assertThat(beanNames).hasSize(1);
 		assertThat(beanNames[0]).isEqualTo("&factoryBean");
 
 		beanNames = factory.getBeanNamesForType(List.class);

spring-context/src/test/java/org/springframework/context/support/ClassPathXmlApplicationContextTests.java

@@ -261,11 +261,11 @@ public class ClassPathXmlApplicationContextTests {
 		assertThat(myMs).isSameAs(someMs);
 
 		String[] aliases = child.getAliases("someMessageSource");
-		assertThat(aliases.length).isEqualTo(2);
+		assertThat(aliases).hasSize(2);
 		assertThat(aliases[0]).isEqualTo("myMessageSource");
 		assertThat(aliases[1]).isEqualTo("yourMessageSource");
 		aliases = child.getAliases("myMessageSource");
-		assertThat(aliases.length).isEqualTo(2);
+		assertThat(aliases).hasSize(2);
 		assertThat(aliases[0]).isEqualTo("someMessageSource");
 		assertThat(aliases[1]).isEqualTo("yourMessageSource");
 
@@ -299,16 +299,16 @@ public class ClassPathXmlApplicationContextTests {
 
 	private void assertOneMessageSourceOnly(ClassPathXmlApplicationContext ctx, Object myMessageSource) {
 		String[] beanNamesForType = ctx.getBeanNamesForType(StaticMessageSource.class);
-		assertThat(beanNamesForType.length).isEqualTo(1);
+		assertThat(beanNamesForType).hasSize(1);
 		assertThat(beanNamesForType[0]).isEqualTo("myMessageSource");
 		beanNamesForType = ctx.getBeanNamesForType(StaticMessageSource.class, true, true);
-		assertThat(beanNamesForType.length).isEqualTo(1);
+		assertThat(beanNamesForType).hasSize(1);
 		assertThat(beanNamesForType[0]).isEqualTo("myMessageSource");
 		beanNamesForType = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(ctx, StaticMessageSource.class);
-		assertThat(beanNamesForType.length).isEqualTo(1);
+		assertThat(beanNamesForType).hasSize(1);
 		assertThat(beanNamesForType[0]).isEqualTo("myMessageSource");
 		beanNamesForType = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(ctx, StaticMessageSource.class, true, true);
-		assertThat(beanNamesForType.length).isEqualTo(1);
+		assertThat(beanNamesForType).hasSize(1);
 		assertThat(beanNamesForType[0]).isEqualTo("myMessageSource");
 
 		Map<?, StaticMessageSource> beansOfType = ctx.getBeansOfType(StaticMessageSource.class);

spring-context/src/test/java/org/springframework/ui/ModelMapTests.java

@@ -108,7 +108,7 @@ public class ModelMapTests {
 		assertThat(model).hasSize(1);
 		String[] strings = (String[]) model.get("stringList");
 		assertThat(strings).isNotNull();
-		assertThat(strings.length).isEqualTo(2);
+		assertThat(strings).hasSize(2);
 		assertThat(strings[0]).isEqualTo("foo");
 		assertThat(strings[1]).isEqualTo("boing");
 	}
@@ -134,7 +134,7 @@ public class ModelMapTests {
 		assertThat(model).hasSize(1);
 		int[] ints = (int[]) model.get("intList");
 		assertThat(ints).isNotNull();
-		assertThat(ints.length).isEqualTo(0);
+		assertThat(ints).hasSize(0);
 	}
 
 	@Test

spring-context/src/test/java/org/springframework/validation/DataBinderTests.java

@@ -1724,7 +1724,7 @@ class DataBinderTests {
 		pvs.add("stringArray", new String[] {"a1", "b2"});
 		binder.bind(pvs);
 		assertThat(binder.getBindingResult().hasErrors()).isFalse();
-		assertThat(tb.getStringArray().length).isEqualTo(2);
+		assertThat(tb.getStringArray()).hasSize(2);
 		assertThat(tb.getStringArray()[0]).isEqualTo("Xa1");
 		assertThat(tb.getStringArray()[1]).isEqualTo("Xb2");
 	}

spring-core/src/test/java/org/springframework/core/GenericTypeResolverTests.java

@@ -168,7 +168,7 @@ class GenericTypeResolverTests {
 	void resolveIncompleteTypeVariables() {
 		Class<?>[] resolved = GenericTypeResolver.resolveTypeArguments(IdFixingRepository.class, Repository.class);
 		assertThat(resolved).isNotNull();
-		assertThat(resolved.length).isEqualTo(2);
+		assertThat(resolved).hasSize(2);
 		assertThat(resolved[0]).isEqualTo(Object.class);
 		assertThat(resolved[1]).isEqualTo(Long.class);
 	}

spring-core/src/test/java/org/springframework/core/LocalVariableTableParameterNameDiscovererTests.java

@@ -162,23 +162,23 @@ class LocalVariableTableParameterNameDiscovererTests {
 
 		Constructor<?> ctor = clazz.getDeclaredConstructor(Object.class);
 		String[] names = discoverer.getParameterNames(ctor);
-		assertThat(names.length).isEqualTo(1);
+		assertThat(names).hasSize(1);
 		assertThat(names[0]).isEqualTo("key");
 
 		ctor = clazz.getDeclaredConstructor(Object.class, Object.class);
 		names = discoverer.getParameterNames(ctor);
-		assertThat(names.length).isEqualTo(2);
+		assertThat(names).hasSize(2);
 		assertThat(names[0]).isEqualTo("key");
 		assertThat(names[1]).isEqualTo("value");
 
 		Method m = clazz.getMethod("generifiedStaticMethod", Object.class);
 		names = discoverer.getParameterNames(m);
-		assertThat(names.length).isEqualTo(1);
+		assertThat(names).hasSize(1);
 		assertThat(names[0]).isEqualTo("param");
 
 		m = clazz.getMethod("generifiedMethod", Object.class, long.class, Object.class, Object.class);
 		names = discoverer.getParameterNames(m);
-		assertThat(names.length).isEqualTo(4);
+		assertThat(names).hasSize(4);
 		assertThat(names[0]).isEqualTo("param");
 		assertThat(names[1]).isEqualTo("x");
 		assertThat(names[2]).isEqualTo("key");
@@ -186,21 +186,21 @@ class LocalVariableTableParameterNameDiscovererTests {
 
 		m = clazz.getMethod("voidStaticMethod", Object.class, long.class, int.class);
 		names = discoverer.getParameterNames(m);
-		assertThat(names.length).isEqualTo(3);
+		assertThat(names).hasSize(3);
 		assertThat(names[0]).isEqualTo("obj");
 		assertThat(names[1]).isEqualTo("x");
 		assertThat(names[2]).isEqualTo("i");
 
 		m = clazz.getMethod("nonVoidStaticMethod", Object.class, long.class, int.class);
 		names = discoverer.getParameterNames(m);
-		assertThat(names.length).isEqualTo(3);
+		assertThat(names).hasSize(3);
 		assertThat(names[0]).isEqualTo("obj");
 		assertThat(names[1]).isEqualTo("x");
 		assertThat(names[2]).isEqualTo("i");
 
 		m = clazz.getMethod("getDate");
 		names = discoverer.getParameterNames(m);
-		assertThat(names.length).isEqualTo(0);
+		assertThat(names).hasSize(0);
 	}
 
 	@Disabled("Ignored because Ubuntu packages OpenJDK with debug symbols enabled. See SPR-8078.")

spring-core/src/test/java/org/springframework/core/ResolvableTypeTests.java

@@ -535,7 +535,7 @@ class ResolvableTypeTests {
 	void getGenericsFromParameterizedType() throws Exception {
 		ResolvableType type = ResolvableType.forClass(List.class, ExtendsList.class);
 		ResolvableType[] generics = type.getGenerics();
-		assertThat(generics.length).isEqualTo(1);
+		assertThat(generics).hasSize(1);
 		assertThat(generics[0].resolve()).isEqualTo(CharSequence.class);
 	}
 
@@ -543,7 +543,7 @@ class ResolvableTypeTests {
 	void getGenericsFromClass() throws Exception {
 		ResolvableType type = ResolvableType.forClass(List.class);
 		ResolvableType[] generics = type.getGenerics();
-		assertThat(generics.length).isEqualTo(1);
+		assertThat(generics).hasSize(1);
 		assertThat(generics[0].getType().toString()).isEqualTo("E");
 	}
 
@@ -558,7 +558,7 @@ class ResolvableTypeTests {
 	void getResolvedGenerics() throws Exception {
 		ResolvableType type = ResolvableType.forClass(List.class, ExtendsList.class);
 		Class<?>[] generics = type.resolveGenerics();
-		assertThat(generics.length).isEqualTo(1);
+		assertThat(generics).hasSize(1);
 		assertThat(generics[0]).isEqualTo(CharSequence.class);
 	}
 
@@ -1307,7 +1307,7 @@ class ResolvableTypeTests {
 		Type type = resolvableType.getType();
 		assertThat(type).isInstanceOf(ParameterizedType.class);
 		assertThat(((ParameterizedType) type).getRawType()).isEqualTo(Callable.class);
-		assertThat(((ParameterizedType) type).getActualTypeArguments().length).isEqualTo(1);
+		assertThat(((ParameterizedType) type).getActualTypeArguments()).hasSize(1);
 		assertThat(((ParameterizedType) type).getActualTypeArguments()[0]).isEqualTo(String.class);
 	}
 

spring-core/src/test/java/org/springframework/core/annotation/AnnotationAttributesTests.java

@@ -108,12 +108,12 @@ class AnnotationAttributesTests {
 
 		AnnotationAttributes[] array = attributes.getAnnotationArray("nestedAttributes");
 		assertThat(array).isNotNull();
-		assertThat(array.length).isEqualTo(1);
+		assertThat(array).hasSize(1);
 		assertThat(array[0].getString("name")).isEqualTo("Dilbert");
 
 		Filter[] filters = attributes.getAnnotationArray("filters", Filter.class);
 		assertThat(filters).isNotNull();
-		assertThat(filters.length).isEqualTo(1);
+		assertThat(filters).hasSize(1);
 		assertThat(filters[0].pattern()).isEqualTo("foo");
 	}
 
@@ -130,7 +130,7 @@ class AnnotationAttributesTests {
 
 		Filter[] retrievedFilters = attributes.getAnnotationArray("filters", Filter.class);
 		assertThat(retrievedFilters).isNotNull();
-		assertThat(retrievedFilters.length).isEqualTo(2);
+		assertThat(retrievedFilters).hasSize(2);
 		assertThat(retrievedFilters[1].pattern()).isEqualTo("foo");
 	}
 

spring-core/src/test/java/org/springframework/core/annotation/AnnotationUtilsTests.java

@@ -507,7 +507,7 @@ class AnnotationUtilsTests {
 	@Test
 	void getValueFromNonPublicAnnotation() throws Exception {
 		Annotation[] declaredAnnotations = NonPublicAnnotatedClass.class.getDeclaredAnnotations();
-		assertThat(declaredAnnotations.length).isEqualTo(1);
+		assertThat(declaredAnnotations).hasSize(1);
 		Annotation annotation = declaredAnnotations[0];
 		assertThat(annotation).isNotNull();
 		assertThat(annotation.annotationType().getSimpleName()).isEqualTo("NonPublicAnnotation");
@@ -527,7 +527,7 @@ class AnnotationUtilsTests {
 	@Test
 	void getDefaultValueFromNonPublicAnnotation() {
 		Annotation[] declaredAnnotations = NonPublicAnnotatedClass.class.getDeclaredAnnotations();
-		assertThat(declaredAnnotations.length).isEqualTo(1);
+		assertThat(declaredAnnotations).hasSize(1);
 		Annotation annotation = declaredAnnotations[0];
 		assertThat(annotation).isNotNull();
 		assertThat(annotation.annotationType().getSimpleName()).isEqualTo("NonPublicAnnotation");
@@ -706,7 +706,7 @@ class AnnotationUtilsTests {
 		// Java 8
 		MyRepeatable[] array = clazz.getDeclaredAnnotationsByType(MyRepeatable.class);
 		assertThat(array).isNotNull();
-		assertThat(array.length).isEqualTo(0);
+		assertThat(array).hasSize(0);
 
 		// Spring
 		Set<MyRepeatable> set = getDeclaredRepeatableAnnotations(clazz, MyRepeatable.class, MyRepeatableContainer.class);

spring-core/src/test/java/org/springframework/core/convert/TypeDescriptorTests.java

@@ -65,7 +65,7 @@ class TypeDescriptorTests {
 		assertThat(desc.getName()).isEqualTo("int");
 		assertThat(desc.toString()).isEqualTo("int");
 		assertThat(desc.isPrimitive()).isTrue();
-		assertThat(desc.getAnnotations().length).isEqualTo(0);
+		assertThat(desc.getAnnotations()).hasSize(0);
 		assertThat(desc.isCollection()).isFalse();
 		assertThat(desc.isMap()).isFalse();
 	}
@@ -78,7 +78,7 @@ class TypeDescriptorTests {
 		assertThat(desc.getName()).isEqualTo("java.lang.String");
 		assertThat(desc.toString()).isEqualTo("java.lang.String");
 		assertThat(!desc.isPrimitive()).isTrue();
-		assertThat(desc.getAnnotations().length).isEqualTo(0);
+		assertThat(desc.getAnnotations()).hasSize(0);
 		assertThat(desc.isCollection()).isFalse();
 		assertThat(desc.isArray()).isFalse();
 		assertThat(desc.isMap()).isFalse();
@@ -93,7 +93,7 @@ class TypeDescriptorTests {
 		assertThat(desc.getName()).isEqualTo("java.util.List");
 		assertThat(desc.toString()).isEqualTo("java.util.List<java.util.List<java.util.Map<java.lang.Integer, java.lang.Enum<?>>>>");
 		assertThat(!desc.isPrimitive()).isTrue();
-		assertThat(desc.getAnnotations().length).isEqualTo(0);
+		assertThat(desc.getAnnotations()).hasSize(0);
 		assertThat(desc.isCollection()).isTrue();
 		assertThat(desc.isArray()).isFalse();
 		assertThat(desc.getElementTypeDescriptor().getType()).isEqualTo(List.class);
@@ -114,7 +114,7 @@ class TypeDescriptorTests {
 		assertThat(desc.getName()).isEqualTo("java.util.List");
 		assertThat(desc.toString()).isEqualTo("java.util.List<?>");
 		assertThat(!desc.isPrimitive()).isTrue();
-		assertThat(desc.getAnnotations().length).isEqualTo(0);
+		assertThat(desc.getAnnotations()).hasSize(0);
 		assertThat(desc.isCollection()).isTrue();
 		assertThat(desc.isArray()).isFalse();
 		assertThat((Object) desc.getElementTypeDescriptor()).isNull();
@@ -130,7 +130,7 @@ class TypeDescriptorTests {
 		assertThat(desc.getName()).isEqualTo("java.lang.Integer[]");
 		assertThat(desc.toString()).isEqualTo("java.lang.Integer[]");
 		assertThat(!desc.isPrimitive()).isTrue();
-		assertThat(desc.getAnnotations().length).isEqualTo(0);
+		assertThat(desc.getAnnotations()).hasSize(0);
 		assertThat(desc.isCollection()).isFalse();
 		assertThat(desc.isArray()).isTrue();
 		assertThat(desc.getElementTypeDescriptor().getType()).isEqualTo(Integer.class);
@@ -147,7 +147,7 @@ class TypeDescriptorTests {
 		assertThat(desc.getName()).isEqualTo("java.util.Map");
 		assertThat(desc.toString()).isEqualTo("java.util.Map<java.lang.Integer, java.util.List<java.lang.String>>");
 		assertThat(!desc.isPrimitive()).isTrue();
-		assertThat(desc.getAnnotations().length).isEqualTo(0);
+		assertThat(desc.getAnnotations()).hasSize(0);
 		assertThat(desc.isCollection()).isFalse();
 		assertThat(desc.isArray()).isFalse();
 		assertThat(desc.isMap()).isTrue();
@@ -162,7 +162,7 @@ class TypeDescriptorTests {
 	void parameterAnnotated() throws Exception {
 		TypeDescriptor t1 = new TypeDescriptor(new MethodParameter(getClass().getMethod("testAnnotatedMethod", String.class), 0));
 		assertThat(t1.getType()).isEqualTo(String.class);
-		assertThat(t1.getAnnotations().length).isEqualTo(1);
+		assertThat(t1.getAnnotations()).hasSize(1);
 		assertThat(t1.getAnnotation(ParameterAnnotation.class)).isNotNull();
 		assertThat(t1.hasAnnotation(ParameterAnnotation.class)).isTrue();
 		assertThat(t1.getAnnotation(ParameterAnnotation.class).value()).isEqualTo(123);
@@ -335,7 +335,7 @@ class TypeDescriptorTests {
 	@Test
 	void fieldAnnotated() throws Exception {
 		TypeDescriptor typeDescriptor = new TypeDescriptor(getClass().getField("fieldAnnotated"));
-		assertThat(typeDescriptor.getAnnotations().length).isEqualTo(1);
+		assertThat(typeDescriptor.getAnnotations()).hasSize(1);
 		assertThat(typeDescriptor.getAnnotation(FieldAnnotation.class)).isNotNull();
 	}
 
@@ -463,7 +463,7 @@ class TypeDescriptorTests {
 		assertThat(desc.getName()).isEqualTo("java.util.List");
 		assertThat(desc.toString()).isEqualTo("java.util.List<java.lang.Integer>");
 		assertThat(!desc.isPrimitive()).isTrue();
-		assertThat(desc.getAnnotations().length).isEqualTo(0);
+		assertThat(desc.getAnnotations()).hasSize(0);
 		assertThat(desc.isCollection()).isTrue();
 		assertThat(desc.isArray()).isFalse();
 		assertThat(desc.getElementTypeDescriptor().getType()).isEqualTo(Integer.class);
@@ -479,7 +479,7 @@ class TypeDescriptorTests {
 		assertThat(desc.getName()).isEqualTo("java.util.List");
 		assertThat(desc.toString()).isEqualTo("java.util.List<java.util.List<java.lang.Integer>>");
 		assertThat(!desc.isPrimitive()).isTrue();
-		assertThat(desc.getAnnotations().length).isEqualTo(0);
+		assertThat(desc.getAnnotations()).hasSize(0);
 		assertThat(desc.isCollection()).isTrue();
 		assertThat(desc.isArray()).isFalse();
 		assertThat(desc.getElementTypeDescriptor().getType()).isEqualTo(List.class);
@@ -495,7 +495,7 @@ class TypeDescriptorTests {
 		assertThat(desc.getName()).isEqualTo("java.util.Map");
 		assertThat(desc.toString()).isEqualTo("java.util.Map<java.lang.String, java.lang.Integer>");
 		assertThat(!desc.isPrimitive()).isTrue();
-		assertThat(desc.getAnnotations().length).isEqualTo(0);
+		assertThat(desc.getAnnotations()).hasSize(0);
 		assertThat(desc.isCollection()).isFalse();
 		assertThat(desc.isArray()).isFalse();
 		assertThat(desc.isMap()).isTrue();
@@ -512,7 +512,7 @@ class TypeDescriptorTests {
 		assertThat(desc.getName()).isEqualTo("java.util.Map");
 		assertThat(desc.toString()).isEqualTo("java.util.Map<java.lang.String, java.util.Map<java.lang.String, java.lang.Integer>>");
 		assertThat(!desc.isPrimitive()).isTrue();
-		assertThat(desc.getAnnotations().length).isEqualTo(0);
+		assertThat(desc.getAnnotations()).hasSize(0);
 		assertThat(desc.isCollection()).isFalse();
 		assertThat(desc.isArray()).isFalse();
 		assertThat(desc.isMap()).isTrue();

spring-core/src/test/java/org/springframework/core/convert/converter/DefaultConversionServiceTests.java

@@ -452,7 +452,7 @@ class DefaultConversionServiceTests {
 	@Test
 	void convertObjectToArray() {
 		Object[] result = conversionService.convert(3L, Object[].class);
-		assertThat(result.length).isEqualTo(1);
+		assertThat(result).hasSize(1);
 		assertThat(result[0]).isEqualTo(3L);
 	}
 

spring-core/src/test/java/org/springframework/core/convert/support/GenericConversionServiceTests.java

@@ -335,7 +335,7 @@ class GenericConversionServiceTests {
 		TypeDescriptor sourceType = TypeDescriptor.forObject(list);
 		TypeDescriptor targetType = TypeDescriptor.valueOf(String[].class);
 		assertThat(conversionService.canConvert(sourceType, targetType)).isTrue();
-		assertThat(((String[]) conversionService.convert(list, sourceType, targetType)).length).isEqualTo(0);
+		assertThat(((String[]) conversionService.convert(list, sourceType, targetType))).hasSize(0);
 	}
 
 	@Test

spring-core/src/test/java/org/springframework/core/env/StandardEnvironmentTests.java

@@ -113,12 +113,12 @@ public class StandardEnvironmentTests {
 
 	@Test
 	void activeProfilesIsEmptyByDefault() {
-		assertThat(environment.getActiveProfiles().length).isEqualTo(0);
+		assertThat(environment.getActiveProfiles()).hasSize(0);
 	}
 
 	@Test
 	void defaultProfilesContainsDefaultProfileByDefault() {
-		assertThat(environment.getDefaultProfiles().length).isEqualTo(1);
+		assertThat(environment.getDefaultProfiles()).hasSize(1);
 		assertThat(environment.getDefaultProfiles()[0]).isEqualTo("default");
 	}
 
@@ -127,7 +127,7 @@ public class StandardEnvironmentTests {
 		environment.setActiveProfiles("local", "embedded");
 		String[] activeProfiles = environment.getActiveProfiles();
 		assertThat(activeProfiles).contains("local", "embedded");
-		assertThat(activeProfiles.length).isEqualTo(2);
+		assertThat(activeProfiles).hasSize(2);
 	}
 
 	@Test
@@ -172,17 +172,17 @@ public class StandardEnvironmentTests {
 
 	@Test
 	void addActiveProfile() {
-		assertThat(environment.getActiveProfiles().length).isEqualTo(0);
+		assertThat(environment.getActiveProfiles()).hasSize(0);
 		environment.setActiveProfiles("local", "embedded");
 		assertThat(environment.getActiveProfiles()).contains("local", "embedded");
-		assertThat(environment.getActiveProfiles().length).isEqualTo(2);
+		assertThat(environment.getActiveProfiles()).hasSize(2);
 		environment.addActiveProfile("p1");
 		assertThat(environment.getActiveProfiles()).contains("p1");
-		assertThat(environment.getActiveProfiles().length).isEqualTo(3);
+		assertThat(environment.getActiveProfiles()).hasSize(3);
 		environment.addActiveProfile("p2");
 		environment.addActiveProfile("p3");
 		assertThat(environment.getActiveProfiles()).contains("p2", "p3");
-		assertThat(environment.getActiveProfiles().length).isEqualTo(5);
+		assertThat(environment.getActiveProfiles()).hasSize(5);
 	}
 
 	@Test
@@ -218,9 +218,9 @@ public class StandardEnvironmentTests {
 
 	@Test
 	void getActiveProfiles_systemPropertiesEmpty() {
-		assertThat(environment.getActiveProfiles().length).isEqualTo(0);
+		assertThat(environment.getActiveProfiles()).hasSize(0);
 		System.setProperty(ACTIVE_PROFILES_PROPERTY_NAME, "");
-		assertThat(environment.getActiveProfiles().length).isEqualTo(0);
+		assertThat(environment.getActiveProfiles()).hasSize(0);
 		System.clearProperty(ACTIVE_PROFILES_PROPERTY_NAME);
 	}
 
@@ -249,14 +249,14 @@ public class StandardEnvironmentTests {
 	void getDefaultProfiles() {
 		assertThat(environment.getDefaultProfiles()).isEqualTo(new String[] {RESERVED_DEFAULT_PROFILE_NAME});
 		environment.getPropertySources().addFirst(new MockPropertySource().withProperty(DEFAULT_PROFILES_PROPERTY_NAME, "pd1"));
-		assertThat(environment.getDefaultProfiles().length).isEqualTo(1);
+		assertThat(environment.getDefaultProfiles()).hasSize(1);
 		assertThat(Arrays.asList(environment.getDefaultProfiles())).contains("pd1");
 	}
 
 	@Test
 	void setDefaultProfiles() {
 		environment.setDefaultProfiles();
-		assertThat(environment.getDefaultProfiles().length).isEqualTo(0);
+		assertThat(environment.getDefaultProfiles()).hasSize(0);
 		environment.setDefaultProfiles("pd1");
 		assertThat(Arrays.asList(environment.getDefaultProfiles())).contains("pd1");
 		environment.setDefaultProfiles("pd2", "pd3");

spring-core/src/test/java/org/springframework/core/type/AnnotationMetadataTests.java

@@ -90,7 +90,7 @@ class AnnotationMetadataTests {
 		assertThat(metadata.isConcrete()).isTrue();
 		assertThat(metadata.hasSuperClass()).isTrue();
 		assertThat(metadata.getSuperClassName()).isEqualTo(AnnotatedComponent.class.getName());
-		assertThat(metadata.getInterfaceNames().length).isEqualTo(0);
+		assertThat(metadata.getInterfaceNames()).hasSize(0);
 		assertThat(metadata.isAnnotated(Component.class.getName())).isFalse();
 		assertThat(metadata.isAnnotated(Scope.class.getName())).isFalse();
 		assertThat(metadata.isAnnotated(SpecialAttr.class.getName())).isFalse();
@@ -141,7 +141,7 @@ class AnnotationMetadataTests {
 		assertThat(metadata.isConcrete()).isFalse();
 		assertThat(metadata.hasSuperClass()).isFalse();
 		assertThat(metadata.getSuperClassName()).isNull();
-		assertThat(metadata.getInterfaceNames().length).isEqualTo(2);
+		assertThat(metadata.getInterfaceNames()).hasSize(2);
 		assertThat(metadata.getInterfaceNames()[0]).isEqualTo(ClassMetadata.class.getName());
 		assertThat(metadata.getInterfaceNames()[1]).isEqualTo(AnnotatedTypeMetadata.class.getName());
 		assertThat(metadata.getAnnotationTypes()).hasSize(0);
@@ -169,7 +169,7 @@ class AnnotationMetadataTests {
 		assertThat(metadata.isConcrete()).isFalse();
 		assertThat(metadata.hasSuperClass()).isFalse();
 		assertThat(metadata.getSuperClassName()).isNull();
-		assertThat(metadata.getInterfaceNames().length).isEqualTo(1);
+		assertThat(metadata.getInterfaceNames()).hasSize(1);
 		assertThat(metadata.getInterfaceNames()[0]).isEqualTo(Annotation.class.getName());
 		assertThat(metadata.isAnnotated(Documented.class.getName())).isFalse();
 		assertThat(metadata.isAnnotated(Scope.class.getName())).isFalse();
@@ -287,7 +287,7 @@ class AnnotationMetadataTests {
 		assertThat(metadata.isConcrete()).isTrue();
 		assertThat(metadata.hasSuperClass()).isTrue();
 		assertThat(metadata.getSuperClassName()).isEqualTo(Object.class.getName());
-		assertThat(metadata.getInterfaceNames().length).isEqualTo(1);
+		assertThat(metadata.getInterfaceNames()).hasSize(1);
 		assertThat(metadata.getInterfaceNames()[0]).isEqualTo(Serializable.class.getName());
 
 		assertThat(metadata.isAnnotated(Component.class.getName())).isTrue();
@@ -335,7 +335,7 @@ class AnnotationMetadataTests {
 			assertThat((Class<?>[]) nestedAnno.get("classArray")).isEqualTo(new Class<?>[] {String.class});
 
 			AnnotationAttributes[] nestedAnnoArray = specialAttrs.getAnnotationArray("nestedAnnoArray");
-			assertThat(nestedAnnoArray.length).isEqualTo(2);
+			assertThat(nestedAnnoArray).hasSize(2);
 			assertThat(nestedAnnoArray[0].getString("value")).isEqualTo("default");
 			assertThat(nestedAnnoArray[0].getEnum("anEnum").equals(SomeEnum.DEFAULT)).isTrue();
 			assertThat((Class<?>[]) nestedAnnoArray[0].get("classArray")).isEqualTo(new Class<?>[] {Void.class});
@@ -351,7 +351,7 @@ class AnnotationMetadataTests {
 			assertThat(optional.getClassArray("classArray")).isEqualTo(new Class<?>[] {Void.class});
 
 			AnnotationAttributes[] optionalArray = specialAttrs.getAnnotationArray("optionalArray");
-			assertThat(optionalArray.length).isEqualTo(1);
+			assertThat(optionalArray).hasSize(1);
 			assertThat(optionalArray[0].getString("value")).isEqualTo("optional");
 			assertThat(optionalArray[0].getEnum("anEnum").equals(SomeEnum.DEFAULT)).isTrue();
 			assertThat((Class<?>[]) optionalArray[0].get("classArray")).isEqualTo(new Class<?>[] {Void.class});
@@ -363,7 +363,7 @@ class AnnotationMetadataTests {
 			allMeta = metadata.getAllAnnotationAttributes(DirectAnnotation.class.getName()).get("additional");
 			assertThat(new HashSet<>(allMeta)).isEqualTo(new HashSet<Object>(Arrays.asList("direct", "")));
 			assertThat(metadata.getAnnotationAttributes(DirectAnnotation.class.getName()).get("additional")).isEqualTo("");
-			assertThat(((String[]) metadata.getAnnotationAttributes(DirectAnnotation.class.getName()).get("additionalArray")).length).isEqualTo(0);
+			assertThat(((String[]) metadata.getAnnotationAttributes(DirectAnnotation.class.getName()).get("additionalArray"))).hasSize(0);
 		}
 		{ // perform tests with classValuesAsString = true
 			AnnotationAttributes specialAttrs = (AnnotationAttributes) metadata.getAnnotationAttributes(

spring-core/src/test/java/org/springframework/util/FastByteArrayOutputStreamTests.java

@@ -45,7 +45,7 @@ class FastByteArrayOutputStreamTests {
 	@Test
 	void size() throws Exception {
 		this.os.write(this.helloBytes);
-		assertThat(this.helloBytes.length).isEqualTo(this.os.size());
+		assertThat(this.helloBytes).hasSize(this.os.size());
 	}
 
 	@Test
@@ -123,7 +123,7 @@ class FastByteArrayOutputStreamTests {
 	@Test
 	void getInputStreamAvailable() throws Exception {
 		this.os.write(this.helloBytes);
-		assertThat(this.helloBytes.length).isEqualTo(this.os.getInputStream().available());
+		assertThat(this.helloBytes).hasSize(this.os.getInputStream().available());
 	}
 
 	@Test

spring-core/src/test/java/org/springframework/util/ObjectUtilsTests.java

@@ -151,7 +151,7 @@ class ObjectUtilsTests {
 	void toObjectArrayWithNull() {
 		Object[] objects = ObjectUtils.toObjectArray(null);
 		assertThat(objects).isNotNull();
-		assertThat(objects.length).isEqualTo(0);
+		assertThat(objects).hasSize(0);
 	}
 
 	@Test

spring-core/src/test/java/org/springframework/util/StringUtilsTests.java

@@ -441,7 +441,7 @@ class StringUtilsTests {
 		String[] input1 = new String[] {"myString2"};
 		String[] input2 = new String[] {"myString1", "myString2"};
 		String[] result = StringUtils.concatenateStringArrays(input1, input2);
-		assertThat(result.length).isEqualTo(3);
+		assertThat(result).hasSize(3);
 		assertThat(result[0]).isEqualTo("myString2");
 		assertThat(result[1]).isEqualTo("myString1");
 		assertThat(result[2]).isEqualTo("myString2");
@@ -490,21 +490,21 @@ class StringUtilsTests {
 	@Test
 	void tokenizeToStringArray() {
 		String[] sa = StringUtils.tokenizeToStringArray("a,b , ,c", ",");
-		assertThat(sa.length).isEqualTo(3);
+		assertThat(sa).hasSize(3);
 		assertThat(sa[0].equals("a") && sa[1].equals("b") && sa[2].equals("c")).as("components are correct").isTrue();
 	}
 
 	@Test
 	void tokenizeToStringArrayWithNotIgnoreEmptyTokens() {
 		String[] sa = StringUtils.tokenizeToStringArray("a,b , ,c", ",", true, false);
-		assertThat(sa.length).isEqualTo(4);
+		assertThat(sa).hasSize(4);
 		assertThat(sa[0].equals("a") && sa[1].equals("b") && sa[2].isEmpty() && sa[3].equals("c")).as("components are correct").isTrue();
 	}
 
 	@Test
 	void tokenizeToStringArrayWithNotTrimTokens() {
 		String[] sa = StringUtils.tokenizeToStringArray("a,b ,c", ",", false, true);
-		assertThat(sa.length).isEqualTo(3);
+		assertThat(sa).hasSize(3);
 		assertThat(sa[0].equals("a") && sa[1].equals("b ") && sa[2].equals("c")).as("components are correct").isTrue();
 	}
 
@@ -525,7 +525,7 @@ class StringUtilsTests {
 	@Test
 	void delimitedListToStringArrayWithComma() {
 		String[] sa = StringUtils.delimitedListToStringArray("a,b", ",");
-		assertThat(sa.length).isEqualTo(2);
+		assertThat(sa).hasSize(2);
 		assertThat(sa[0]).isEqualTo("a");
 		assertThat(sa[1]).isEqualTo("b");
 	}
@@ -533,7 +533,7 @@ class StringUtilsTests {
 	@Test
 	void delimitedListToStringArrayWithSemicolon() {
 		String[] sa = StringUtils.delimitedListToStringArray("a;b", ";");
-		assertThat(sa.length).isEqualTo(2);
+		assertThat(sa).hasSize(2);
 		assertThat(sa[0]).isEqualTo("a");
 		assertThat(sa[1]).isEqualTo("b");
 	}
@@ -541,7 +541,7 @@ class StringUtilsTests {
 	@Test
 	void delimitedListToStringArrayWithEmptyDelimiter() {
 		String[] sa = StringUtils.delimitedListToStringArray("a,b", "");
-		assertThat(sa.length).isEqualTo(3);
+		assertThat(sa).hasSize(3);
 		assertThat(sa[0]).isEqualTo("a");
 		assertThat(sa[1]).isEqualTo(",");
 		assertThat(sa[2]).isEqualTo("b");
@@ -550,7 +550,7 @@ class StringUtilsTests {
 	@Test
 	void delimitedListToStringArrayWithNullDelimiter() {
 		String[] sa = StringUtils.delimitedListToStringArray("a,b", null);
-		assertThat(sa.length).isEqualTo(1);
+		assertThat(sa).hasSize(1);
 		assertThat(sa[0]).isEqualTo("a,b");
 	}
 

spring-expression/src/test/java/org/springframework/expression/spel/TemplateExpressionParsingTests.java

@@ -166,7 +166,7 @@ public class TemplateExpressionParsingTests extends AbstractExpressionTests {
 		assertThat(ex.getClass()).isEqualTo(CompositeStringExpression.class);
 		CompositeStringExpression cse = (CompositeStringExpression)ex;
 		Expression[] exprs = cse.getExpressions();
-		assertThat(exprs.length).isEqualTo(3);
+		assertThat(exprs).hasSize(3);
 		assertThat(exprs[1].getExpressionString()).isEqualTo("listOfNumbersUpToTen.$[#root.listOfNumbersUpToTen.$[#this%2==1]==3]");
 		s = ex.getValue(TestScenarioCreator.getTestEvaluationContext(),String.class);
 		assertThat(s).isEqualTo("hello  world");

spring-expression/src/test/java/org/springframework/expression/spel/support/ReflectionHelperTests.java

@@ -253,11 +253,11 @@ public class ReflectionHelperTests extends AbstractExpressionTests {
 		Object[] newArray = ReflectionHelper.setupArgumentsForVarargsInvocation(
 				new Class<?>[] {String[].class}, "a", "b", "c");
 
-		assertThat(newArray.length).isEqualTo(1);
+		assertThat(newArray).hasSize(1);
 		Object firstParam = newArray[0];
 		assertThat(firstParam.getClass().getComponentType()).isEqualTo(String.class);
 		Object[] firstParamArray = (Object[]) firstParam;
-		assertThat(firstParamArray.length).isEqualTo(3);
+		assertThat(firstParamArray).hasSize(3);
 		assertThat(firstParamArray[0]).isEqualTo("a");
 		assertThat(firstParamArray[1]).isEqualTo("b");
 		assertThat(firstParamArray[2]).isEqualTo("c");
@@ -412,7 +412,7 @@ public class ReflectionHelperTests extends AbstractExpressionTests {
 	}
 
 	private void checkArguments(Object[] args, Object... expected) {
-		assertThat(args.length).isEqualTo(expected.length);
+		assertThat(args).hasSize(expected.length);
 		for (int i = 0; i < expected.length; i++) {
 			checkArgument(expected[i],args[i]);
 		}

spring-jdbc/src/test/java/org/springframework/jdbc/core/namedparam/NamedParameterUtilsTests.java

@@ -161,7 +161,7 @@ public class NamedParameterUtilsTests {
 		paramMap.addValue("b", "b");
 		paramMap.addValue("c", "c");
 		Object[] params = NamedParameterUtils.buildValueArray(psql1, paramMap, null);
-		assertThat(params.length).isEqualTo(4);
+		assertThat(params).hasSize(4);
 		assertThat(params[0]).isEqualTo("a");
 		assertThat(params[1]).isEqualTo("b");
 		assertThat(params[2]).isEqualTo("c");

spring-jdbc/src/test/java/org/springframework/jdbc/object/BatchSqlUpdateTests.java

@@ -77,11 +77,11 @@ public class BatchSqlUpdateTests {
 
 		if (flushThroughBatchSize) {
 			assertThat(update.getQueueCount()).isEqualTo(0);
-			assertThat(update.getRowsAffected().length).isEqualTo(2);
+			assertThat(update.getRowsAffected()).hasSize(2);
 		}
 		else {
 			assertThat(update.getQueueCount()).isEqualTo(2);
-			assertThat(update.getRowsAffected().length).isEqualTo(0);
+			assertThat(update.getRowsAffected()).hasSize(0);
 		}
 
 		int[] actualRowsAffected = update.flush();
@@ -102,7 +102,7 @@ public class BatchSqlUpdateTests {
 		assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected[1]);
 
 		update.reset();
-		assertThat(update.getRowsAffected().length).isEqualTo(0);
+		assertThat(update.getRowsAffected()).hasSize(0);
 
 		verify(preparedStatement).setObject(1, ids[0], Types.INTEGER);
 		verify(preparedStatement).setObject(1, ids[1], Types.INTEGER);

spring-jdbc/src/test/java/org/springframework/jdbc/support/SQLErrorCodesFactoryTests.java

@@ -185,7 +185,7 @@ public class SQLErrorCodesFactoryTests {
 		// Should have loaded without error
 		TestSQLErrorCodesFactory sf = new TestSQLErrorCodesFactory();
 		assertThat(sf.getErrorCodes("XX").getBadSqlGrammarCodes().length == 0).isTrue();
-		assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes().length).isEqualTo(2);
+		assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes()).hasSize(2);
 		assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes()[0]).isEqualTo("1");
 		assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes()[1]).isEqualTo("2");
 	}
@@ -206,7 +206,7 @@ public class SQLErrorCodesFactoryTests {
 		// Should have failed to load without error
 		TestSQLErrorCodesFactory sf = new TestSQLErrorCodesFactory();
 		assertThat(sf.getErrorCodes("XX").getBadSqlGrammarCodes().length == 0).isTrue();
-		assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes().length).isEqualTo(0);
+		assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes()).hasSize(0);
 	}
 
 	/**
@@ -226,11 +226,11 @@ public class SQLErrorCodesFactoryTests {
 
 		// Should have loaded without error
 		TestSQLErrorCodesFactory sf = new TestSQLErrorCodesFactory();
-		assertThat(sf.getErrorCodes("Oracle").getCustomTranslations().length).isEqualTo(1);
+		assertThat(sf.getErrorCodes("Oracle").getCustomTranslations()).hasSize(1);
 		CustomSQLErrorCodesTranslation translation =
 				sf.getErrorCodes("Oracle").getCustomTranslations()[0];
 		assertThat(translation.getExceptionClass()).isEqualTo(CustomErrorCodeException.class);
-		assertThat(translation.getErrorCodes().length).isEqualTo(1);
+		assertThat(translation.getErrorCodes()).hasSize(1);
 	}
 
 	@Test
@@ -371,8 +371,8 @@ public class SQLErrorCodesFactoryTests {
 	}
 
 	private void assertIsEmpty(SQLErrorCodes sec) {
-		assertThat(sec.getBadSqlGrammarCodes().length).isEqualTo(0);
-		assertThat(sec.getDataIntegrityViolationCodes().length).isEqualTo(0);
+		assertThat(sec.getBadSqlGrammarCodes()).hasSize(0);
+		assertThat(sec.getDataIntegrityViolationCodes()).hasSize(0);
 	}
 
 }

spring-jms/src/test/java/org/springframework/jms/support/SimpleMessageConverterTests.java

@@ -78,7 +78,7 @@ public class SimpleMessageConverterTests {
 
 		SimpleMessageConverter converter = new SimpleMessageConverter();
 		Message msg = converter.toMessage(content, session);
-		assertThat(((byte[]) converter.fromMessage(msg)).length).isEqualTo(content.length);
+		assertThat(((byte[]) converter.fromMessage(msg))).hasSize(content.length);
 
 		verify(message).writeBytes(content);
 	}

spring-messaging/src/test/java/org/springframework/messaging/simp/SimpAttributesTests.java

@@ -82,7 +82,7 @@ public class SimpAttributesTests {
 		this.simpAttributes.registerDestructionCallback("name1", callback1);
 		this.simpAttributes.registerDestructionCallback("name2", callback2);
 
-		assertThat(this.simpAttributes.getAttributeNames().length).isEqualTo(2);
+		assertThat(this.simpAttributes.getAttributeNames()).hasSize(2);
 	}
 
 	@Test

spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/StompDecoderTests.java

@@ -46,7 +46,7 @@ public class StompDecoderTests {
 
 		assertThat(headers.getCommand()).isEqualTo(StompCommand.DISCONNECT);
 		assertThat(headers.toNativeHeaderMap()).hasSize(0);
-		assertThat(frame.getPayload().length).isEqualTo(0);
+		assertThat(frame.getPayload()).hasSize(0);
 	}
 
 	@Test
@@ -56,7 +56,7 @@ public class StompDecoderTests {
 
 		assertThat(headers.getCommand()).isEqualTo(StompCommand.DISCONNECT);
 		assertThat(headers.toNativeHeaderMap()).hasSize(0);
-		assertThat(frame.getPayload().length).isEqualTo(0);
+		assertThat(frame.getPayload()).hasSize(0);
 	}
 
 	@Test
@@ -73,7 +73,7 @@ public class StompDecoderTests {
 		assertThat(headers.getFirstNativeHeader("accept-version")).isEqualTo("1.1");
 		assertThat(headers.getHost()).isEqualTo("github.org");
 
-		assertThat(frame.getPayload().length).isEqualTo(0);
+		assertThat(frame.getPayload()).hasSize(0);
 	}
 
 	@Test
@@ -173,7 +173,7 @@ public class StompDecoderTests {
 		assertThat(headers.getFirstNativeHeader("accept-version")).isEqualTo("1.1");
 		assertThat(headers.getFirstNativeHeader("key")).isEqualTo("\\value");
 
-		assertThat(frame.getPayload().length).isEqualTo(0);
+		assertThat(frame.getPayload()).hasSize(0);
 	}
 
 	@Test
@@ -220,7 +220,7 @@ public class StompDecoderTests {
 		assertThat(headers.getFirstNativeHeader("accept-version")).isEqualTo("1.1");
 		assertThat(headers.getFirstNativeHeader("key")).isEqualTo("");
 
-		assertThat(frame.getPayload().length).isEqualTo(0);
+		assertThat(frame.getPayload()).hasSize(0);
 	}
 
 	@Test

spring-orm/src/test/java/org/springframework/orm/jpa/persistenceunit/PersistenceXmlParsingTests.java

@@ -57,7 +57,7 @@ public class PersistenceXmlParsingTests {
 		PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
 
 		assertThat(info).isNotNull();
-		assertThat(info.length).isEqualTo(1);
+		assertThat(info).hasSize(1);
 		assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement");
 
 		assertThat(info[0].getJarFileUrls()).hasSize(2);
@@ -75,7 +75,7 @@ public class PersistenceXmlParsingTests {
 		PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
 
 		assertThat(info).isNotNull();
-		assertThat(info.length).isEqualTo(1);
+		assertThat(info).hasSize(1);
 		assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement");
 
 		assertThat(info[0].excludeUnlistedClasses()).as("Exclude unlisted should default false in 1.0.").isFalse();
@@ -89,7 +89,7 @@ public class PersistenceXmlParsingTests {
 		PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
 
 		assertThat(info).isNotNull();
-		assertThat(info.length).isEqualTo(1);
+		assertThat(info).hasSize(1);
 
 		assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement2");
 
@@ -108,7 +108,7 @@ public class PersistenceXmlParsingTests {
 		PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
 
 		assertThat(info).isNotNull();
-		assertThat(info.length).isEqualTo(1);
+		assertThat(info).hasSize(1);
 		assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement3");
 
 		assertThat(info[0].getJarFileUrls()).hasSize(2);
@@ -134,7 +134,7 @@ public class PersistenceXmlParsingTests {
 		PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
 
 		assertThat(info).isNotNull();
-		assertThat(info.length).isEqualTo(1);
+		assertThat(info).hasSize(1);
 		assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement4");
 
 		assertThat(info[0].getMappingFileNames()).hasSize(1);
@@ -161,7 +161,7 @@ public class PersistenceXmlParsingTests {
 		PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
 
 		assertThat(info).isNotNull();
-		assertThat(info.length).isEqualTo(1);
+		assertThat(info).hasSize(1);
 		assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement5");
 
 		assertThat(info[0].getMappingFileNames()).hasSize(2);
@@ -192,7 +192,7 @@ public class PersistenceXmlParsingTests {
 				new PathMatchingResourcePatternResolver(), dataSourceLookup);
 		PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
 
-		assertThat(info.length).isEqualTo(2);
+		assertThat(info).hasSize(2);
 
 		PersistenceUnitInfo pu1 = info[0];
 
@@ -247,7 +247,7 @@ public class PersistenceXmlParsingTests {
 				new PathMatchingResourcePatternResolver(), new JndiDataSourceLookup());
 		String resource = "/org/springframework/orm/jpa/persistence-example6.xml";
 		PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
-		assertThat(info.length).isEqualTo(1);
+		assertThat(info).hasSize(1);
 		assertThat(info[0].getPersistenceUnitName()).isEqualTo("pu");
 		assertThat(info[0].getProperties().keySet()).hasSize(0);
 

spring-test/src/test/java/org/springframework/mock/web/MockHttpServletRequestTests.java

@@ -236,11 +236,11 @@ class MockHttpServletRequestTests {
 		params.put("key3", new String[] { "value3A", "value3B" });
 		request.setParameters(params);
 		String[] values1 = request.getParameterValues("key1");
-		assertThat(values1.length).isEqualTo(1);
+		assertThat(values1).hasSize(1);
 		assertThat(request.getParameter("key1")).isEqualTo("newValue1");
 		assertThat(request.getParameter("key2")).isEqualTo("value2");
 		String[] values3 = request.getParameterValues("key3");
-		assertThat(values3.length).isEqualTo(2);
+		assertThat(values3).hasSize(2);
 		assertThat(values3[0]).isEqualTo("value3A");
 		assertThat(values3[1]).isEqualTo("value3B");
 	}
@@ -254,12 +254,12 @@ class MockHttpServletRequestTests {
 		params.put("key3", new String[] { "value3A", "value3B" });
 		request.addParameters(params);
 		String[] values1 = request.getParameterValues("key1");
-		assertThat(values1.length).isEqualTo(2);
+		assertThat(values1).hasSize(2);
 		assertThat(values1[0]).isEqualTo("value1");
 		assertThat(values1[1]).isEqualTo("newValue1");
 		assertThat(request.getParameter("key2")).isEqualTo("value2");
 		String[] values3 = request.getParameterValues("key3");
-		assertThat(values3.length).isEqualTo(2);
+		assertThat(values3).hasSize(2);
 		assertThat(values3[0]).isEqualTo("value3A");
 		assertThat(values3[1]).isEqualTo("value3B");
 	}

spring-test/src/test/java/org/springframework/mock/web/MockHttpServletResponseTests.java

@@ -280,7 +280,7 @@ class MockHttpServletResponseTests {
 		int size = response.getBufferSize();
 		response.getOutputStream().write(new byte[size]);
 		assertThat(response.isCommitted()).isTrue();
-		assertThat(response.getContentAsByteArray().length).isEqualTo((size + 1));
+		assertThat(response.getContentAsByteArray()).hasSize((size + 1));
 	}
 
 	@Test
@@ -290,7 +290,7 @@ class MockHttpServletResponseTests {
 		assertThat(response.isCommitted()).isFalse();
 		response.flushBuffer();
 		assertThat(response.isCommitted()).isTrue();
-		assertThat(response.getContentAsByteArray().length).isEqualTo(1);
+		assertThat(response.getContentAsByteArray()).hasSize(1);
 	}
 
 	@Test
@@ -303,7 +303,7 @@ class MockHttpServletResponseTests {
 		Arrays.fill(data, 'p');
 		response.getWriter().write(data);
 		assertThat(response.isCommitted()).isTrue();
-		assertThat(response.getContentAsByteArray().length).isEqualTo((size + 1));
+		assertThat(response.getContentAsByteArray()).hasSize((size + 1));
 	}
 
 	@Test
@@ -313,7 +313,7 @@ class MockHttpServletResponseTests {
 		assertThat(response.isCommitted()).isFalse();
 		response.getOutputStream().flush();
 		assertThat(response.isCommitted()).isTrue();
-		assertThat(response.getContentAsByteArray().length).isEqualTo(1);
+		assertThat(response.getContentAsByteArray()).hasSize(1);
 	}
 
 	@Test
@@ -323,7 +323,7 @@ class MockHttpServletResponseTests {
 		assertThat(response.isCommitted()).isFalse();
 		response.getWriter().flush();
 		assertThat(response.isCommitted()).isTrue();
-		assertThat(response.getContentAsByteArray().length).isEqualTo(1);
+		assertThat(response.getContentAsByteArray()).hasSize(1);
 	}
 
 	@Test // SPR-16683
@@ -333,7 +333,7 @@ class MockHttpServletResponseTests {
 		assertThat(response.isCommitted()).isFalse();
 		response.getWriter().close();
 		assertThat(response.isCommitted()).isTrue();
-		assertThat(response.getContentAsByteArray().length).isEqualTo(1);
+		assertThat(response.getContentAsByteArray()).hasSize(1);
 	}
 
 	@Test  // gh-23219

spring-test/src/test/java/org/springframework/test/context/TestContextConcurrencyTests.java

@@ -77,7 +77,7 @@ class TestContextConcurrencyTests {
 			});
 			assertThat(actualMethods).isEqualTo(expectedMethods);
 		});
-		assertThat(tcm.getTestContext().attributeNames().length).isEqualTo(0);
+		assertThat(tcm.getTestContext().attributeNames()).hasSize(0);
 	}
 
 

spring-test/src/test/java/org/springframework/test/context/support/AnnotationConfigContextLoaderUtilsTests.java

@@ -47,7 +47,7 @@ class AnnotationConfigContextLoaderUtilsTests {
 	void detectDefaultConfigurationClassesWithoutConfigurationClass() {
 		Class<?>[] configClasses = detectDefaultConfigurationClasses(NoConfigTestCase.class);
 		assertThat(configClasses).isNotNull();
-		assertThat(configClasses.length).isEqualTo(0);
+		assertThat(configClasses).hasSize(0);
 	}
 
 	@Test

spring-test/src/test/java/org/springframework/test/context/support/ContextLoaderUtilsContextHierarchyTests.java

@@ -338,20 +338,20 @@ class ContextLoaderUtilsContextHierarchyTests extends AbstractContextConfigurati
 
 		List<ContextConfigurationAttributes> alphaConfig = map.get("alpha");
 		assertThat(alphaConfig).hasSize(2);
-		assertThat(alphaConfig.get(0).getLocations().length).isEqualTo(1);
+		assertThat(alphaConfig.get(0).getLocations()).hasSize(1);
 		assertThat(alphaConfig.get(0).getLocations()[0]).isEqualTo("1-A.xml");
-		assertThat(alphaConfig.get(0).getInitializers().length).isEqualTo(0);
-		assertThat(alphaConfig.get(1).getLocations().length).isEqualTo(0);
-		assertThat(alphaConfig.get(1).getInitializers().length).isEqualTo(1);
+		assertThat(alphaConfig.get(0).getInitializers()).hasSize(0);
+		assertThat(alphaConfig.get(1).getLocations()).hasSize(0);
+		assertThat(alphaConfig.get(1).getInitializers()).hasSize(1);
 		assertThat(alphaConfig.get(1).getInitializers()[0]).isEqualTo(DummyApplicationContextInitializer.class);
 
 		List<ContextConfigurationAttributes> betaConfig = map.get("beta");
 		assertThat(betaConfig).hasSize(2);
-		assertThat(betaConfig.get(0).getLocations().length).isEqualTo(1);
+		assertThat(betaConfig.get(0).getLocations()).hasSize(1);
 		assertThat(betaConfig.get(0).getLocations()[0]).isEqualTo("1-B.xml");
-		assertThat(betaConfig.get(0).getInitializers().length).isEqualTo(0);
-		assertThat(betaConfig.get(1).getLocations().length).isEqualTo(0);
-		assertThat(betaConfig.get(1).getInitializers().length).isEqualTo(1);
+		assertThat(betaConfig.get(0).getInitializers()).hasSize(0);
+		assertThat(betaConfig.get(1).getLocations()).hasSize(0);
+		assertThat(betaConfig.get(1).getInitializers()).hasSize(1);
 		assertThat(betaConfig.get(1).getInitializers()[0]).isEqualTo(DummyApplicationContextInitializer.class);
 	}
 

spring-test/src/test/java/org/springframework/test/web/client/response/ResponseCreatorsTests.java

@@ -46,7 +46,7 @@ class ResponseCreatorsTests {
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
 		assertThat(response.getHeaders().isEmpty()).isTrue();
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -77,7 +77,7 @@ class ResponseCreatorsTests {
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
 		assertThat(response.getHeaders().getLocation()).isEqualTo(location);
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -86,7 +86,7 @@ class ResponseCreatorsTests {
 		MockClientHttpResponse response = (MockClientHttpResponse) responseCreator.createResponse(null);
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.ACCEPTED);
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -96,7 +96,7 @@ class ResponseCreatorsTests {
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT);
 		assertThat(response.getHeaders().isEmpty()).isTrue();
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -106,7 +106,7 @@ class ResponseCreatorsTests {
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
 		assertThat(response.getHeaders().isEmpty()).isTrue();
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -116,7 +116,7 @@ class ResponseCreatorsTests {
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
 		assertThat(response.getHeaders().isEmpty()).isTrue();
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -125,7 +125,7 @@ class ResponseCreatorsTests {
 		MockClientHttpResponse response = (MockClientHttpResponse) responseCreator.createResponse(null);
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -134,7 +134,7 @@ class ResponseCreatorsTests {
 		MockClientHttpResponse response = (MockClientHttpResponse) responseCreator.createResponse(null);
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -143,7 +143,7 @@ class ResponseCreatorsTests {
 		MockClientHttpResponse response = (MockClientHttpResponse) responseCreator.createResponse(null);
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CONFLICT);
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -153,7 +153,7 @@ class ResponseCreatorsTests {
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.TOO_MANY_REQUESTS);
 		assertThat(response.getHeaders()).doesNotContainKey(HttpHeaders.RETRY_AFTER);
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -163,7 +163,7 @@ class ResponseCreatorsTests {
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.TOO_MANY_REQUESTS);
 		assertThat(response.getHeaders().getFirst(HttpHeaders.RETRY_AFTER)).isEqualTo("512");
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -173,7 +173,7 @@ class ResponseCreatorsTests {
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR);
 		assertThat(response.getHeaders().isEmpty()).isTrue();
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -182,7 +182,7 @@ class ResponseCreatorsTests {
 		MockClientHttpResponse response = (MockClientHttpResponse) responseCreator.createResponse(null);
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_GATEWAY);
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -191,7 +191,7 @@ class ResponseCreatorsTests {
 		MockClientHttpResponse response = (MockClientHttpResponse) responseCreator.createResponse(null);
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.SERVICE_UNAVAILABLE);
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -200,7 +200,7 @@ class ResponseCreatorsTests {
 		MockClientHttpResponse response = (MockClientHttpResponse) responseCreator.createResponse(null);
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.GATEWAY_TIMEOUT);
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test
@@ -210,7 +210,7 @@ class ResponseCreatorsTests {
 
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
 		assertThat(response.getHeaders().isEmpty()).isTrue();
-		assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
+		assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
 	}
 
 	@Test

spring-test/src/test/java/org/springframework/test/web/servlet/htmlunit/HtmlUnitRequestBuilderTests.java

@@ -230,7 +230,7 @@ public class HtmlUnitRequestBuilderTests {
 		MockHttpServletRequest actualRequest = requestBuilder.buildRequest(servletContext);
 
 		Cookie[] cookies = actualRequest.getCookies();
-		assertThat(cookies.length).isEqualTo(1);
+		assertThat(cookies).hasSize(1);
 		assertThat(cookies[0].getName()).isEqualTo("name");
 		assertThat(cookies[0].getValue()).isEqualTo("value");
 	}
@@ -242,7 +242,7 @@ public class HtmlUnitRequestBuilderTests {
 		MockHttpServletRequest actualRequest = requestBuilder.buildRequest(servletContext);
 
 		Cookie[] cookies = actualRequest.getCookies();
-		assertThat(cookies.length).isEqualTo(2);
+		assertThat(cookies).hasSize(2);
 		Cookie cookie = cookies[0];
 		assertThat(cookie.getName()).isEqualTo("name");
 		assertThat(cookie.getValue()).isEqualTo("value");
@@ -857,7 +857,7 @@ public class HtmlUnitRequestBuilderTests {
 
 		Cookie[] cookies = mockMvc.perform(requestBuilder).andReturn().getRequest().getCookies();
 		assertThat(cookies).isNotNull();
-		assertThat(cookies.length).isEqualTo(1);
+		assertThat(cookies).hasSize(1);
 		Cookie cookie = cookies[0];
 		assertThat(cookie.getName()).isEqualTo(cookieName);
 		assertThat(cookie.getValue()).isEqualTo(cookieValue);

spring-test/src/test/java/org/springframework/test/web/servlet/request/MockHttpServletRequestBuilderTests.java

@@ -463,7 +463,7 @@ class MockHttpServletRequestBuilderTests {
 		MockHttpServletRequest request = this.builder.buildRequest(this.servletContext);
 		Cookie[] cookies = request.getCookies();
 
-		assertThat(cookies.length).isEqualTo(2);
+		assertThat(cookies).hasSize(2);
 		assertThat(cookies[0].getName()).isEqualTo("foo");
 		assertThat(cookies[0].getValue()).isEqualTo("bar");
 		assertThat(cookies[1].getName()).isEqualTo("baz");

spring-test/src/test/java/org/springframework/test/web/servlet/result/PrintingResultHandlerTests.java

@@ -190,7 +190,7 @@ class PrintingResultHandlerTests {
 
 		Map<String, Map<String, Object>> printedValues = this.handler.getPrinter().printedValues;
 		String[] cookies = (String[]) printedValues.get(heading).get("Cookies");
-		assertThat(cookies.length).isEqualTo(2);
+		assertThat(cookies).hasSize(2);
 		String cookie1 = cookies[0];
 		String cookie2 = cookies[1];
 		assertThat(cookie1.startsWith("[" + Cookie.class.getSimpleName())).isTrue();

spring-web/src/test/java/org/springframework/http/server/reactive/RandomHandlerIntegrationTests.java

@@ -68,7 +68,7 @@ class RandomHandlerIntegrationTests extends AbstractHttpHandlerIntegrationTests
 
 		assertThat(response.getBody()).isNotNull();
 		assertThat(response.getHeaders().getContentLength()).isEqualTo(RESPONSE_SIZE);
-		assertThat(response.getBody().length).isEqualTo(RESPONSE_SIZE);
+		assertThat(response.getBody()).hasSize(RESPONSE_SIZE);
 	}
 
 

spring-web/src/test/java/org/springframework/web/bind/support/WebRequestDataBinderTests.java

@@ -269,7 +269,7 @@ public class WebRequestDataBinderTests {
 		MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
 		request.addFile(new MockMultipartFile("stringArray", "Juergen".getBytes()));
 		binder.bind(new ServletWebRequest(request));
-		assertThat(target.getStringArray().length).isEqualTo(1);
+		assertThat(target.getStringArray()).hasSize(1);
 		assertThat(target.getStringArray()[0]).isEqualTo("Juergen");
 	}
 
@@ -283,7 +283,7 @@ public class WebRequestDataBinderTests {
 		request.addFile(new MockMultipartFile("stringArray", "Juergen".getBytes()));
 		request.addFile(new MockMultipartFile("stringArray", "Eva".getBytes()));
 		binder.bind(new ServletWebRequest(request));
-		assertThat(target.getStringArray().length).isEqualTo(2);
+		assertThat(target.getStringArray()).hasSize(2);
 		assertThat(target.getStringArray()[0]).isEqualTo("Juergen");
 		assertThat(target.getStringArray()[1]).isEqualTo("Eva");
 	}

spring-web/src/test/java/org/springframework/web/context/request/ServletWebRequestTests.java

@@ -61,18 +61,18 @@ public class ServletWebRequestTests {
 		servletRequest.addParameter("param2", "value2a");
 
 		assertThat(request.getParameter("param1")).isEqualTo("value1");
-		assertThat(request.getParameterValues("param1").length).isEqualTo(1);
+		assertThat(request.getParameterValues("param1")).hasSize(1);
 		assertThat(request.getParameterValues("param1")[0]).isEqualTo("value1");
 		assertThat(request.getParameter("param2")).isEqualTo("value2");
-		assertThat(request.getParameterValues("param2").length).isEqualTo(2);
+		assertThat(request.getParameterValues("param2")).hasSize(2);
 		assertThat(request.getParameterValues("param2")[0]).isEqualTo("value2");
 		assertThat(request.getParameterValues("param2")[1]).isEqualTo("value2a");
 
 		Map<String, String[]> paramMap = request.getParameterMap();
 		assertThat(paramMap).hasSize(2);
-		assertThat(paramMap.get("param1").length).isEqualTo(1);
+		assertThat(paramMap.get("param1")).hasSize(1);
 		assertThat(paramMap.get("param1")[0]).isEqualTo("value1");
-		assertThat(paramMap.get("param2").length).isEqualTo(2);
+		assertThat(paramMap.get("param2")).hasSize(2);
 		assertThat(paramMap.get("param2")[0]).isEqualTo("value2");
 		assertThat(paramMap.get("param2")[1]).isEqualTo("value2a");
 	}

spring-web/src/test/java/org/springframework/web/method/annotation/RequestParamMethodArgumentResolverTests.java

@@ -225,7 +225,7 @@ public class RequestParamMethodArgumentResolverTests {
 		boolean condition = result instanceof MultipartFile[];
 		assertThat(condition).isTrue();
 		MultipartFile[] parts = (MultipartFile[]) result;
-		assertThat(parts.length).isEqualTo(2);
+		assertThat(parts).hasSize(2);
 		assertThat(expected1).isEqualTo(parts[0]);
 		assertThat(expected2).isEqualTo(parts[1]);
 	}
@@ -309,7 +309,7 @@ public class RequestParamMethodArgumentResolverTests {
 		boolean condition = result instanceof Part[];
 		assertThat(condition).isTrue();
 		Part[] parts = (Part[]) result;
-		assertThat(parts.length).isEqualTo(2);
+		assertThat(parts).hasSize(2);
 		assertThat(expected1).isEqualTo(parts[0]);
 		assertThat(expected2).isEqualTo(parts[1]);
 	}

spring-webflux/src/test/java/org/springframework/web/reactive/result/method/annotation/RequestMappingMessageConversionIntegrationTests.java

@@ -262,7 +262,7 @@ public class RequestMappingMessageConversionIntegrationTests extends AbstractReq
 		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
 		assertThat(response.hasBody()).isTrue();
 		assertThat(response.getHeaders().getContentLength()).isEqualTo(951);
-		assertThat(response.getBody().length).isEqualTo(951);
+		assertThat(response.getBody()).hasSize(951);
 		assertThat(response.getHeaders().getContentType()).isEqualTo(new MediaType("image", "png"));
 	}
 

spring-webmvc/src/test/java/org/springframework/web/servlet/config/MvcNamespaceTests.java

@@ -775,11 +775,11 @@ public class MvcNamespaceTests {
 
 		CallableProcessingInterceptor[] callableInterceptors =
 				(CallableProcessingInterceptor[]) fieldAccessor.getPropertyValue("callableInterceptors");
-		assertThat(callableInterceptors.length).isEqualTo(1);
+		assertThat(callableInterceptors).hasSize(1);
 
 		DeferredResultProcessingInterceptor[] deferredResultInterceptors =
 				(DeferredResultProcessingInterceptor[]) fieldAccessor.getPropertyValue("deferredResultInterceptors");
-		assertThat(deferredResultInterceptors.length).isEqualTo(1);
+		assertThat(deferredResultInterceptors).hasSize(1);
 	}
 
 	@Test
@@ -907,7 +907,7 @@ public class MvcNamespaceTests {
 		loadBeanDefinitions("mvc-config-cors-minimal.xml");
 
 		String[] beanNames = appContext.getBeanNamesForType(AbstractHandlerMapping.class);
-		assertThat(beanNames.length).isEqualTo(2);
+		assertThat(beanNames).hasSize(2);
 		for (String beanName : beanNames) {
 			AbstractHandlerMapping handlerMapping = (AbstractHandlerMapping)appContext.getBean(beanName);
 			assertThat(handlerMapping).isNotNull();
@@ -932,7 +932,7 @@ public class MvcNamespaceTests {
 		loadBeanDefinitions("mvc-config-cors.xml");
 
 		String[] beanNames = appContext.getBeanNamesForType(AbstractHandlerMapping.class);
-		assertThat(beanNames.length).isEqualTo(2);
+		assertThat(beanNames).hasSize(2);
 		for (String beanName : beanNames) {
 			AbstractHandlerMapping handlerMapping = (AbstractHandlerMapping)appContext.getBean(beanName);
 			assertThat(handlerMapping).isNotNull();

spring-webmvc/src/test/java/org/springframework/web/servlet/config/annotation/WebMvcConfigurationSupportExtensionTests.java

@@ -137,7 +137,7 @@ public class WebMvcConfigurationSupportExtensionTests {
 		assertThat(chain).isNotNull();
 		HandlerInterceptor[] interceptors = chain.getInterceptors();
 		assertThat(interceptors).isNotNull();
-		assertThat(interceptors.length).isEqualTo(4);
+		assertThat(interceptors).hasSize(4);
 		assertThat(interceptors[0].getClass().getSimpleName()).isEqualTo("CorsInterceptor");
 		assertThat(interceptors[1].getClass()).isEqualTo(LocaleChangeInterceptor.class);
 		assertThat(interceptors[2].getClass()).isEqualTo(ConversionServiceExposingInterceptor.class);
@@ -235,11 +235,11 @@ public class WebMvcConfigurationSupportExtensionTests {
 
 		CallableProcessingInterceptor[] callableInterceptors =
 				(CallableProcessingInterceptor[]) fieldAccessor.getPropertyValue("callableInterceptors");
-		assertThat(callableInterceptors.length).isEqualTo(1);
+		assertThat(callableInterceptors).hasSize(1);
 
 		DeferredResultProcessingInterceptor[] deferredResultInterceptors =
 				(DeferredResultProcessingInterceptor[]) fieldAccessor.getPropertyValue("deferredResultInterceptors");
-		assertThat(deferredResultInterceptors.length).isEqualTo(1);
+		assertThat(deferredResultInterceptors).hasSize(1);
 
 		assertThat(fieldAccessor.getPropertyValue("ignoreDefaultModelOnRedirect")).asInstanceOf(BOOLEAN).isTrue();
 	}

spring-webmvc/src/test/java/org/springframework/web/servlet/config/annotation/WebMvcConfigurationSupportTests.java

@@ -163,7 +163,7 @@ public class WebMvcConfigurationSupportTests {
 		assertThat(chain).isNotNull();
 		HandlerInterceptor[] interceptors = chain.getInterceptors();
 		assertThat(interceptors).isNotNull();
-		assertThat(interceptors.length).isEqualTo(3);
+		assertThat(interceptors).hasSize(3);
 		assertThat(interceptors[1].getClass()).isEqualTo(ConversionServiceExposingInterceptor.class);
 		assertThat(interceptors[2].getClass()).isEqualTo(ResourceUrlProviderExposingInterceptor.class);
 	}

spring-webmvc/src/test/java/org/springframework/web/servlet/function/DefaultRenderingResponseTests.java

@@ -140,7 +140,7 @@ public class DefaultRenderingResponseTests {
 		MockHttpServletResponse response = new MockHttpServletResponse();
 		ModelAndView mav = result.writeTo(request, response, EMPTY_CONTEXT);
 		assertThat(mav).isNotNull();
-		assertThat(response.getCookies().length).isEqualTo(1);
+		assertThat(response.getCookies()).hasSize(1);
 		assertThat(response.getCookies()[0].getName()).isEqualTo("name");
 		assertThat(response.getCookies()[0].getValue()).isEqualTo("value");
 	}

spring-webmvc/src/test/java/org/springframework/web/servlet/function/ResourceHandlerFunctionTests.java

@@ -162,7 +162,7 @@ public class ResourceHandlerFunctionTests {
 
 		assertThat(servletResponse.getStatus()).isEqualTo(200);
 		byte[] actualBytes = servletResponse.getContentAsByteArray();
-		assertThat(actualBytes.length).isEqualTo(0);
+		assertThat(actualBytes).hasSize(0);
 		assertThat(servletResponse.getContentType()).isEqualTo(MediaType.TEXT_PLAIN_VALUE);
 		assertThat(servletResponse.getContentLength()).isEqualTo(this.resource.contentLength());
 	}
@@ -185,7 +185,7 @@ public class ResourceHandlerFunctionTests {
 		String[] methods = StringUtils.tokenizeToStringArray(allowHeader, ",");
 		assertThat(methods).containsExactlyInAnyOrder("GET","HEAD","OPTIONS");
 		byte[] actualBytes = servletResponse.getContentAsByteArray();
-		assertThat(actualBytes.length).isEqualTo(0);
+		assertThat(actualBytes).hasSize(0);
 	}
 
 }

spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/HttpEntityMethodProcessorMockTests.java

@@ -832,7 +832,7 @@ public class HttpEntityMethodProcessorMockTests {
 			assertResponseBody(body);
 		}
 		else {
-			assertThat(servletResponse.getContentAsByteArray().length).isEqualTo(0);
+			assertThat(servletResponse.getContentAsByteArray()).hasSize(0);
 		}
 		if (etag != null) {
 			assertThat(servletResponse.getHeaderValues(HttpHeaders.ETAG)).hasSize(1);

spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestPartMethodArgumentResolverTests.java

@@ -203,7 +203,7 @@ public class RequestPartMethodArgumentResolverTests {
 		assertThat(actual).isNotNull();
 		assertThat(actual instanceof MultipartFile[]).isTrue();
 		MultipartFile[] parts = (MultipartFile[]) actual;
-		assertThat(parts.length).isEqualTo(2);
+		assertThat(parts).hasSize(2);
 		assertThat(multipartFile1).isEqualTo(parts[0]);
 		assertThat(multipartFile2).isEqualTo(parts[1]);
 	}
@@ -269,7 +269,7 @@ public class RequestPartMethodArgumentResolverTests {
 		Object result = resolver.resolveArgument(paramPartArray, null, webRequest, null);
 		assertThat(result instanceof Part[]).isTrue();
 		Part[] parts = (Part[]) result;
-		assertThat(parts.length).isEqualTo(2);
+		assertThat(parts).hasSize(2);
 		assertThat(part1).isEqualTo(parts[0]);
 		assertThat(part2).isEqualTo(parts[1]);
 	}

spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ServletAnnotationControllerHandlerMethodTests.java

@@ -2731,7 +2731,7 @@ public class ServletAnnotationControllerHandlerMethodTests extends AbstractServl
 			vf.afterPropertiesSet();
 			binder.setValidator(vf);
 			assertThat(date).isEqualTo("2007-10-02");
-			assertThat(date2.length).isEqualTo(1);
+			assertThat(date2).hasSize(1);
 			assertThat(date2[0]).isEqualTo("2007-10-02");
 			SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
 			dateFormat.setLenient(false);

spring-websocket/src/test/java/org/springframework/web/socket/config/annotation/WebSocketHandlerRegistrationTests.java

@@ -61,14 +61,14 @@ public class WebSocketHandlerRegistrationTests {
 		assertThat(m1.webSocketHandler).isEqualTo(handler);
 		assertThat(m1.path).isEqualTo("/foo");
 		assertThat(m1.interceptors).isNotNull();
-		assertThat(m1.interceptors.length).isEqualTo(1);
+		assertThat(m1.interceptors).hasSize(1);
 		assertThat(m1.interceptors[0].getClass()).isEqualTo(OriginHandshakeInterceptor.class);
 
 		Mapping m2 = mappings.get(1);
 		assertThat(m2.webSocketHandler).isEqualTo(handler);
 		assertThat(m2.path).isEqualTo("/bar");
 		assertThat(m2.interceptors).isNotNull();
-		assertThat(m2.interceptors.length).isEqualTo(1);
+		assertThat(m2.interceptors).hasSize(1);
 		assertThat(m2.interceptors[0].getClass()).isEqualTo(OriginHandshakeInterceptor.class);
 	}
 
@@ -86,7 +86,7 @@ public class WebSocketHandlerRegistrationTests {
 		assertThat(mapping.webSocketHandler).isEqualTo(handler);
 		assertThat(mapping.path).isEqualTo("/foo");
 		assertThat(mapping.interceptors).isNotNull();
-		assertThat(mapping.interceptors.length).isEqualTo(2);
+		assertThat(mapping.interceptors).hasSize(2);
 		assertThat(mapping.interceptors[0]).isEqualTo(interceptor);
 		assertThat(mapping.interceptors[1].getClass()).isEqualTo(OriginHandshakeInterceptor.class);
 	}
@@ -105,7 +105,7 @@ public class WebSocketHandlerRegistrationTests {
 		assertThat(mapping.webSocketHandler).isEqualTo(handler);
 		assertThat(mapping.path).isEqualTo("/foo");
 		assertThat(mapping.interceptors).isNotNull();
-		assertThat(mapping.interceptors.length).isEqualTo(2);
+		assertThat(mapping.interceptors).hasSize(2);
 		assertThat(mapping.interceptors[0]).isEqualTo(interceptor);
 		assertThat(mapping.interceptors[1].getClass()).isEqualTo(OriginHandshakeInterceptor.class);
 	}
@@ -127,7 +127,7 @@ public class WebSocketHandlerRegistrationTests {
 		assertThat(mapping.webSocketHandler).isEqualTo(handler);
 		assertThat(mapping.path).isEqualTo("/foo");
 		assertThat(mapping.interceptors).isNotNull();
-		assertThat(mapping.interceptors.length).isEqualTo(2);
+		assertThat(mapping.interceptors).hasSize(2);
 		assertThat(mapping.interceptors[0]).isEqualTo(interceptor);
 
 		OriginHandshakeInterceptor originInterceptor = (OriginHandshakeInterceptor) mapping.interceptors[1];