Use AssertJ's hasSize() for collections and maps

Achieved via a global search-and-replace.

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

@@ -366,7 +366,7 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 				new SingletonMetadataAwareAspectInstanceFactory(new MakeLockable(), "someBean")),
 		CannotBeUnlocked.class).isEmpty()).isTrue();
 		assertThat(AopUtils.findAdvisorsThatCanApply(getFixture().getAdvisors(
-		new SingletonMetadataAwareAspectInstanceFactory(new MakeLockable(),"someBean")), NotLockable.class).size()).isEqualTo(2);
+		new SingletonMetadataAwareAspectInstanceFactory(new MakeLockable(),"someBean")), NotLockable.class)).hasSize(2);
 	}
 
 	@Test

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

@@ -1010,11 +1010,11 @@ abstract class AbstractPropertyAccessorTests {
 		accessor.setPropertyValue("list", list);
 		assertThat(target.getCollection()).hasSize(1);
 		assertThat(target.getCollection().containsAll(coll)).isTrue();
-		assertThat(target.getSet().size()).isEqualTo(1);
+		assertThat(target.getSet()).hasSize(1);
 		assertThat(target.getSet().containsAll(set)).isTrue();
-		assertThat(target.getSortedSet().size()).isEqualTo(1);
+		assertThat(target.getSortedSet()).hasSize(1);
 		assertThat(target.getSortedSet().containsAll(sortedSet)).isTrue();
-		assertThat(target.getList().size()).isEqualTo(1);
+		assertThat(target.getList()).hasSize(1);
 		assertThat(target.getList().containsAll(list)).isTrue();
 	}
 
@@ -1037,11 +1037,11 @@ abstract class AbstractPropertyAccessorTests {
 		accessor.setPropertyValue("list", list.toArray());
 		assertThat(target.getCollection()).hasSize(1);
 		assertThat(target.getCollection().containsAll(coll)).isTrue();
-		assertThat(target.getSet().size()).isEqualTo(1);
+		assertThat(target.getSet()).hasSize(1);
 		assertThat(target.getSet().containsAll(set)).isTrue();
-		assertThat(target.getSortedSet().size()).isEqualTo(1);
+		assertThat(target.getSortedSet()).hasSize(1);
 		assertThat(target.getSortedSet().containsAll(sortedSet)).isTrue();
-		assertThat(target.getList().size()).isEqualTo(1);
+		assertThat(target.getList()).hasSize(1);
 		assertThat(target.getList().containsAll(list)).isTrue();
 	}
 
@@ -1064,11 +1064,11 @@ abstract class AbstractPropertyAccessorTests {
 		accessor.setPropertyValue("list", new int[]{3});
 		assertThat(target.getCollection()).hasSize(1);
 		assertThat(target.getCollection().containsAll(coll)).isTrue();
-		assertThat(target.getSet().size()).isEqualTo(1);
+		assertThat(target.getSet()).hasSize(1);
 		assertThat(target.getSet().containsAll(set)).isTrue();
-		assertThat(target.getSortedSet().size()).isEqualTo(1);
+		assertThat(target.getSortedSet()).hasSize(1);
 		assertThat(target.getSortedSet().containsAll(sortedSet)).isTrue();
-		assertThat(target.getList().size()).isEqualTo(1);
+		assertThat(target.getList()).hasSize(1);
 		assertThat(target.getList().containsAll(list)).isTrue();
 	}
 
@@ -1091,11 +1091,11 @@ abstract class AbstractPropertyAccessorTests {
 		accessor.setPropertyValue("list", 3);
 		assertThat(target.getCollection()).hasSize(1);
 		assertThat(target.getCollection().containsAll(coll)).isTrue();
-		assertThat(target.getSet().size()).isEqualTo(1);
+		assertThat(target.getSet()).hasSize(1);
 		assertThat(target.getSet().containsAll(set)).isTrue();
-		assertThat(target.getSortedSet().size()).isEqualTo(1);
+		assertThat(target.getSortedSet()).hasSize(1);
 		assertThat(target.getSortedSet().containsAll(sortedSet)).isTrue();
-		assertThat(target.getList().size()).isEqualTo(1);
+		assertThat(target.getList()).hasSize(1);
 		assertThat(target.getList().containsAll(list)).isTrue();
 	}
 
@@ -1113,15 +1113,16 @@ abstract class AbstractPropertyAccessorTests {
 		Set<String> list = new HashSet<>();
 		list.add("list1");
 		accessor.setPropertyValue("list", "list1");
-		assertThat(target.getSet().size()).isEqualTo(1);
+		assertThat(target.getSet()).hasSize(1);
 		assertThat(target.getSet().containsAll(set)).isTrue();
-		assertThat(target.getSortedSet().size()).isEqualTo(1);
+		assertThat(target.getSortedSet()).hasSize(1);
 		assertThat(target.getSortedSet().containsAll(sortedSet)).isTrue();
-		assertThat(target.getList().size()).isEqualTo(1);
+		assertThat(target.getList()).hasSize(1);
 		assertThat(target.getList().containsAll(list)).isTrue();
 	}
 
 	@Test
+	@SuppressWarnings("unchecked")
 	void setCollectionPropertyWithStringValueAndCustomEditor() {
 		IndexedTestBean target = new IndexedTestBean();
 		AbstractPropertyAccessor accessor = createAccessor(target);
@@ -1131,11 +1132,11 @@ abstract class AbstractPropertyAccessorTests {
 		accessor.setPropertyValue("set", "set1 ");
 		accessor.setPropertyValue("sortedSet", "sortedSet1");
 		accessor.setPropertyValue("list", "list1 ");
-		assertThat(target.getSet().size()).isEqualTo(1);
+		assertThat(target.getSet()).hasSize(1);
 		assertThat(target.getSet().contains("set1")).isTrue();
-		assertThat(target.getSortedSet().size()).isEqualTo(1);
+		assertThat(target.getSortedSet()).hasSize(1);
 		assertThat(target.getSortedSet().contains("sortedSet1")).isTrue();
-		assertThat(target.getList().size()).isEqualTo(1);
+		assertThat(target.getList()).hasSize(1);
 		assertThat(target.getList().contains("list1")).isTrue();
 
 		accessor.setPropertyValue("list", Collections.singletonList("list1 "));
@@ -1169,7 +1170,7 @@ abstract class AbstractPropertyAccessorTests {
 		accessor.setPropertyValue("sortedMap", sortedMap);
 		assertThat(target.getMap()).hasSize(1);
 		assertThat(target.getMap().get("key")).isEqualTo("value");
-		assertThat(target.getSortedMap().size()).isEqualTo(1);
+		assertThat(target.getSortedMap()).hasSize(1);
 		assertThat(target.getSortedMap().get("sortedKey")).isEqualTo("sortedValue");
 	}
 

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

@@ -125,7 +125,7 @@ public class BeanWrapperAutoGrowingTests {
 	@Test
 	public void getPropertyValueAutoGrowList() {
 		assertNotNull(wrapper.getPropertyValue("list[0]"));
-		assertThat(bean.getList().size()).isEqualTo(1);
+		assertThat(bean.getList()).hasSize(1);
 		assertThat(bean.getList().get(0)).isInstanceOf(Bean.class);
 	}
 
@@ -138,7 +138,7 @@ public class BeanWrapperAutoGrowingTests {
 	@Test
 	public void getPropertyValueAutoGrowListBySeveralElements() {
 		assertNotNull(wrapper.getPropertyValue("list[4]"));
-		assertThat(bean.getList().size()).isEqualTo(5);
+		assertThat(bean.getList()).hasSize(5);
 		assertThat(bean.getList().get(0)).isInstanceOf(Bean.class);
 		assertThat(bean.getList().get(1)).isInstanceOf(Bean.class);
 		assertThat(bean.getList().get(2)).isInstanceOf(Bean.class);
@@ -161,7 +161,7 @@ public class BeanWrapperAutoGrowingTests {
 	@Test
 	public void getPropertyValueAutoGrowMultiDimensionalList() {
 		assertNotNull(wrapper.getPropertyValue("multiList[0][0]"));
-		assertThat(bean.getMultiList().get(0).size()).isEqualTo(1);
+		assertThat(bean.getMultiList().get(0)).hasSize(1);
 		assertThat(bean.getMultiList().get(0).get(0)).isInstanceOf(Bean.class);
 	}
 

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

@@ -91,7 +91,7 @@ public class BeanWrapperEnumTests {
 		GenericBean<?> gb = new GenericBean<>();
 		BeanWrapper bw = new BeanWrapperImpl(gb);
 		bw.setPropertyValue("customEnumSet", "VALUE_1");
-		assertThat(gb.getCustomEnumSet().size()).isEqualTo(1);
+		assertThat(gb.getCustomEnumSet()).hasSize(1);
 		assertThat(gb.getCustomEnumSet().contains(CustomEnum.VALUE_1)).isTrue();
 	}
 
@@ -100,7 +100,7 @@ public class BeanWrapperEnumTests {
 		GenericBean<?> gb = new GenericBean<>();
 		BeanWrapper bw = new BeanWrapperImpl(gb);
 		bw.setPropertyValue("customEnumSet", new String[] {"VALUE_1", "VALUE_2"});
-		assertThat(gb.getCustomEnumSet().size()).isEqualTo(2);
+		assertThat(gb.getCustomEnumSet()).hasSize(2);
 		assertThat(gb.getCustomEnumSet().contains(CustomEnum.VALUE_1)).isTrue();
 		assertThat(gb.getCustomEnumSet().contains(CustomEnum.VALUE_2)).isTrue();
 	}
@@ -110,7 +110,7 @@ public class BeanWrapperEnumTests {
 		GenericBean<?> gb = new GenericBean<>();
 		BeanWrapper bw = new BeanWrapperImpl(gb);
 		bw.setPropertyValue("customEnumSet", "VALUE_1,VALUE_2");
-		assertThat(gb.getCustomEnumSet().size()).isEqualTo(2);
+		assertThat(gb.getCustomEnumSet()).hasSize(2);
 		assertThat(gb.getCustomEnumSet().contains(CustomEnum.VALUE_1)).isTrue();
 		assertThat(gb.getCustomEnumSet().contains(CustomEnum.VALUE_2)).isTrue();
 	}
@@ -120,7 +120,7 @@ public class BeanWrapperEnumTests {
 		GenericBean<?> gb = new GenericBean<>();
 		BeanWrapper bw = new BeanWrapperImpl(gb);
 		bw.setPropertyValue("customEnumSetMismatch", new String[] {"VALUE_1", "VALUE_2"});
-		assertThat(gb.getCustomEnumSet().size()).isEqualTo(2);
+		assertThat(gb.getCustomEnumSet()).hasSize(2);
 		assertThat(gb.getCustomEnumSet().contains(CustomEnum.VALUE_1)).isTrue();
 		assertThat(gb.getCustomEnumSet().contains(CustomEnum.VALUE_2)).isTrue();
 	}
@@ -132,7 +132,7 @@ public class BeanWrapperEnumTests {
 		bw.setConversionService(new DefaultConversionService());
 		assertThat(gb.getStandardEnumSet()).isNull();
 		bw.setPropertyValue("standardEnumSet", new String[] {"VALUE_1", "VALUE_2"});
-		assertThat(gb.getStandardEnumSet().size()).isEqualTo(2);
+		assertThat(gb.getStandardEnumSet()).hasSize(2);
 		assertThat(gb.getStandardEnumSet().contains(CustomEnum.VALUE_1)).isTrue();
 		assertThat(gb.getStandardEnumSet().contains(CustomEnum.VALUE_2)).isTrue();
 	}
@@ -144,7 +144,7 @@ public class BeanWrapperEnumTests {
 		bw.setAutoGrowNestedPaths(true);
 		assertThat(gb.getStandardEnumSet()).isNull();
 		bw.getPropertyValue("standardEnumSet.class");
-		assertThat(gb.getStandardEnumSet().size()).isEqualTo(0);
+		assertThat(gb.getStandardEnumSet()).hasSize(0);
 	}
 
 	@Test
@@ -157,7 +157,7 @@ public class BeanWrapperEnumTests {
 		map.put("VALUE_1", 1);
 		map.put("VALUE_2", 2);
 		bw.setPropertyValue("standardEnumMap", map);
-		assertThat(gb.getStandardEnumMap().size()).isEqualTo(2);
+		assertThat(gb.getStandardEnumMap()).hasSize(2);
 		assertThat(gb.getStandardEnumMap().get(CustomEnum.VALUE_1)).isEqualTo(1);
 		assertThat(gb.getStandardEnumMap().get(CustomEnum.VALUE_2)).isEqualTo(2);
 	}
@@ -169,7 +169,7 @@ public class BeanWrapperEnumTests {
 		bw.setAutoGrowNestedPaths(true);
 		assertThat(gb.getStandardEnumMap()).isNull();
 		bw.setPropertyValue("standardEnumMap[VALUE_1]", 1);
-		assertThat(gb.getStandardEnumMap().size()).isEqualTo(1);
+		assertThat(gb.getStandardEnumMap()).hasSize(1);
 		assertThat(gb.getStandardEnumMap().get(CustomEnum.VALUE_1)).isEqualTo(1);
 	}
 

spring-beans/src/test/java/org/springframework/beans/factory/BeanFactoryUtilsTests.java

@@ -103,14 +103,14 @@ public class BeanFactoryUtilsTests {
 	public void testHierarchicalNamesWithNoMatch() {
 		List<String> names = Arrays.asList(
 				BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.listableBeanFactory, NoOp.class));
-		assertThat(names.size()).isEqualTo(0);
+		assertThat(names).hasSize(0);
 	}
 
 	@Test
 	public void testHierarchicalNamesWithMatchOnlyInRoot() {
 		List<String> names = Arrays.asList(
 				BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.listableBeanFactory, IndexedTestBean.class));
-		assertThat(names.size()).isEqualTo(1);
+		assertThat(names).hasSize(1);
 		assertThat(names.contains("indexedBean")).isTrue();
 		// Distinguish from default ListableBeanFactory behavior
 		assertThat(listableBeanFactory.getBeanNamesForType(IndexedTestBean.class).length == 0).isTrue();
@@ -121,7 +121,7 @@ public class BeanFactoryUtilsTests {
 		List<String> names = Arrays.asList(
 				BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.listableBeanFactory, ITestBean.class));
 		// includes 2 TestBeans from FactoryBeans (DummyFactory definitions)
-		assertThat(names.size()).isEqualTo(4);
+		assertThat(names).hasSize(4);
 		assertThat(names.contains("test")).isTrue();
 		assertThat(names.contains("test3")).isTrue();
 		assertThat(names.contains("testFactory1")).isTrue();
@@ -150,7 +150,7 @@ public class BeanFactoryUtilsTests {
 		lbf.addBean("t4", t4);
 
 		Map<String, ?> beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(lbf, ITestBean.class, true, true);
-		assertThat(beans.size()).isEqualTo(4);
+		assertThat(beans).hasSize(4);
 		assertThat(beans.get("t1")).isEqualTo(t1);
 		assertThat(beans.get("t2")).isEqualTo(t2);
 		assertThat(beans.get("t3")).isEqualTo(t3.getObject());
@@ -158,12 +158,12 @@ public class BeanFactoryUtilsTests {
 		assertThat(condition).isTrue();
 
 		beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(lbf, DummyFactory.class, true, true);
-		assertThat(beans.size()).isEqualTo(2);
+		assertThat(beans).hasSize(2);
 		assertThat(beans.get("&t3")).isEqualTo(t3);
 		assertThat(beans.get("&t4")).isEqualTo(t4);
 
 		beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(lbf, FactoryBean.class, true, true);
-		assertThat(beans.size()).isEqualTo(2);
+		assertThat(beans).hasSize(2);
 		assertThat(beans.get("&t3")).isEqualTo(t3);
 		assertThat(beans.get("&t4")).isEqualTo(t4);
 	}
@@ -185,7 +185,7 @@ public class BeanFactoryUtilsTests {
 
 		Map<String, ?> beans =
 				BeanFactoryUtils.beansOfTypeIncludingAncestors(this.listableBeanFactory, ITestBean.class, true, false);
-		assertThat(beans.size()).isEqualTo(6);
+		assertThat(beans).hasSize(6);
 		assertThat(beans.get("test3")).isEqualTo(test3);
 		assertThat(beans.get("test")).isEqualTo(test);
 		assertThat(beans.get("t1")).isEqualTo(t1);
@@ -199,7 +199,7 @@ public class BeanFactoryUtilsTests {
 
 		beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(this.listableBeanFactory, ITestBean.class, false, true);
 		Object testFactory1 = this.listableBeanFactory.getBean("testFactory1");
-		assertThat(beans.size()).isEqualTo(5);
+		assertThat(beans).hasSize(5);
 		assertThat(beans.get("test")).isEqualTo(test);
 		assertThat(beans.get("testFactory1")).isEqualTo(testFactory1);
 		assertThat(beans.get("t1")).isEqualTo(t1);
@@ -207,7 +207,7 @@ public class BeanFactoryUtilsTests {
 		assertThat(beans.get("t3")).isEqualTo(t3.getObject());
 
 		beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(this.listableBeanFactory, ITestBean.class, true, true);
-		assertThat(beans.size()).isEqualTo(8);
+		assertThat(beans).hasSize(8);
 		assertThat(beans.get("test3")).isEqualTo(test3);
 		assertThat(beans.get("test")).isEqualTo(test);
 		assertThat(beans.get("testFactory1")).isEqualTo(testFactory1);
@@ -220,14 +220,14 @@ public class BeanFactoryUtilsTests {
 		assertThat(condition).isTrue();
 
 		beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(this.listableBeanFactory, DummyFactory.class, true, true);
-		assertThat(beans.size()).isEqualTo(4);
+		assertThat(beans).hasSize(4);
 		assertThat(beans.get("&testFactory1")).isEqualTo(this.listableBeanFactory.getBean("&testFactory1"));
 		assertThat(beans.get("&testFactory2")).isEqualTo(this.listableBeanFactory.getBean("&testFactory2"));
 		assertThat(beans.get("&t3")).isEqualTo(t3);
 		assertThat(beans.get("&t4")).isEqualTo(t4);
 
 		beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(this.listableBeanFactory, FactoryBean.class, true, true);
-		assertThat(beans.size()).isEqualTo(4);
+		assertThat(beans).hasSize(4);
 		assertThat(beans.get("&testFactory1")).isEqualTo(this.listableBeanFactory.getBean("&testFactory1"));
 		assertThat(beans.get("&testFactory2")).isEqualTo(this.listableBeanFactory.getBean("&testFactory2"));
 		assertThat(beans.get("&t3")).isEqualTo(t3);
@@ -241,22 +241,22 @@ public class BeanFactoryUtilsTests {
 
 		Map<String, ?> beans =
 				BeanFactoryUtils.beansOfTypeIncludingAncestors(this.listableBeanFactory, ITestBean.class, true, false);
-		assertThat(beans.size()).isEqualTo(2);
+		assertThat(beans).hasSize(2);
 		assertThat(beans.get("test3")).isEqualTo(test3);
 		assertThat(beans.get("test")).isEqualTo(test);
 
 		beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(this.listableBeanFactory, ITestBean.class, false, false);
-		assertThat(beans.size()).isEqualTo(1);
+		assertThat(beans).hasSize(1);
 		assertThat(beans.get("test")).isEqualTo(test);
 
 		beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(this.listableBeanFactory, ITestBean.class, false, true);
 		Object testFactory1 = this.listableBeanFactory.getBean("testFactory1");
-		assertThat(beans.size()).isEqualTo(2);
+		assertThat(beans).hasSize(2);
 		assertThat(beans.get("test")).isEqualTo(test);
 		assertThat(beans.get("testFactory1")).isEqualTo(testFactory1);
 
 		beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(this.listableBeanFactory, ITestBean.class, true, true);
-		assertThat(beans.size()).isEqualTo(4);
+		assertThat(beans).hasSize(4);
 		assertThat(beans.get("test3")).isEqualTo(test3);
 		assertThat(beans.get("test")).isEqualTo(test);
 		assertThat(beans.get("testFactory1")).isEqualTo(testFactory1);
@@ -264,12 +264,12 @@ public class BeanFactoryUtilsTests {
 		assertThat(condition).isTrue();
 
 		beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(this.listableBeanFactory, DummyFactory.class, true, true);
-		assertThat(beans.size()).isEqualTo(2);
+		assertThat(beans).hasSize(2);
 		assertThat(beans.get("&testFactory1")).isEqualTo(this.listableBeanFactory.getBean("&testFactory1"));
 		assertThat(beans.get("&testFactory2")).isEqualTo(this.listableBeanFactory.getBean("&testFactory2"));
 
 		beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(this.listableBeanFactory, FactoryBean.class, true, true);
-		assertThat(beans.size()).isEqualTo(2);
+		assertThat(beans).hasSize(2);
 		assertThat(beans.get("&testFactory1")).isEqualTo(this.listableBeanFactory.getBean("&testFactory1"));
 		assertThat(beans.get("&testFactory2")).isEqualTo(this.listableBeanFactory.getBean("&testFactory2"));
 	}
@@ -278,14 +278,14 @@ public class BeanFactoryUtilsTests {
 	public void testHierarchicalNamesForAnnotationWithNoMatch() {
 		List<String> names = Arrays.asList(
 				BeanFactoryUtils.beanNamesForAnnotationIncludingAncestors(this.listableBeanFactory, Override.class));
-		assertThat(names.size()).isEqualTo(0);
+		assertThat(names).hasSize(0);
 	}
 
 	@Test
 	public void testHierarchicalNamesForAnnotationWithMatchOnlyInRoot() {
 		List<String> names = Arrays.asList(
 				BeanFactoryUtils.beanNamesForAnnotationIncludingAncestors(this.listableBeanFactory, TestAnnotation.class));
-		assertThat(names.size()).isEqualTo(1);
+		assertThat(names).hasSize(1);
 		assertThat(names.contains("annotatedBean")).isTrue();
 		// Distinguish from default ListableBeanFactory behavior
 		assertThat(listableBeanFactory.getBeanNamesForAnnotation(TestAnnotation.class).length == 0).isTrue();
@@ -297,7 +297,7 @@ public class BeanFactoryUtilsTests {
 		this.listableBeanFactory.registerSingleton("anotherAnnotatedBean", annotatedBean);
 		List<String> names = Arrays.asList(
 				BeanFactoryUtils.beanNamesForAnnotationIncludingAncestors(this.listableBeanFactory, TestAnnotation.class));
-		assertThat(names.size()).isEqualTo(2);
+		assertThat(names).hasSize(2);
 		assertThat(names.contains("annotatedBean")).isTrue();
 		assertThat(names.contains("anotherAnnotatedBean")).isTrue();
 	}

spring-beans/src/test/java/org/springframework/beans/factory/DefaultListableBeanFactoryTests.java

@@ -1075,12 +1075,12 @@ class DefaultListableBeanFactoryTests {
 		assertThat(test.getSpouse()).isEqualTo(singletonObject);
 
 		Map<?, ?> beansOfType = lbf.getBeansOfType(TestBean.class, false, true);
-		assertThat(beansOfType.size()).isEqualTo(2);
+		assertThat(beansOfType).hasSize(2);
 		assertThat(beansOfType.containsValue(test)).isTrue();
 		assertThat(beansOfType.containsValue(singletonObject)).isTrue();
 
 		beansOfType = lbf.getBeansOfType(null, false, true);
-		assertThat(beansOfType.size()).isEqualTo(2);
+		assertThat(beansOfType).hasSize(2);
 
 		Iterator<String> beanNames = lbf.getBeanNamesIterator();
 		assertThat(beanNames.next()).isEqualTo("test");
@@ -1113,7 +1113,7 @@ class DefaultListableBeanFactoryTests {
 		assertThat(test.getSpouse()).isEqualTo(singletonObject);
 
 		Map<?, ?>  beansOfType = lbf.getBeansOfType(TestBean.class, false, true);
-		assertThat(beansOfType.size()).isEqualTo(2);
+		assertThat(beansOfType).hasSize(2);
 		assertThat(beansOfType.containsValue(test)).isTrue();
 		assertThat(beansOfType.containsValue(singletonObject)).isTrue();
 
@@ -1123,7 +1123,7 @@ class DefaultListableBeanFactoryTests {
 		assertThat(beanNames.next()).isEqualTo("test");
 		assertThat(beanNames.next()).isEqualTo("singletonObject");
 		assertThat(beanNames.hasNext()).isFalse();
-		assertThat(beansOfType.size()).isEqualTo(2);
+		assertThat(beansOfType).hasSize(2);
 
 		assertThat(lbf.containsSingleton("test")).isTrue();
 		assertThat(lbf.containsSingleton("singletonObject")).isTrue();
@@ -1669,18 +1669,18 @@ class DefaultListableBeanFactoryTests {
 		for (ConstructorDependency instance : provider) {
 			resolved.add(instance);
 		}
-		assertThat(resolved.size()).isEqualTo(2);
+		assertThat(resolved).hasSize(2);
 		assertThat(resolved.contains(lbf.getBean("bd1"))).isTrue();
 		assertThat(resolved.contains(lbf.getBean("bd2"))).isTrue();
 
 		resolved = new HashSet<>();
 		provider.forEach(resolved::add);
-		assertThat(resolved.size()).isEqualTo(2);
+		assertThat(resolved).hasSize(2);
 		assertThat(resolved.contains(lbf.getBean("bd1"))).isTrue();
 		assertThat(resolved.contains(lbf.getBean("bd2"))).isTrue();
 
 		resolved = provider.stream().collect(Collectors.toSet());
-		assertThat(resolved.size()).isEqualTo(2);
+		assertThat(resolved).hasSize(2);
 		assertThat(resolved.contains(lbf.getBean("bd1"))).isTrue();
 		assertThat(resolved.contains(lbf.getBean("bd2"))).isTrue();
 	}
@@ -1718,18 +1718,18 @@ class DefaultListableBeanFactoryTests {
 		for (ConstructorDependency instance : provider) {
 			resolved.add(instance);
 		}
-		assertThat(resolved.size()).isEqualTo(2);
+		assertThat(resolved).hasSize(2);
 		assertThat(resolved.contains(lbf.getBean("bd1"))).isTrue();
 		assertThat(resolved.contains(lbf.getBean("bd2"))).isTrue();
 
 		resolved = new HashSet<>();
 		provider.forEach(resolved::add);
-		assertThat(resolved.size()).isEqualTo(2);
+		assertThat(resolved).hasSize(2);
 		assertThat(resolved.contains(lbf.getBean("bd1"))).isTrue();
 		assertThat(resolved.contains(lbf.getBean("bd2"))).isTrue();
 
 		resolved = provider.stream().collect(Collectors.toSet());
-		assertThat(resolved.size()).isEqualTo(2);
+		assertThat(resolved).hasSize(2);
 		assertThat(resolved.contains(lbf.getBean("bd1"))).isTrue();
 		assertThat(resolved.contains(lbf.getBean("bd2"))).isTrue();
 	}

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

@@ -411,13 +411,13 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isSameAs(tb);
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
-		assertThat(bean.getNestedTestBeans().size()).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb1);
 		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb2);
-		assertThat(bean.nestedTestBeansSetter.size()).isEqualTo(2);
+		assertThat(bean.nestedTestBeansSetter).hasSize(2);
 		assertThat(bean.nestedTestBeansSetter.get(0)).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansSetter.get(1)).isSameAs(ntb2);
-		assertThat(bean.nestedTestBeansField.size()).isEqualTo(2);
+		assertThat(bean.nestedTestBeansField).hasSize(2);
 		assertThat(bean.nestedTestBeansField.get(0)).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansField.get(1)).isSameAs(ntb2);
 	}
@@ -442,11 +442,11 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isSameAs(tb);
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
-		assertThat(bean.getNestedTestBeans().size()).isEqualTo(1);
+		assertThat(bean.getNestedTestBeans()).hasSize(1);
 		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb1);
-		assertThat(bean.nestedTestBeansSetter.size()).isEqualTo(1);
+		assertThat(bean.nestedTestBeansSetter).hasSize(1);
 		assertThat(bean.nestedTestBeansSetter.get(0)).isSameAs(ntb1);
-		assertThat(bean.nestedTestBeansField.size()).isEqualTo(1);
+		assertThat(bean.nestedTestBeansField).hasSize(1);
 		assertThat(bean.nestedTestBeansField.get(0)).isSameAs(ntb1);
 	}
 
@@ -554,13 +554,13 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isSameAs(tb);
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
-		assertThat(bean.getNestedTestBeans().size()).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb2);
 		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb1);
-		assertThat(bean.nestedTestBeansSetter.size()).isEqualTo(2);
+		assertThat(bean.nestedTestBeansSetter).hasSize(2);
 		assertThat(bean.nestedTestBeansSetter.get(0)).isSameAs(ntb2);
 		assertThat(bean.nestedTestBeansSetter.get(1)).isSameAs(ntb1);
-		assertThat(bean.nestedTestBeansField.size()).isEqualTo(2);
+		assertThat(bean.nestedTestBeansField).hasSize(2);
 		assertThat(bean.nestedTestBeansField.get(0)).isSameAs(ntb2);
 		assertThat(bean.nestedTestBeansField.get(1)).isSameAs(ntb1);
 	}
@@ -587,13 +587,13 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isSameAs(tb);
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
-		assertThat(bean.getNestedTestBeans().size()).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb2);
 		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb1);
-		assertThat(bean.nestedTestBeansSetter.size()).isEqualTo(2);
+		assertThat(bean.nestedTestBeansSetter).hasSize(2);
 		assertThat(bean.nestedTestBeansSetter.get(0)).isSameAs(ntb2);
 		assertThat(bean.nestedTestBeansSetter.get(1)).isSameAs(ntb1);
-		assertThat(bean.nestedTestBeansField.size()).isEqualTo(2);
+		assertThat(bean.nestedTestBeansField).hasSize(2);
 		assertThat(bean.nestedTestBeansField.get(0)).isSameAs(ntb2);
 		assertThat(bean.nestedTestBeansField.get(1)).isSameAs(ntb1);
 	}
@@ -798,7 +798,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		ConstructorsCollectionResourceInjectionBean bean = (ConstructorsCollectionResourceInjectionBean) bf.getBean("annotatedBean");
 		assertThat(bean.getTestBean3()).isNull();
 		assertThat(bean.getTestBean4()).isSameAs(tb);
-		assertThat(bean.getNestedTestBeans().size()).isEqualTo(1);
+		assertThat(bean.getNestedTestBeans()).hasSize(1);
 		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb2);
 
 		Map<String, NestedTestBean> map = bf.getBeansOfType(NestedTestBean.class);
@@ -820,7 +820,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		ConstructorsCollectionResourceInjectionBean bean = (ConstructorsCollectionResourceInjectionBean) bf.getBean("annotatedBean");
 		assertThat(bean.getTestBean3()).isNull();
 		assertThat(bean.getTestBean4()).isSameAs(tb);
-		assertThat(bean.getNestedTestBeans().size()).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb1);
 		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb2);
 	}
@@ -856,7 +856,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		ConstructorsCollectionResourceInjectionBean bean = (ConstructorsCollectionResourceInjectionBean) bf.getBean("annotatedBean");
 		assertThat(bean.getTestBean3()).isNull();
 		assertThat(bean.getTestBean4()).isSameAs(tb);
-		assertThat(bean.getNestedTestBeans().size()).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb2);
 		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb1);
 	}
@@ -873,7 +873,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 
 		SingleConstructorVarargBean bean = (SingleConstructorVarargBean) bf.getBean("annotatedBean");
 		assertThat(bean.getTestBean()).isSameAs(tb);
-		assertThat(bean.getNestedTestBeans().size()).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb2);
 		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb1);
 	}
@@ -902,7 +902,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 
 		SingleConstructorRequiredCollectionBean bean = (SingleConstructorRequiredCollectionBean) bf.getBean("annotatedBean");
 		assertThat(bean.getTestBean()).isSameAs(tb);
-		assertThat(bean.getNestedTestBeans().size()).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb2);
 		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb1);
 	}
@@ -931,7 +931,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 
 		SingleConstructorOptionalCollectionBean bean = (SingleConstructorOptionalCollectionBean) bf.getBean("annotatedBean");
 		assertThat(bean.getTestBean()).isSameAs(tb);
-		assertThat(bean.getNestedTestBeans().size()).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb2);
 		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb1);
 	}
@@ -996,12 +996,12 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		bf.registerBeanDefinition("testBean2", tb2);
 
 		MapConstructorInjectionBean bean = (MapConstructorInjectionBean) bf.getBean("annotatedBean");
-		assertThat(bean.getTestBeanMap().size()).isEqualTo(1);
+		assertThat(bean.getTestBeanMap()).hasSize(1);
 		assertThat(bean.getTestBeanMap().get("testBean1")).isSameAs(tb1);
 		assertThat(bean.getTestBeanMap().get("testBean2")).isNull();
 
 		bean = (MapConstructorInjectionBean) bf.getBean("annotatedBean");
-		assertThat(bean.getTestBeanMap().size()).isEqualTo(1);
+		assertThat(bean.getTestBeanMap()).hasSize(1);
 		assertThat(bean.getTestBeanMap().get("testBean1")).isSameAs(tb1);
 		assertThat(bean.getTestBeanMap().get("testBean2")).isNull();
 	}
@@ -1017,14 +1017,14 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		bf.registerSingleton("testBean2", tb2);
 
 		MapFieldInjectionBean bean = (MapFieldInjectionBean) bf.getBean("annotatedBean");
-		assertThat(bean.getTestBeanMap().size()).isEqualTo(2);
+		assertThat(bean.getTestBeanMap()).hasSize(2);
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean1")).isTrue();
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean2")).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb1)).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb2)).isTrue();
 
 		bean = (MapFieldInjectionBean) bf.getBean("annotatedBean");
-		assertThat(bean.getTestBeanMap().size()).isEqualTo(2);
+		assertThat(bean.getTestBeanMap()).hasSize(2);
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean1")).isTrue();
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean2")).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb1)).isTrue();
@@ -1040,13 +1040,13 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		bf.registerSingleton("testBean", tb);
 
 		MapMethodInjectionBean bean = (MapMethodInjectionBean) bf.getBean("annotatedBean");
-		assertThat(bean.getTestBeanMap().size()).isEqualTo(1);
+		assertThat(bean.getTestBeanMap()).hasSize(1);
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean")).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb)).isTrue();
 		assertThat(bean.getTestBean()).isSameAs(tb);
 
 		bean = (MapMethodInjectionBean) bf.getBean("annotatedBean");
-		assertThat(bean.getTestBeanMap().size()).isEqualTo(1);
+		assertThat(bean.getTestBeanMap()).hasSize(1);
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean")).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb)).isTrue();
 		assertThat(bean.getTestBean()).isSameAs(tb);
@@ -1072,7 +1072,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 
 		MapMethodInjectionBean bean = (MapMethodInjectionBean) bf.getBean("annotatedBean");
 		TestBean tb = (TestBean) bf.getBean("testBean1");
-		assertThat(bean.getTestBeanMap().size()).isEqualTo(1);
+		assertThat(bean.getTestBeanMap()).hasSize(1);
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean1")).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb)).isTrue();
 		assertThat(bean.getTestBean()).isSameAs(tb);
@@ -1215,7 +1215,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		SelfInjectionBean bean = (SelfInjectionBean) bf.getBean("annotatedBean");
 		SelfInjectionBean bean2 = (SelfInjectionBean) bf.getBean("annotatedBean2");
 		assertThat(bean.reference).isSameAs(bean2);
-		assertThat(bean.referenceCollection.size()).isEqualTo(1);
+		assertThat(bean.referenceCollection).hasSize(1);
 		assertThat(bean.referenceCollection.get(0)).isSameAs(bean2);
 	}
 
@@ -1326,16 +1326,16 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.consumeUniqueTestBean()).isEqualTo(bf.getBean("testBean"));
 
 		List<?> testBeans = bean.iterateTestBeans();
-		assertThat(testBeans.size()).isEqualTo(1);
+		assertThat(testBeans).hasSize(1);
 		assertThat(testBeans.contains(bf.getBean("testBean"))).isTrue();
 		testBeans = bean.forEachTestBeans();
-		assertThat(testBeans.size()).isEqualTo(1);
+		assertThat(testBeans).hasSize(1);
 		assertThat(testBeans.contains(bf.getBean("testBean"))).isTrue();
 		testBeans = bean.streamTestBeans();
-		assertThat(testBeans.size()).isEqualTo(1);
+		assertThat(testBeans).hasSize(1);
 		assertThat(testBeans.contains(bf.getBean("testBean"))).isTrue();
 		testBeans = bean.sortedTestBeans();
-		assertThat(testBeans.size()).isEqualTo(1);
+		assertThat(testBeans).hasSize(1);
 		assertThat(testBeans.contains(bf.getBean("testBean"))).isTrue();
 	}
 
@@ -1354,16 +1354,16 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.consumeUniqueTestBean()).isEqualTo(bf.getBean("testBean"));
 
 		List<?> testBeans = bean.iterateTestBeans();
-		assertThat(testBeans.size()).isEqualTo(1);
+		assertThat(testBeans).hasSize(1);
 		assertThat(testBeans.contains(bf.getBean("testBean"))).isTrue();
 		testBeans = bean.forEachTestBeans();
-		assertThat(testBeans.size()).isEqualTo(1);
+		assertThat(testBeans).hasSize(1);
 		assertThat(testBeans.contains(bf.getBean("testBean"))).isTrue();
 		testBeans = bean.streamTestBeans();
-		assertThat(testBeans.size()).isEqualTo(1);
+		assertThat(testBeans).hasSize(1);
 		assertThat(testBeans.contains(bf.getBean("testBean"))).isTrue();
 		testBeans = bean.sortedTestBeans();
-		assertThat(testBeans.size()).isEqualTo(1);
+		assertThat(testBeans).hasSize(1);
 		assertThat(testBeans.contains(bf.getBean("testBean"))).isTrue();
 	}
 
@@ -1405,19 +1405,19 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.consumeUniqueTestBean()).isNull();
 
 		List<?> testBeans = bean.iterateTestBeans();
-		assertThat(testBeans.size()).isEqualTo(2);
+		assertThat(testBeans).hasSize(2);
 		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean1"));
 		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean2"));
 		testBeans = bean.forEachTestBeans();
-		assertThat(testBeans.size()).isEqualTo(2);
+		assertThat(testBeans).hasSize(2);
 		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean1"));
 		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean2"));
 		testBeans = bean.streamTestBeans();
-		assertThat(testBeans.size()).isEqualTo(2);
+		assertThat(testBeans).hasSize(2);
 		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean1"));
 		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean2"));
 		testBeans = bean.sortedTestBeans();
-		assertThat(testBeans.size()).isEqualTo(2);
+		assertThat(testBeans).hasSize(2);
 		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean1"));
 		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean2"));
 	}
@@ -1443,19 +1443,19 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bf.containsSingleton("testBean2")).isFalse();
 
 		List<?> testBeans = bean.iterateTestBeans();
-		assertThat(testBeans.size()).isEqualTo(2);
+		assertThat(testBeans).hasSize(2);
 		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean1"));
 		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean2"));
 		testBeans = bean.forEachTestBeans();
-		assertThat(testBeans.size()).isEqualTo(2);
+		assertThat(testBeans).hasSize(2);
 		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean1"));
 		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean2"));
 		testBeans = bean.streamTestBeans();
-		assertThat(testBeans.size()).isEqualTo(2);
+		assertThat(testBeans).hasSize(2);
 		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean1"));
 		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean2"));
 		testBeans = bean.sortedTestBeans();
-		assertThat(testBeans.size()).isEqualTo(2);
+		assertThat(testBeans).hasSize(2);
 		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean2"));
 		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean1"));
 	}
@@ -1474,7 +1474,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 
 		ObjectProviderInjectionBean bean = (ObjectProviderInjectionBean) bf.getBean("annotatedBean");
 		List<?> testBeans = bean.sortedTestBeans();
-		assertThat(testBeans.size()).isEqualTo(2);
+		assertThat(testBeans).hasSize(2);
 		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean2"));
 		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean1"));
 	}

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

@@ -195,7 +195,7 @@ public class InjectAnnotationBeanPostProcessorTests {
 		ConstructorsCollectionResourceInjectionBean bean = (ConstructorsCollectionResourceInjectionBean) bf.getBean("annotatedBean");
 		assertThat(bean.getTestBean3()).isNull();
 		assertThat(bean.getTestBean4()).isSameAs(tb);
-		assertThat(bean.getNestedTestBeans().size()).isEqualTo(2);
+		assertThat(bean.getNestedTestBeans()).hasSize(2);
 		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb1);
 		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb2);
 	}
@@ -222,14 +222,14 @@ public class InjectAnnotationBeanPostProcessorTests {
 		bf.registerSingleton("testBean2", tb1);
 
 		MapConstructorInjectionBean bean = (MapConstructorInjectionBean) bf.getBean("annotatedBean");
-		assertThat(bean.getTestBeanMap().size()).isEqualTo(2);
+		assertThat(bean.getTestBeanMap()).hasSize(2);
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean1")).isTrue();
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean2")).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb1)).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb2)).isTrue();
 
 		bean = (MapConstructorInjectionBean) bf.getBean("annotatedBean");
-		assertThat(bean.getTestBeanMap().size()).isEqualTo(2);
+		assertThat(bean.getTestBeanMap()).hasSize(2);
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean1")).isTrue();
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean2")).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb1)).isTrue();
@@ -247,14 +247,14 @@ public class InjectAnnotationBeanPostProcessorTests {
 		bf.registerSingleton("testBean2", tb1);
 
 		MapFieldInjectionBean bean = (MapFieldInjectionBean) bf.getBean("annotatedBean");
-		assertThat(bean.getTestBeanMap().size()).isEqualTo(2);
+		assertThat(bean.getTestBeanMap()).hasSize(2);
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean1")).isTrue();
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean2")).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb1)).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb2)).isTrue();
 
 		bean = (MapFieldInjectionBean) bf.getBean("annotatedBean");
-		assertThat(bean.getTestBeanMap().size()).isEqualTo(2);
+		assertThat(bean.getTestBeanMap()).hasSize(2);
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean1")).isTrue();
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean2")).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb1)).isTrue();
@@ -270,13 +270,13 @@ public class InjectAnnotationBeanPostProcessorTests {
 		bf.registerSingleton("testBean", tb);
 
 		MapMethodInjectionBean bean = (MapMethodInjectionBean) bf.getBean("annotatedBean");
-		assertThat(bean.getTestBeanMap().size()).isEqualTo(1);
+		assertThat(bean.getTestBeanMap()).hasSize(1);
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean")).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb)).isTrue();
 		assertThat(bean.getTestBean()).isSameAs(tb);
 
 		bean = (MapMethodInjectionBean) bf.getBean("annotatedBean");
-		assertThat(bean.getTestBeanMap().size()).isEqualTo(1);
+		assertThat(bean.getTestBeanMap()).hasSize(1);
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean")).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb)).isTrue();
 		assertThat(bean.getTestBean()).isSameAs(tb);
@@ -301,7 +301,7 @@ public class InjectAnnotationBeanPostProcessorTests {
 
 		MapMethodInjectionBean bean = (MapMethodInjectionBean) bf.getBean("annotatedBean");
 		TestBean tb = (TestBean) bf.getBean("testBean1");
-		assertThat(bean.getTestBeanMap().size()).isEqualTo(1);
+		assertThat(bean.getTestBeanMap()).hasSize(1);
 		assertThat(bean.getTestBeanMap().keySet().contains("testBean1")).isTrue();
 		assertThat(bean.getTestBeanMap().values().contains(tb)).isTrue();
 		assertThat(bean.getTestBean()).isSameAs(tb);

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

@@ -399,19 +399,19 @@ public class PropertyResourceConfigurerTests {
 		assertThat(tb1.getName()).isEqualTo("namemyvarmyvar${");
 		assertThat(tb2.getName()).isEqualTo("myvarname98");
 		assertThat(tb1.getSpouse()).isEqualTo(tb2);
-		assertThat(tb1.getSomeMap().size()).isEqualTo(1);
+		assertThat(tb1.getSomeMap()).hasSize(1);
 		assertThat(tb1.getSomeMap().get("myKey")).isEqualTo("myValue");
 		assertThat(tb2.getStringArray().length).isEqualTo(2);
 		assertThat(tb2.getStringArray()[0]).isEqualTo(System.getProperty("os.name"));
 		assertThat(tb2.getStringArray()[1]).isEqualTo("98");
-		assertThat(tb2.getFriends().size()).isEqualTo(2);
+		assertThat(tb2.getFriends()).hasSize(2);
 		assertThat(tb2.getFriends().iterator().next()).isEqualTo("na98me");
 		assertThat(tb2.getFriends().toArray()[1]).isEqualTo(tb2);
-		assertThat(tb2.getSomeSet().size()).isEqualTo(3);
+		assertThat(tb2.getSomeSet()).hasSize(3);
 		assertThat(tb2.getSomeSet().contains("na98me")).isTrue();
 		assertThat(tb2.getSomeSet().contains(tb2)).isTrue();
 		assertThat(tb2.getSomeSet().contains(98)).isTrue();
-		assertThat(tb2.getSomeMap().size()).isEqualTo(6);
+		assertThat(tb2.getSomeMap()).hasSize(6);
 		assertThat(tb2.getSomeMap().get("key98")).isEqualTo("98");
 		assertThat(tb2.getSomeMap().get("key98ref")).isEqualTo(tb2);
 		assertThat(tb2.getSomeMap().get("key1")).isEqualTo(tb2);

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

@@ -47,7 +47,7 @@ public class YamlMapFactoryBeanTests {
 	public void testSetIgnoreResourceNotFound() {
 		this.factory.setResolutionMethod(YamlMapFactoryBean.ResolutionMethod.OVERRIDE_AND_IGNORE);
 		this.factory.setResources(new FileSystemResource("non-exsitent-file.yml"));
-		assertThat(this.factory.getObject().size()).isEqualTo(0);
+		assertThat(this.factory.getObject()).hasSize(0);
 	}
 
 	@Test
@@ -61,7 +61,7 @@ public class YamlMapFactoryBeanTests {
 	@Test
 	public void testGetObject() {
 		this.factory.setResources(new ByteArrayResource("foo: bar".getBytes()));
-		assertThat(this.factory.getObject().size()).isEqualTo(1);
+		assertThat(this.factory.getObject()).hasSize(1);
 	}
 
 	@SuppressWarnings("unchecked")
@@ -70,8 +70,8 @@ public class YamlMapFactoryBeanTests {
 		this.factory.setResources(new ByteArrayResource("foo:\n  bar: spam".getBytes()),
 				new ByteArrayResource("foo:\n  spam: bar".getBytes()));
 
-		assertThat(this.factory.getObject().size()).isEqualTo(1);
-		assertThat(((Map<String, Object>) this.factory.getObject().get("foo")).size()).isEqualTo(2);
+		assertThat(this.factory.getObject()).hasSize(1);
+		assertThat(((Map<String, Object>) this.factory.getObject().get("foo"))).hasSize(2);
 	}
 
 	@Test
@@ -88,7 +88,7 @@ public class YamlMapFactoryBeanTests {
 			}
 		}, new ByteArrayResource("foo:\n  spam: bar".getBytes()));
 
-		assertThat(this.factory.getObject().size()).isEqualTo(1);
+		assertThat(this.factory.getObject()).hasSize(1);
 	}
 
 	@Test
@@ -96,7 +96,7 @@ public class YamlMapFactoryBeanTests {
 		this.factory.setResources(new ByteArrayResource("foo:\n  ? key1.key2\n  : value".getBytes()));
 		Map<String, Object> map = this.factory.getObject();
 
-		assertThat(map.size()).isEqualTo(1);
+		assertThat(map).hasSize(1);
 		assertThat(map.containsKey("foo")).isTrue();
 		Object object = map.get("foo");
 		boolean condition = object instanceof LinkedHashMap;
@@ -112,14 +112,14 @@ public class YamlMapFactoryBeanTests {
 		this.factory.setResources(new ByteArrayResource("foo:\n  ? key1.key2\n  : 3".getBytes()));
 		Map<String, Object> map = this.factory.getObject();
 
-		assertThat(map.size()).isEqualTo(1);
+		assertThat(map).hasSize(1);
 		assertThat(map.containsKey("foo")).isTrue();
 		Object object = map.get("foo");
 		boolean condition = object instanceof LinkedHashMap;
 		assertThat(condition).isTrue();
 		@SuppressWarnings("unchecked")
 		Map<String, Object> sub = (Map<String, Object>) object;
-		assertThat(sub.size()).isEqualTo(1);
+		assertThat(sub).hasSize(1);
 		assertThat(sub.get("key1.key2")).isEqualTo(3);
 	}
 

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

@@ -52,7 +52,7 @@ class YamlProcessorTests {
 	void arrayConvertedToIndexedBeanReference() {
 		setYaml("foo: bar\nbar: [1,2,3]");
 		this.processor.process((properties, map) -> {
-			assertThat(properties.size()).isEqualTo(4);
+			assertThat(properties).hasSize(4);
 			assertThat(properties.get("foo")).isEqualTo("bar");
 			assertThat(properties.getProperty("foo")).isEqualTo("bar");
 			assertThat(properties.get("bar[0]")).isEqualTo(1);

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

@@ -181,7 +181,7 @@ public class BeanDefinitionTests {
 		RootBeanDefinition mergedBd = new RootBeanDefinition(bd);
 		mergedBd.overrideFrom(childBd);
 		assertThat(mergedBd.getConstructorArgumentValues().getArgumentCount()).isEqualTo(2);
-		assertThat(mergedBd.getPropertyValues().size()).isEqualTo(2);
+		assertThat(mergedBd.getPropertyValues()).hasSize(2);
 		assertThat(mergedBd).isEqualTo(bd);
 
 		mergedBd.getConstructorArgumentValues().getArgumentValue(1, null).setValue(9);

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

@@ -166,7 +166,7 @@ class BeanFactoryGenericsTests {
 				new ClassPathResource("genericBeanTests.xml", getClass()));
 		GenericBean<?> gb = (GenericBean<?>) bf.getBean("listOfArrays");
 
-		assertThat(gb.getListOfArrays().size()).isEqualTo(1);
+		assertThat(gb.getListOfArrays()).hasSize(1);
 		String[] array = gb.getListOfArrays().get(0);
 		assertThat(array).hasSize(2);
 		assertThat(array[0]).isEqualTo("value1");
@@ -338,7 +338,7 @@ class BeanFactoryGenericsTests {
 		assertThat(gb.getPlainMap()).hasSize(2);
 		assertThat(gb.getPlainMap().get("1")).isEqualTo("0");
 		assertThat(gb.getPlainMap().get("2")).isEqualTo("3");
-		assertThat(gb.getShortMap().size()).isEqualTo(2);
+		assertThat(gb.getShortMap()).hasSize(2);
 		assertThat(gb.getShortMap().get(Short.valueOf("4"))).isEqualTo(5);
 		assertThat(gb.getShortMap().get(Short.valueOf("6"))).isEqualTo(7);
 	}
@@ -361,7 +361,7 @@ class BeanFactoryGenericsTests {
 		assertThat(gb.getPlainMap()).hasSize(2);
 		assertThat(gb.getPlainMap().get("1")).isEqualTo("0");
 		assertThat(gb.getPlainMap().get("2")).isEqualTo("3");
-		assertThat(gb.getShortMap().size()).isEqualTo(2);
+		assertThat(gb.getShortMap()).hasSize(2);
 		assertThat(gb.getShortMap().get(Short.valueOf("1"))).isEqualTo(0);
 		assertThat(gb.getShortMap().get(Short.valueOf("2"))).isEqualTo(3);
 	}
@@ -589,7 +589,7 @@ class BeanFactoryGenericsTests {
 		new XmlBeanDefinitionReader(bf).loadBeanDefinitions(
 				new ClassPathResource("genericBeanTests.xml", getClass()));
 		List<?> list = (List<?>) bf.getBean("list");
-		assertThat(list.size()).isEqualTo(1);
+		assertThat(list).hasSize(1);
 		assertThat(list.get(0)).isEqualTo(new URL("http://localhost:8080"));
 	}
 
@@ -599,7 +599,7 @@ class BeanFactoryGenericsTests {
 		new XmlBeanDefinitionReader(bf).loadBeanDefinitions(
 				new ClassPathResource("genericBeanTests.xml", getClass()));
 		Set<?> set = (Set<?>) bf.getBean("set");
-		assertThat(set.size()).isEqualTo(1);
+		assertThat(set).hasSize(1);
 		assertThat(set.iterator().next()).isEqualTo(new URL("http://localhost:8080"));
 	}
 
@@ -643,7 +643,7 @@ class BeanFactoryGenericsTests {
 		new XmlBeanDefinitionReader(bf).loadBeanDefinitions(
 				new ClassPathResource("genericBeanTests.xml", getClass()));
 		UrlSet us = (UrlSet) bf.getBean("setBean");
-		assertThat(us.size()).isEqualTo(1);
+		assertThat(us).hasSize(1);
 		assertThat(us.iterator().next()).isEqualTo(new URL("https://www.springframework.org"));
 	}
 
@@ -879,17 +879,17 @@ class BeanFactoryGenericsTests {
 		for (NumberStore<?> instance : numberStoreProvider) {
 			resolved.add(instance);
 		}
-		assertThat(resolved.size()).isEqualTo(2);
+		assertThat(resolved).hasSize(2);
 		assertThat(resolved.get(0)).isSameAs(bf.getBean("store1"));
 		assertThat(resolved.get(1)).isSameAs(bf.getBean("store2"));
 
 		resolved = numberStoreProvider.stream().toList();
-		assertThat(resolved.size()).isEqualTo(2);
+		assertThat(resolved).hasSize(2);
 		assertThat(resolved.get(0)).isSameAs(bf.getBean("store1"));
 		assertThat(resolved.get(1)).isSameAs(bf.getBean("store2"));
 
 		resolved = numberStoreProvider.orderedStream().toList();
-		assertThat(resolved.size()).isEqualTo(2);
+		assertThat(resolved).hasSize(2);
 		assertThat(resolved.get(0)).isSameAs(bf.getBean("store2"));
 		assertThat(resolved.get(1)).isSameAs(bf.getBean("store1"));
 
@@ -897,30 +897,30 @@ class BeanFactoryGenericsTests {
 		for (NumberStore<Double> instance : doubleStoreProvider) {
 			resolved.add(instance);
 		}
-		assertThat(resolved.size()).isEqualTo(1);
+		assertThat(resolved).hasSize(1);
 		assertThat(resolved.contains(bf.getBean("store1"))).isTrue();
 
 		resolved = doubleStoreProvider.stream().collect(Collectors.toList());
-		assertThat(resolved.size()).isEqualTo(1);
+		assertThat(resolved).hasSize(1);
 		assertThat(resolved.contains(bf.getBean("store1"))).isTrue();
 
 		resolved = doubleStoreProvider.orderedStream().collect(Collectors.toList());
-		assertThat(resolved.size()).isEqualTo(1);
+		assertThat(resolved).hasSize(1);
 		assertThat(resolved.contains(bf.getBean("store1"))).isTrue();
 
 		resolved = new ArrayList<>();
 		for (NumberStore<Float> instance : floatStoreProvider) {
 			resolved.add(instance);
 		}
-		assertThat(resolved.size()).isEqualTo(1);
+		assertThat(resolved).hasSize(1);
 		assertThat(resolved.contains(bf.getBean("store2"))).isTrue();
 
 		resolved = floatStoreProvider.stream().collect(Collectors.toList());
-		assertThat(resolved.size()).isEqualTo(1);
+		assertThat(resolved).hasSize(1);
 		assertThat(resolved.contains(bf.getBean("store2"))).isTrue();
 
 		resolved = floatStoreProvider.orderedStream().collect(Collectors.toList());
-		assertThat(resolved.size()).isEqualTo(1);
+		assertThat(resolved).hasSize(1);
 		assertThat(resolved.contains(bf.getBean("store2"))).isTrue();
 	}
 
@@ -939,7 +939,7 @@ class BeanFactoryGenericsTests {
 
 		ObjectProvider<NumberStore<?>> numberStoreProvider = bf.getBeanProvider(ResolvableType.forClass(NumberStore.class));
 		List<NumberStore<?>> resolved = numberStoreProvider.orderedStream().toList();
-		assertThat(resolved.size()).isEqualTo(2);
+		assertThat(resolved).hasSize(2);
 		assertThat(resolved.get(0)).isSameAs(bf.getBean("store2"));
 		assertThat(resolved.get(1)).isSameAs(bf.getBean("store1"));
 	}
@@ -963,9 +963,9 @@ class BeanFactoryGenericsTests {
 	public static class CollectionDependentBean {
 
 		public CollectionDependentBean(NamedUrlList list, NamedUrlSet set, NamedUrlMap map) {
-			assertThat(list.size()).isEqualTo(1);
-			assertThat(set.size()).isEqualTo(1);
-			assertThat(map.size()).isEqualTo(1);
+			assertThat(list).hasSize(1);
+			assertThat(set).hasSize(1);
+			assertThat(map).hasSize(1);
 		}
 	}
 

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

@@ -65,7 +65,7 @@ public class CollectionMergingTests {
 		TestBean bean = (TestBean) this.beanFactory.getBean("childWithListOfRefs");
 		List<?> list = bean.getSomeList();
 		assertThat(list).isNotNull();
-		assertThat(list.size()).isEqualTo(3);
+		assertThat(list).hasSize(3);
 		assertThat(list.get(2)).isNotNull();
 		boolean condition = list.get(2) instanceof TestBean;
 		assertThat(condition).isTrue();
@@ -85,7 +85,7 @@ public class CollectionMergingTests {
 		TestBean bean = (TestBean) this.beanFactory.getBean("childWithSetOfRefs");
 		Set<?> set = bean.getSomeSet();
 		assertThat(set).isNotNull();
-		assertThat(set.size()).isEqualTo(2);
+		assertThat(set).hasSize(2);
 		Iterator it = set.iterator();
 		it.next();
 		Object o = it.next();
@@ -110,7 +110,7 @@ public class CollectionMergingTests {
 		TestBean bean = (TestBean) this.beanFactory.getBean("childWithMapOfRefs");
 		Map<?, ?> map = bean.getSomeMap();
 		assertThat(map).isNotNull();
-		assertThat(map.size()).isEqualTo(2);
+		assertThat(map).hasSize(2);
 		assertThat(map.get("Rob")).isNotNull();
 		boolean condition = map.get("Rob") instanceof TestBean;
 		assertThat(condition).isTrue();
@@ -142,7 +142,7 @@ public class CollectionMergingTests {
 		TestBean bean = (TestBean) this.beanFactory.getBean("childWithListOfRefsInConstructor");
 		List<?> list = bean.getSomeList();
 		assertThat(list).isNotNull();
-		assertThat(list.size()).isEqualTo(3);
+		assertThat(list).hasSize(3);
 		assertThat(list.get(2)).isNotNull();
 		boolean condition = list.get(2) instanceof TestBean;
 		assertThat(condition).isTrue();
@@ -162,7 +162,7 @@ public class CollectionMergingTests {
 		TestBean bean = (TestBean) this.beanFactory.getBean("childWithSetOfRefsInConstructor");
 		Set<?> set = bean.getSomeSet();
 		assertThat(set).isNotNull();
-		assertThat(set.size()).isEqualTo(2);
+		assertThat(set).hasSize(2);
 		Iterator it = set.iterator();
 		it.next();
 		Object o = it.next();
@@ -187,7 +187,7 @@ public class CollectionMergingTests {
 		TestBean bean = (TestBean) this.beanFactory.getBean("childWithMapOfRefsInConstructor");
 		Map<?, ?> map = bean.getSomeMap();
 		assertThat(map).isNotNull();
-		assertThat(map.size()).isEqualTo(2);
+		assertThat(map).hasSize(2);
 		assertThat(map.get("Rob")).isNotNull();
 		boolean condition = map.get("Rob") instanceof TestBean;
 		assertThat(condition).isTrue();

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * Copyright 2002-2022 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,6 +27,7 @@ import org.springframework.beans.factory.config.TypedStringValue;
 import org.springframework.beans.factory.parsing.AliasDefinition;
 import org.springframework.beans.factory.parsing.BeanComponentDefinition;
 import org.springframework.beans.factory.parsing.ComponentDefinition;
+import org.springframework.beans.factory.parsing.DefaultsDefinition;
 import org.springframework.beans.factory.parsing.ImportDefinition;
 import org.springframework.beans.factory.parsing.PassThroughSourceExtractor;
 import org.springframework.beans.factory.support.DefaultListableBeanFactory;
@@ -40,7 +41,7 @@ import static org.assertj.core.api.Assertions.assertThat;
  * @author Juergen Hoeller
  */
 @SuppressWarnings("rawtypes")
-public class EventPublicationTests {
+class EventPublicationTests {
 
 	private final DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
 
@@ -49,7 +50,7 @@ public class EventPublicationTests {
 
 
 	@BeforeEach
-	public void setUp() throws Exception {
+	void setUp() throws Exception {
 		XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this.beanFactory);
 		reader.setEventListener(this.eventListener);
 		reader.setSourceExtractor(new PassThroughSourceExtractor());
@@ -57,27 +58,23 @@ public class EventPublicationTests {
 	}
 
 	@Test
-	public void defaultsEventReceived() throws Exception {
-		List defaultsList = this.eventListener.getDefaults();
-		boolean condition2 = !defaultsList.isEmpty();
-		assertThat(condition2).isTrue();
-		boolean condition1 = defaultsList.get(0) instanceof DocumentDefaultsDefinition;
-		assertThat(condition1).isTrue();
+	void defaultsEventReceived() throws Exception {
+		List<DefaultsDefinition> defaultsList = this.eventListener.getDefaults();
+		assertThat(defaultsList).isNotEmpty();
+		assertThat(defaultsList.get(0)).isInstanceOf(DocumentDefaultsDefinition.class);
 		DocumentDefaultsDefinition defaults = (DocumentDefaultsDefinition) defaultsList.get(0);
 		assertThat(defaults.getLazyInit()).isEqualTo("true");
 		assertThat(defaults.getAutowire()).isEqualTo("constructor");
 		assertThat(defaults.getInitMethod()).isEqualTo("myInit");
 		assertThat(defaults.getDestroyMethod()).isEqualTo("myDestroy");
 		assertThat(defaults.getMerge()).isEqualTo("true");
-		boolean condition = defaults.getSource() instanceof Element;
-		assertThat(condition).isTrue();
+		assertThat(defaults.getSource()).isInstanceOf(Element.class);
 	}
 
 	@Test
-	public void beanEventReceived() throws Exception {
+	void beanEventReceived() throws Exception {
 		ComponentDefinition componentDefinition1 = this.eventListener.getComponentDefinition("testBean");
-		boolean condition3 = componentDefinition1 instanceof BeanComponentDefinition;
-		assertThat(condition3).isTrue();
+		assertThat(componentDefinition1).isInstanceOf(BeanComponentDefinition.class);
 		assertThat(componentDefinition1.getBeanDefinitions().length).isEqualTo(1);
 		BeanDefinition beanDefinition1 = componentDefinition1.getBeanDefinitions()[0];
 		assertThat(beanDefinition1.getConstructorArgumentValues().getGenericArgumentValue(String.class).getValue()).isEqualTo(new TypedStringValue("Rob Harrop"));
@@ -86,12 +83,10 @@ public class EventPublicationTests {
 		assertThat(componentDefinition1.getInnerBeanDefinitions().length).isEqualTo(1);
 		BeanDefinition innerBd1 = componentDefinition1.getInnerBeanDefinitions()[0];
 		assertThat(innerBd1.getConstructorArgumentValues().getGenericArgumentValue(String.class).getValue()).isEqualTo(new TypedStringValue("ACME"));
-		boolean condition2 = componentDefinition1.getSource() instanceof Element;
-		assertThat(condition2).isTrue();
+		assertThat(componentDefinition1.getSource()).isInstanceOf(Element.class);
 
 		ComponentDefinition componentDefinition2 = this.eventListener.getComponentDefinition("testBean2");
-		boolean condition1 = componentDefinition2 instanceof BeanComponentDefinition;
-		assertThat(condition1).isTrue();
+		assertThat(componentDefinition2).isInstanceOf(BeanComponentDefinition.class);
 		assertThat(componentDefinition1.getBeanDefinitions().length).isEqualTo(1);
 		BeanDefinition beanDefinition2 = componentDefinition2.getBeanDefinitions()[0];
 		assertThat(beanDefinition2.getPropertyValues().getPropertyValue("name").getValue()).isEqualTo(new TypedStringValue("Juergen Hoeller"));
@@ -99,32 +94,28 @@ public class EventPublicationTests {
 		assertThat(componentDefinition2.getInnerBeanDefinitions().length).isEqualTo(1);
 		BeanDefinition innerBd2 = componentDefinition2.getInnerBeanDefinitions()[0];
 		assertThat(innerBd2.getPropertyValues().getPropertyValue("name").getValue()).isEqualTo(new TypedStringValue("Eva Schallmeiner"));
-		boolean condition = componentDefinition2.getSource() instanceof Element;
-		assertThat(condition).isTrue();
+		assertThat(componentDefinition2.getSource()).isInstanceOf(Element.class);
 	}
 
 	@Test
-	public void aliasEventReceived() throws Exception {
-		List aliases = this.eventListener.getAliases("testBean");
-		assertThat(aliases.size()).isEqualTo(2);
-		AliasDefinition aliasDefinition1 = (AliasDefinition) aliases.get(0);
+	void aliasEventReceived() throws Exception {
+		List<AliasDefinition> aliases = this.eventListener.getAliases("testBean");
+		assertThat(aliases).hasSize(2);
+		AliasDefinition aliasDefinition1 = aliases.get(0);
 		assertThat(aliasDefinition1.getAlias()).isEqualTo("testBeanAlias1");
-		boolean condition1 = aliasDefinition1.getSource() instanceof Element;
-		assertThat(condition1).isTrue();
-		AliasDefinition aliasDefinition2 = (AliasDefinition) aliases.get(1);
+		assertThat(aliasDefinition1.getSource()).isInstanceOf(Element.class);
+		AliasDefinition aliasDefinition2 = aliases.get(1);
 		assertThat(aliasDefinition2.getAlias()).isEqualTo("testBeanAlias2");
-		boolean condition = aliasDefinition2.getSource() instanceof Element;
-		assertThat(condition).isTrue();
+		assertThat(aliasDefinition2.getSource()).isInstanceOf(Element.class);
 	}
 
 	@Test
-	public void importEventReceived() throws Exception {
-		List imports = this.eventListener.getImports();
-		assertThat(imports.size()).isEqualTo(1);
-		ImportDefinition importDefinition = (ImportDefinition) imports.get(0);
+	void importEventReceived() throws Exception {
+		List<ImportDefinition> imports = this.eventListener.getImports();
+		assertThat(imports).hasSize(1);
+		ImportDefinition importDefinition = imports.get(0);
 		assertThat(importDefinition.getImportedResource()).isEqualTo("beanEventsImported.xml");
-		boolean condition = importDefinition.getSource() instanceof Element;
-		assertThat(condition).isTrue();
+		assertThat(importDefinition.getSource()).isInstanceOf(Element.class);
 	}
 
 }

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

@@ -54,7 +54,7 @@ public class UtilNamespaceHandlerTests {
 
 
 	@BeforeEach
-	public void setUp() {
+	void setUp() {
 		this.beanFactory = new DefaultListableBeanFactory();
 		XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this.beanFactory);
 		reader.setEventListener(this.listener);
@@ -63,19 +63,19 @@ public class UtilNamespaceHandlerTests {
 
 
 	@Test
-	public void testConstant() {
+	void testConstant() {
 		Integer min = (Integer) this.beanFactory.getBean("min");
 		assertThat(min.intValue()).isEqualTo(Integer.MIN_VALUE);
 	}
 
 	@Test
-	public void testConstantWithDefaultName() {
+	void testConstantWithDefaultName() {
 		Integer max = (Integer) this.beanFactory.getBean("java.lang.Integer.MAX_VALUE");
 		assertThat(max.intValue()).isEqualTo(Integer.MAX_VALUE);
 	}
 
 	@Test
-	public void testEvents() {
+	void testEvents() {
 		ComponentDefinition propertiesComponent = this.listener.getComponentDefinition("myProperties");
 		assertThat(propertiesComponent).as("Event for 'myProperties' not sent").isNotNull();
 		AbstractBeanDefinition propertiesBean = (AbstractBeanDefinition) propertiesComponent.getBeanDefinitions()[0];
@@ -88,109 +88,106 @@ public class UtilNamespaceHandlerTests {
 	}
 
 	@Test
-	public void testNestedProperties() {
+	void testNestedProperties() {
 		TestBean bean = (TestBean) this.beanFactory.getBean("testBean");
 		Properties props = bean.getSomeProperties();
 		assertThat(props.get("foo")).as("Incorrect property value").isEqualTo("bar");
 	}
 
 	@Test
-	public void testPropertyPath() {
+	void testPropertyPath() {
 		String name = (String) this.beanFactory.getBean("name");
 		assertThat(name).isEqualTo("Rob Harrop");
 	}
 
 	@Test
-	public void testNestedPropertyPath() {
+	void testNestedPropertyPath() {
 		TestBean bean = (TestBean) this.beanFactory.getBean("testBean");
 		assertThat(bean.getName()).isEqualTo("Rob Harrop");
 	}
 
 	@Test
-	public void testSimpleMap() {
-		Map map = (Map) this.beanFactory.getBean("simpleMap");
+	void testSimpleMap() {
+		Map<?, ?> map = (Map) this.beanFactory.getBean("simpleMap");
 		assertThat(map.get("foo")).isEqualTo("bar");
-		Map map2 = (Map) this.beanFactory.getBean("simpleMap");
+		Map<?, ?> map2 = (Map) this.beanFactory.getBean("simpleMap");
 		assertThat(map == map2).isTrue();
 	}
 
 	@Test
-	public void testScopedMap() {
-		Map map = (Map) this.beanFactory.getBean("scopedMap");
+	void testScopedMap() {
+		Map<?, ?> map = (Map) this.beanFactory.getBean("scopedMap");
 		assertThat(map.get("foo")).isEqualTo("bar");
-		Map map2 = (Map) this.beanFactory.getBean("scopedMap");
+		Map<?, ?> map2 = (Map) this.beanFactory.getBean("scopedMap");
 		assertThat(map2.get("foo")).isEqualTo("bar");
 		assertThat(map != map2).isTrue();
 	}
 
 	@Test
-	public void testSimpleList() {
-		List list = (List) this.beanFactory.getBean("simpleList");
+	void testSimpleList() {
+		List<?> list = (List) this.beanFactory.getBean("simpleList");
 		assertThat(list.get(0)).isEqualTo("Rob Harrop");
-		List list2 = (List) this.beanFactory.getBean("simpleList");
+		List<?> list2 = (List) this.beanFactory.getBean("simpleList");
 		assertThat(list == list2).isTrue();
 	}
 
 	@Test
-	public void testScopedList() {
-		List list = (List) this.beanFactory.getBean("scopedList");
+	void testScopedList() {
+		List<?> list = (List) this.beanFactory.getBean("scopedList");
 		assertThat(list.get(0)).isEqualTo("Rob Harrop");
-		List list2 = (List) this.beanFactory.getBean("scopedList");
+		List<?> list2 = (List) this.beanFactory.getBean("scopedList");
 		assertThat(list2.get(0)).isEqualTo("Rob Harrop");
 		assertThat(list != list2).isTrue();
 	}
 
 	@Test
-	public void testSimpleSet() {
-		Set set = (Set) this.beanFactory.getBean("simpleSet");
+	void testSimpleSet() {
+		Set<?> set = (Set) this.beanFactory.getBean("simpleSet");
 		assertThat(set.contains("Rob Harrop")).isTrue();
-		Set set2 = (Set) this.beanFactory.getBean("simpleSet");
+		Set<?> set2 = (Set) this.beanFactory.getBean("simpleSet");
 		assertThat(set == set2).isTrue();
 	}
 
 	@Test
-	public void testScopedSet() {
-		Set set = (Set) this.beanFactory.getBean("scopedSet");
+	void testScopedSet() {
+		Set<?> set = (Set) this.beanFactory.getBean("scopedSet");
 		assertThat(set.contains("Rob Harrop")).isTrue();
-		Set set2 = (Set) this.beanFactory.getBean("scopedSet");
+		Set<?> set2 = (Set) this.beanFactory.getBean("scopedSet");
 		assertThat(set2.contains("Rob Harrop")).isTrue();
 		assertThat(set != set2).isTrue();
 	}
 
 	@Test
-	public void testMapWithRef() {
-		Map map = (Map) this.beanFactory.getBean("mapWithRef");
-		boolean condition = map instanceof TreeMap;
-		assertThat(condition).isTrue();
+	void testMapWithRef() {
+		Map<?, ?> map = (Map) this.beanFactory.getBean("mapWithRef");
+		assertThat(map).isInstanceOf(TreeMap.class);
 		assertThat(map.get("bean")).isEqualTo(this.beanFactory.getBean("testBean"));
 	}
 
 	@Test
-	public void testMapWithTypes() {
-		Map map = (Map) this.beanFactory.getBean("mapWithTypes");
-		boolean condition = map instanceof LinkedCaseInsensitiveMap;
-		assertThat(condition).isTrue();
+	void testMapWithTypes() {
+		Map<?, ?> map = (Map) this.beanFactory.getBean("mapWithTypes");
+		assertThat(map).isInstanceOf(LinkedCaseInsensitiveMap.class);
 		assertThat(map.get("bean")).isEqualTo(this.beanFactory.getBean("testBean"));
 	}
 
 	@Test
-	public void testNestedCollections() {
+	void testNestedCollections() {
 		TestBean bean = (TestBean) this.beanFactory.getBean("nestedCollectionsBean");
 
-		List list = bean.getSomeList();
-		assertThat(list.size()).isEqualTo(1);
+		List<?> list = bean.getSomeList();
+		assertThat(list).hasSize(1);
 		assertThat(list.get(0)).isEqualTo("foo");
 
-		Set set = bean.getSomeSet();
-		assertThat(set.size()).isEqualTo(1);
+		Set<?> set = bean.getSomeSet();
+		assertThat(set).hasSize(1);
 		assertThat(set.contains("bar")).isTrue();
 
-		Map map = bean.getSomeMap();
-		assertThat(map.size()).isEqualTo(1);
-		boolean condition = map.get("foo") instanceof Set;
-		assertThat(condition).isTrue();
-		Set innerSet = (Set) map.get("foo");
-		assertThat(innerSet.size()).isEqualTo(1);
+		Map<?, ?> map = bean.getSomeMap();
+		assertThat(map).hasSize(1);
+		assertThat(map.get("foo")).isInstanceOf(Set.class);
+		Set<?> innerSet = (Set) map.get("foo");
+		assertThat(innerSet).hasSize(1);
 		assertThat(innerSet.contains("bar")).isTrue();
 
 		TestBean bean2 = (TestBean) this.beanFactory.getBean("nestedCollectionsBean");
@@ -203,18 +200,18 @@ public class UtilNamespaceHandlerTests {
 	}
 
 	@Test
-	public void testNestedShortcutCollections() {
+	void testNestedShortcutCollections() {
 		TestBean bean = (TestBean) this.beanFactory.getBean("nestedShortcutCollections");
 
 		assertThat(bean.getStringArray().length).isEqualTo(1);
 		assertThat(bean.getStringArray()[0]).isEqualTo("fooStr");
 
-		List list = bean.getSomeList();
-		assertThat(list.size()).isEqualTo(1);
+		List<?> list = bean.getSomeList();
+		assertThat(list).hasSize(1);
 		assertThat(list.get(0)).isEqualTo("foo");
 
-		Set set = bean.getSomeSet();
-		assertThat(set.size()).isEqualTo(1);
+		Set<?> set = bean.getSomeSet();
+		assertThat(set).hasSize(1);
 		assertThat(set.contains("bar")).isTrue();
 
 		TestBean bean2 = (TestBean) this.beanFactory.getBean("nestedShortcutCollections");
@@ -227,20 +224,20 @@ public class UtilNamespaceHandlerTests {
 	}
 
 	@Test
-	public void testNestedInCollections() {
+	void testNestedInCollections() {
 		TestBean bean = (TestBean) this.beanFactory.getBean("nestedCustomTagBean");
 
-		List list = bean.getSomeList();
-		assertThat(list.size()).isEqualTo(1);
+		List<?> list = bean.getSomeList();
+		assertThat(list).hasSize(1);
 		assertThat(list.get(0)).isEqualTo(Integer.MIN_VALUE);
 
-		Set set = bean.getSomeSet();
-		assertThat(set.size()).isEqualTo(2);
+		Set<?> set = bean.getSomeSet();
+		assertThat(set).hasSize(2);
 		assertThat(set.contains(Thread.State.NEW)).isTrue();
 		assertThat(set.contains(Thread.State.RUNNABLE)).isTrue();
 
-		Map map = bean.getSomeMap();
-		assertThat(map.size()).isEqualTo(1);
+		Map<?, ?> map = bean.getSomeMap();
+		assertThat(map).hasSize(1);
 		assertThat(map.get("min")).isEqualTo(CustomEnum.VALUE_1);
 
 		TestBean bean2 = (TestBean) this.beanFactory.getBean("nestedCustomTagBean");
@@ -253,93 +250,93 @@ public class UtilNamespaceHandlerTests {
 	}
 
 	@Test
-	public void testCircularCollections() {
+	void testCircularCollections() {
 		TestBean bean = (TestBean) this.beanFactory.getBean("circularCollectionsBean");
 
-		List list = bean.getSomeList();
-		assertThat(list.size()).isEqualTo(1);
+		List<?> list = bean.getSomeList();
+		assertThat(list).hasSize(1);
 		assertThat(list.get(0)).isEqualTo(bean);
 
-		Set set = bean.getSomeSet();
-		assertThat(set.size()).isEqualTo(1);
+		Set<?> set = bean.getSomeSet();
+		assertThat(set).hasSize(1);
 		assertThat(set.contains(bean)).isTrue();
 
-		Map map = bean.getSomeMap();
-		assertThat(map.size()).isEqualTo(1);
+		Map<?, ?> map = bean.getSomeMap();
+		assertThat(map).hasSize(1);
 		assertThat(map.get("foo")).isEqualTo(bean);
 	}
 
 	@Test
-	public void testCircularCollectionBeansStartingWithList() {
+	void testCircularCollectionBeansStartingWithList() {
 		this.beanFactory.getBean("circularList");
 		TestBean bean = (TestBean) this.beanFactory.getBean("circularCollectionBeansBean");
 
-		List list = bean.getSomeList();
+		List<?> list = bean.getSomeList();
 		assertThat(Proxy.isProxyClass(list.getClass())).isTrue();
-		assertThat(list.size()).isEqualTo(1);
+		assertThat(list).hasSize(1);
 		assertThat(list.get(0)).isEqualTo(bean);
 
-		Set set = bean.getSomeSet();
+		Set<?> set = bean.getSomeSet();
 		assertThat(Proxy.isProxyClass(set.getClass())).isFalse();
-		assertThat(set.size()).isEqualTo(1);
+		assertThat(set).hasSize(1);
 		assertThat(set.contains(bean)).isTrue();
 
-		Map map = bean.getSomeMap();
+		Map<?, ?> map = bean.getSomeMap();
 		assertThat(Proxy.isProxyClass(map.getClass())).isFalse();
-		assertThat(map.size()).isEqualTo(1);
+		assertThat(map).hasSize(1);
 		assertThat(map.get("foo")).isEqualTo(bean);
 	}
 
 	@Test
-	public void testCircularCollectionBeansStartingWithSet() {
+	void testCircularCollectionBeansStartingWithSet() {
 		this.beanFactory.getBean("circularSet");
 		TestBean bean = (TestBean) this.beanFactory.getBean("circularCollectionBeansBean");
 
-		List list = bean.getSomeList();
+		List<?> list = bean.getSomeList();
 		assertThat(Proxy.isProxyClass(list.getClass())).isFalse();
-		assertThat(list.size()).isEqualTo(1);
+		assertThat(list).hasSize(1);
 		assertThat(list.get(0)).isEqualTo(bean);
 
-		Set set = bean.getSomeSet();
+		Set<?> set = bean.getSomeSet();
 		assertThat(Proxy.isProxyClass(set.getClass())).isTrue();
-		assertThat(set.size()).isEqualTo(1);
+		assertThat(set).hasSize(1);
 		assertThat(set.contains(bean)).isTrue();
 
-		Map map = bean.getSomeMap();
+		Map<?, ?> map = bean.getSomeMap();
 		assertThat(Proxy.isProxyClass(map.getClass())).isFalse();
-		assertThat(map.size()).isEqualTo(1);
+		assertThat(map).hasSize(1);
 		assertThat(map.get("foo")).isEqualTo(bean);
 	}
 
 	@Test
-	public void testCircularCollectionBeansStartingWithMap() {
+	void testCircularCollectionBeansStartingWithMap() {
 		this.beanFactory.getBean("circularMap");
 		TestBean bean = (TestBean) this.beanFactory.getBean("circularCollectionBeansBean");
 
-		List list = bean.getSomeList();
+		List<?> list = bean.getSomeList();
 		assertThat(Proxy.isProxyClass(list.getClass())).isFalse();
-		assertThat(list.size()).isEqualTo(1);
+		assertThat(list).hasSize(1);
 		assertThat(list.get(0)).isEqualTo(bean);
 
-		Set set = bean.getSomeSet();
+		Set<?> set = bean.getSomeSet();
 		assertThat(Proxy.isProxyClass(set.getClass())).isFalse();
-		assertThat(set.size()).isEqualTo(1);
+		assertThat(set).hasSize(1);
 		assertThat(set.contains(bean)).isTrue();
 
-		Map map = bean.getSomeMap();
+		Map<?, ?> map = bean.getSomeMap();
 		assertThat(Proxy.isProxyClass(map.getClass())).isTrue();
-		assertThat(map.size()).isEqualTo(1);
+		assertThat(map).hasSize(1);
 		assertThat(map.get("foo")).isEqualTo(bean);
 	}
 
 	@Test
-	public void testNestedInConstructor() {
+	void testNestedInConstructor() {
 		TestBean bean = (TestBean) this.beanFactory.getBean("constructedTestBean");
 		assertThat(bean.getName()).isEqualTo("Rob Harrop");
 	}
 
 	@Test
-	public void testLoadProperties() {
+	void testLoadProperties() {
 		Properties props = (Properties) this.beanFactory.getBean("myProperties");
 		assertThat(props.get("foo")).as("Incorrect property value").isEqualTo("bar");
 		assertThat(props.get("foo2")).as("Incorrect property value").isNull();
@@ -348,7 +345,7 @@ public class UtilNamespaceHandlerTests {
 	}
 
 	@Test
-	public void testScopedProperties() {
+	void testScopedProperties() {
 		Properties props = (Properties) this.beanFactory.getBean("myScopedProperties");
 		assertThat(props.get("foo")).as("Incorrect property value").isEqualTo("bar");
 		assertThat(props.get("foo2")).as("Incorrect property value").isNull();
@@ -359,35 +356,35 @@ public class UtilNamespaceHandlerTests {
 	}
 
 	@Test
-	public void testLocalProperties() {
+	void testLocalProperties() {
 		Properties props = (Properties) this.beanFactory.getBean("myLocalProperties");
 		assertThat(props.get("foo")).as("Incorrect property value").isNull();
 		assertThat(props.get("foo2")).as("Incorrect property value").isEqualTo("bar2");
 	}
 
 	@Test
-	public void testMergedProperties() {
+	void testMergedProperties() {
 		Properties props = (Properties) this.beanFactory.getBean("myMergedProperties");
 		assertThat(props.get("foo")).as("Incorrect property value").isEqualTo("bar");
 		assertThat(props.get("foo2")).as("Incorrect property value").isEqualTo("bar2");
 	}
 
 	@Test
-	public void testLocalOverrideDefault() {
+	void testLocalOverrideDefault() {
 		Properties props = (Properties) this.beanFactory.getBean("defaultLocalOverrideProperties");
 		assertThat(props.get("foo")).as("Incorrect property value").isEqualTo("bar");
 		assertThat(props.get("foo2")).as("Incorrect property value").isEqualTo("local2");
 	}
 
 	@Test
-	public void testLocalOverrideFalse() {
+	void testLocalOverrideFalse() {
 		Properties props = (Properties) this.beanFactory.getBean("falseLocalOverrideProperties");
 		assertThat(props.get("foo")).as("Incorrect property value").isEqualTo("bar");
 		assertThat(props.get("foo2")).as("Incorrect property value").isEqualTo("local2");
 	}
 
 	@Test
-	public void testLocalOverrideTrue() {
+	void testLocalOverrideTrue() {
 		Properties props = (Properties) this.beanFactory.getBean("trueLocalOverrideProperties");
 		assertThat(props.get("foo")).as("Incorrect property value").isEqualTo("local");
 		assertThat(props.get("foo2")).as("Incorrect property value").isEqualTo("local2");

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

@@ -356,12 +356,12 @@ public class XmlBeanCollectionTests {
 	@Test
 	public void testProps() throws Exception {
 		HasMap hasMap = (HasMap) this.beanFactory.getBean("props");
-		assertThat(hasMap.getProps().size()).isEqualTo(2);
+		assertThat(hasMap.getProps()).hasSize(2);
 		assertThat(hasMap.getProps().getProperty("foo")).isEqualTo("bar");
 		assertThat(hasMap.getProps().getProperty("2")).isEqualTo("TWO");
 
 		HasMap hasMap2 = (HasMap) this.beanFactory.getBean("propsViaMap");
-		assertThat(hasMap2.getProps().size()).isEqualTo(2);
+		assertThat(hasMap2.getProps()).hasSize(2);
 		assertThat(hasMap2.getProps().getProperty("foo")).isEqualTo("bar");
 		assertThat(hasMap2.getProps().getProperty("2")).isEqualTo("TWO");
 	}
@@ -432,7 +432,7 @@ public class XmlBeanCollectionTests {
 		boolean condition = sam.getObject() instanceof Map;
 		assertThat(condition).as("Didn't choose constructor with Map argument").isTrue();
 		Map map = (Map) sam.getObject();
-		assertThat(map.size()).isEqualTo(3);
+		assertThat(map).hasSize(3);
 		assertThat(map.get("key1")).isEqualTo("val1");
 		assertThat(map.get("key2")).isEqualTo("val2");
 		assertThat(map.get("key3")).isEqualTo("val3");

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

@@ -138,7 +138,7 @@ public class XmlListableBeanFactoryTests extends AbstractListableBeanFactoryTest
 		TestBean alias1 = (TestBean) getBeanFactory().getBean("myalias");
 		assertThat(tb1 == alias1).isTrue();
 		List tb1Aliases = Arrays.asList(getBeanFactory().getAliases("aliased"));
-		assertThat(tb1Aliases.size()).isEqualTo(2);
+		assertThat(tb1Aliases).hasSize(2);
 		assertThat(tb1Aliases.contains("myalias")).isTrue();
 		assertThat(tb1Aliases.contains("youralias")).isTrue();
 		assertThat(beanNames.contains("aliased")).isTrue();
@@ -156,7 +156,7 @@ public class XmlListableBeanFactoryTests extends AbstractListableBeanFactoryTest
 		assertThat(tb2 == alias3b).isTrue();
 
 		List tb2Aliases = Arrays.asList(getBeanFactory().getAliases("multiAliased"));
-		assertThat(tb2Aliases.size()).isEqualTo(4);
+		assertThat(tb2Aliases).hasSize(4);
 		assertThat(tb2Aliases.contains("alias1")).isTrue();
 		assertThat(tb2Aliases.contains("alias2")).isTrue();
 		assertThat(tb2Aliases.contains("alias3")).isTrue();
@@ -173,7 +173,7 @@ public class XmlListableBeanFactoryTests extends AbstractListableBeanFactoryTest
 		assertThat(tb3 == alias4).isTrue();
 		assertThat(tb3 == alias5).isTrue();
 		List tb3Aliases = Arrays.asList(getBeanFactory().getAliases("aliasWithoutId1"));
-		assertThat(tb3Aliases.size()).isEqualTo(2);
+		assertThat(tb3Aliases).hasSize(2);
 		assertThat(tb3Aliases.contains("aliasWithoutId2")).isTrue();
 		assertThat(tb3Aliases.contains("aliasWithoutId3")).isTrue();
 		assertThat(beanNames.contains("aliasWithoutId1")).isTrue();
@@ -184,7 +184,7 @@ public class XmlListableBeanFactoryTests extends AbstractListableBeanFactoryTest
 		assertThat(tb4.getName()).isNull();
 
 		Map drs = getListableBeanFactory().getBeansOfType(DummyReferencer.class, false, false);
-		assertThat(drs.size()).isEqualTo(5);
+		assertThat(drs).hasSize(5);
 		assertThat(drs.containsKey(DummyReferencer.class.getName() + "#0")).isTrue();
 		assertThat(drs.containsKey(DummyReferencer.class.getName() + "#1")).isTrue();
 		assertThat(drs.containsKey(DummyReferencer.class.getName() + "#2")).isTrue();

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

@@ -1357,12 +1357,12 @@ class CustomEditorTests {
 		bw.registerCustomEditor(Hashtable.class, new CustomMapEditor(Hashtable.class));
 
 		bw.setPropertyValue("vector", new String[] {"a", "b"});
-		assertThat(tb.getVector().size()).isEqualTo(2);
+		assertThat(tb.getVector()).hasSize(2);
 		assertThat(tb.getVector().get(0)).isEqualTo("a");
 		assertThat(tb.getVector().get(1)).isEqualTo("b");
 
 		bw.setPropertyValue("hashtable", Collections.singletonMap("foo", "bar"));
-		assertThat(tb.getHashtable().size()).isEqualTo(1);
+		assertThat(tb.getHashtable()).hasSize(1);
 		assertThat(tb.getHashtable().get("foo")).isEqualTo("bar");
 	}
 

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

@@ -139,7 +139,7 @@ public class PropertiesEditorTests {
 		PropertiesEditor pe= new PropertiesEditor();
 		pe.setAsText(null);
 		Properties p = (Properties) pe.getValue();
-		assertThat(p.size()).isEqualTo(0);
+		assertThat(p).hasSize(0);
 	}
 
 	@Test
@@ -163,7 +163,7 @@ public class PropertiesEditorTests {
 		boolean condition = value instanceof Properties;
 		assertThat(condition).isTrue();
 		Properties props = (Properties) value;
-		assertThat(props.size()).isEqualTo(3);
+		assertThat(props).hasSize(3);
 		assertThat(props.getProperty("one")).isEqualTo("1");
 		assertThat(props.getProperty("two")).isEqualTo("2");
 		assertThat(props.getProperty("three")).isEqualTo("3");

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

@@ -46,7 +46,7 @@ public class CacheResolverAdapterTests extends AbstractJCacheTests {
 		CacheResolverAdapter adapter = new CacheResolverAdapter(getCacheResolver(dummyContext, "testCache"));
 		Collection<? extends Cache> caches = adapter.resolveCaches(dummyContext);
 		assertThat(caches).isNotNull();
-		assertThat(caches.size()).isEqualTo(1);
+		assertThat(caches).hasSize(1);
 		assertThat(caches.iterator().next().getName()).isEqualTo("testCache");
 	}
 

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

@@ -107,11 +107,11 @@ public class CacheResultOperationTests extends AbstractCacheOperationTests<Cache
 		CacheInvocationParameter[] parameters = operation.getAllParameters(2L, "foo");
 
 		Set<Annotation> firstParameterAnnotations = parameters[0].getAnnotations();
-		assertThat(firstParameterAnnotations.size()).isEqualTo(1);
+		assertThat(firstParameterAnnotations).hasSize(1);
 		assertThat(firstParameterAnnotations.iterator().next().annotationType()).isEqualTo(CacheKey.class);
 
 		Set<Annotation> secondParameterAnnotations = parameters[1].getAnnotations();
-		assertThat(secondParameterAnnotations.size()).isEqualTo(1);
+		assertThat(secondParameterAnnotations).hasSize(1);
 		assertThat(secondParameterAnnotations.iterator().next().annotationType()).isEqualTo(Value.class);
 	}
 

spring-context-support/src/test/java/org/springframework/mail/javamail/JavaMailSenderTests.java

@@ -79,22 +79,22 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
 
-		assertThat(sender.transport.getSentMessages().size()).isEqualTo(1);
+		assertThat(sender.transport.getSentMessages()).hasSize(1);
 		MimeMessage sentMessage = sender.transport.getSentMessage(0);
 		List<Address> froms = Arrays.asList(sentMessage.getFrom());
-		assertThat(froms.size()).isEqualTo(1);
+		assertThat(froms).hasSize(1);
 		assertThat(((InternetAddress) froms.get(0)).getAddress()).isEqualTo("me@mail.org");
 		List<Address> replyTos = Arrays.asList(sentMessage.getReplyTo());
 		assertThat(((InternetAddress) replyTos.get(0)).getAddress()).isEqualTo("reply@mail.org");
 		List<Address> tos = Arrays.asList(sentMessage.getRecipients(Message.RecipientType.TO));
-		assertThat(tos.size()).isEqualTo(1);
+		assertThat(tos).hasSize(1);
 		assertThat(((InternetAddress) tos.get(0)).getAddress()).isEqualTo("you@mail.org");
 		List<Address> ccs = Arrays.asList(sentMessage.getRecipients(Message.RecipientType.CC));
-		assertThat(ccs.size()).isEqualTo(2);
+		assertThat(ccs).hasSize(2);
 		assertThat(((InternetAddress) ccs.get(0)).getAddress()).isEqualTo("he@mail.org");
 		assertThat(((InternetAddress) ccs.get(1)).getAddress()).isEqualTo("she@mail.org");
 		List<Address> bccs = Arrays.asList(sentMessage.getRecipients(Message.RecipientType.BCC));
-		assertThat(bccs.size()).isEqualTo(2);
+		assertThat(bccs).hasSize(2);
 		assertThat(((InternetAddress) bccs.get(0)).getAddress()).isEqualTo("us@mail.org");
 		assertThat(((InternetAddress) bccs.get(1)).getAddress()).isEqualTo("them@mail.org");
 		assertThat(sentMessage.getSentDate().getTime()).isEqualTo(sentDate.getTime());
@@ -120,14 +120,14 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
 
-		assertThat(sender.transport.getSentMessages().size()).isEqualTo(2);
+		assertThat(sender.transport.getSentMessages()).hasSize(2);
 		MimeMessage sentMessage1 = sender.transport.getSentMessage(0);
 		List<Address> tos1 = Arrays.asList(sentMessage1.getRecipients(Message.RecipientType.TO));
-		assertThat(tos1.size()).isEqualTo(1);
+		assertThat(tos1).hasSize(1);
 		assertThat(((InternetAddress) tos1.get(0)).getAddress()).isEqualTo("he@mail.org");
 		MimeMessage sentMessage2 = sender.transport.getSentMessage(1);
 		List<Address> tos2 = Arrays.asList(sentMessage2.getRecipients(Message.RecipientType.TO));
-		assertThat(tos2.size()).isEqualTo(1);
+		assertThat(tos2).hasSize(1);
 		assertThat(((InternetAddress) tos2.get(0)).getAddress()).isEqualTo("she@mail.org");
 	}
 
@@ -146,7 +146,7 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages().size()).isEqualTo(1);
+		assertThat(sender.transport.getSentMessages()).hasSize(1);
 		assertThat(sender.transport.getSentMessage(0)).isEqualTo(mimeMessage);
 	}
 
@@ -167,7 +167,7 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages().size()).isEqualTo(2);
+		assertThat(sender.transport.getSentMessages()).hasSize(2);
 		assertThat(sender.transport.getSentMessage(0)).isEqualTo(mimeMessage1);
 		assertThat(sender.transport.getSentMessage(1)).isEqualTo(mimeMessage2);
 	}
@@ -191,7 +191,7 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages().size()).isEqualTo(1);
+		assertThat(sender.transport.getSentMessages()).hasSize(1);
 		assertThat(sender.transport.getSentMessage(0)).isEqualTo(messages.get(0));
 	}
 
@@ -218,7 +218,7 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages().size()).isEqualTo(2);
+		assertThat(sender.transport.getSentMessages()).hasSize(2);
 		assertThat(sender.transport.getSentMessage(0)).isEqualTo(messages.get(0));
 		assertThat(sender.transport.getSentMessage(1)).isEqualTo(messages.get(1));
 	}
@@ -242,7 +242,7 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages().size()).isEqualTo(1);
+		assertThat(sender.transport.getSentMessages()).hasSize(1);
 		assertThat(sender.transport.getSentMessage(0)).isEqualTo(message.getMimeMessage());
 	}
 
@@ -266,7 +266,7 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages().size()).isEqualTo(1);
+		assertThat(sender.transport.getSentMessages()).hasSize(1);
 		assertThat(sender.transport.getSentMessage(0)).isEqualTo(message.getMimeMessage());
 	}
 
@@ -291,7 +291,7 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages().size()).isEqualTo(1);
+		assertThat(sender.transport.getSentMessages()).hasSize(1);
 		assertThat(sender.transport.getSentMessage(0)).isEqualTo(message.getMimeMessage());
 	}
 
@@ -349,7 +349,7 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages().size()).isEqualTo(1);
+		assertThat(sender.transport.getSentMessages()).hasSize(1);
 		assertThat(sender.transport.getSentMessage(0)).isEqualTo(mimeMessage);
 	}
 
@@ -377,7 +377,7 @@ public class JavaMailSenderTests {
 		assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 		assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 		assertThat(sender.transport.isCloseCalled()).isTrue();
-		assertThat(sender.transport.getSentMessages().size()).isEqualTo(1);
+		assertThat(sender.transport.getSentMessages()).hasSize(1);
 		assertThat(sender.transport.getSentMessage(0)).isEqualTo(mimeMessage);
 	}
 
@@ -427,9 +427,9 @@ public class JavaMailSenderTests {
 			assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 			assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 			assertThat(sender.transport.isCloseCalled()).isTrue();
-			assertThat(sender.transport.getSentMessages().size()).isEqualTo(1);
+			assertThat(sender.transport.getSentMessages()).hasSize(1);
 			assertThat(sender.transport.getSentMessage(0).getAllRecipients()[0]).isEqualTo(new InternetAddress("she@mail.org"));
-			assertThat(ex.getFailedMessages().size()).isEqualTo(1);
+			assertThat(ex.getFailedMessages()).hasSize(1);
 			assertThat(ex.getFailedMessages().keySet().iterator().next()).isEqualTo(simpleMessage1);
 			Object subEx = ex.getFailedMessages().values().iterator().next();
 			boolean condition = subEx instanceof MessagingException;
@@ -460,9 +460,9 @@ public class JavaMailSenderTests {
 			assertThat(sender.transport.getConnectedUsername()).isEqualTo("username");
 			assertThat(sender.transport.getConnectedPassword()).isEqualTo("password");
 			assertThat(sender.transport.isCloseCalled()).isTrue();
-			assertThat(sender.transport.getSentMessages().size()).isEqualTo(1);
+			assertThat(sender.transport.getSentMessages()).hasSize(1);
 			assertThat(sender.transport.getSentMessage(0)).isEqualTo(mimeMessage2);
-			assertThat(ex.getFailedMessages().size()).isEqualTo(1);
+			assertThat(ex.getFailedMessages()).hasSize(1);
 			assertThat(ex.getFailedMessages().keySet().iterator().next()).isEqualTo(mimeMessage1);
 			Object subEx = ex.getFailedMessages().values().iterator().next();
 			boolean condition = subEx instanceof MessagingException;

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

@@ -1085,7 +1085,7 @@ public abstract class AbstractAopProxyTests {
 		it.setName(name2);
 		// NameReverter saved it back
 		assertThat(it.getName()).isEqualTo(name1);
-		assertThat(saver.names.size()).isEqualTo(2);
+		assertThat(saver.names).hasSize(2);
 		assertThat(saver.names.get(0)).isEqualTo(name2);
 		assertThat(saver.names.get(1)).isEqualTo(name1);
 	}

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

@@ -203,7 +203,7 @@ class XmlBeanFactoryTests {
 		assertThat(inner5.getBeanName()).isEqualTo("innerBean#2");
 
 		assertThat(hasInnerBeans.getSomeMap()).isNotNull();
-		assertThat(hasInnerBeans.getSomeMap().size()).isEqualTo(2);
+		assertThat(hasInnerBeans.getSomeMap()).hasSize(2);
 		TestBean inner3 = (TestBean) hasInnerBeans.getSomeMap().get("someKey");
 		assertThat(inner3.getName()).isEqualTo("Jenny");
 		assertThat(inner3.getAge()).isEqualTo(30);
@@ -410,7 +410,7 @@ class XmlBeanFactoryTests {
 
 		// abstract beans should not match
 		Map<?, ?> tbs = parent.getBeansOfType(TestBean.class);
-		assertThat(tbs.size()).isEqualTo(2);
+		assertThat(tbs).hasSize(2);
 		assertThat(tbs.containsKey("inheritedTestBeanPrototype")).isTrue();
 		assertThat(tbs.containsKey("inheritedTestBeanSingleton")).isTrue();
 
@@ -427,13 +427,13 @@ class XmlBeanFactoryTests {
 		DefaultListableBeanFactory xbf = new DefaultListableBeanFactory();
 		new XmlBeanDefinitionReader(xbf).loadBeanDefinitions(DEP_MATERIALIZE_CONTEXT);
 
-		assertThat(xbf.getBeansOfType(DummyBo.class, true, false).size()).isEqualTo(2);
-		assertThat(xbf.getBeansOfType(DummyBo.class, true, true).size()).isEqualTo(3);
-		assertThat(xbf.getBeansOfType(DummyBo.class, true, false).size()).isEqualTo(3);
-		assertThat(xbf.getBeansOfType(DummyBo.class).size()).isEqualTo(3);
-		assertThat(xbf.getBeansOfType(DummyBoImpl.class, true, true).size()).isEqualTo(2);
-		assertThat(xbf.getBeansOfType(DummyBoImpl.class, false, true).size()).isEqualTo(1);
-		assertThat(xbf.getBeansOfType(DummyBoImpl.class).size()).isEqualTo(2);
+		assertThat(xbf.getBeansOfType(DummyBo.class, true, false)).hasSize(2);
+		assertThat(xbf.getBeansOfType(DummyBo.class, true, true)).hasSize(3);
+		assertThat(xbf.getBeansOfType(DummyBo.class, true, false)).hasSize(3);
+		assertThat(xbf.getBeansOfType(DummyBo.class)).hasSize(3);
+		assertThat(xbf.getBeansOfType(DummyBoImpl.class, true, true)).hasSize(2);
+		assertThat(xbf.getBeansOfType(DummyBoImpl.class, false, true)).hasSize(1);
+		assertThat(xbf.getBeansOfType(DummyBoImpl.class)).hasSize(2);
 
 		DummyBoImpl bos = (DummyBoImpl) xbf.getBean("boSingleton");
 		DummyBoImpl bop = (DummyBoImpl) xbf.getBean("boPrototype");
@@ -1389,12 +1389,12 @@ class XmlBeanFactoryTests {
 		reader.loadBeanDefinitions(OVERRIDES_CONTEXT);
 
 		TestBean jenny1 = (TestBean) xbf.getBean("jennyChild");
-		assertThat(jenny1.getFriends().size()).isEqualTo(1);
+		assertThat(jenny1.getFriends()).hasSize(1);
 		Object friend1 = jenny1.getFriends().iterator().next();
 		assertThat(friend1 instanceof TestBean).isTrue();
 
 		TestBean jenny2 = (TestBean) xbf.getBean("jennyChild");
-		assertThat(jenny2.getFriends().size()).isEqualTo(1);
+		assertThat(jenny2.getFriends()).hasSize(1);
 		Object friend2 = jenny2.getFriends().iterator().next();
 		assertThat(friend2 instanceof TestBean).isTrue();
 

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

@@ -151,21 +151,21 @@ public class CustomNamespaceHandlerTests {
 	public void testCustomElementNestedWithinUtilList() throws Exception {
 		List<?> things = (List<?>) this.beanFactory.getBean("list.of.things");
 		assertThat(things).isNotNull();
-		assertThat(things.size()).isEqualTo(2);
+		assertThat(things).hasSize(2);
 	}
 
 	@Test  // SPR-2728
 	public void testCustomElementNestedWithinUtilSet() throws Exception {
 		Set<?> things = (Set<?>) this.beanFactory.getBean("set.of.things");
 		assertThat(things).isNotNull();
-		assertThat(things.size()).isEqualTo(2);
+		assertThat(things).hasSize(2);
 	}
 
 	@Test  // SPR-2728
 	public void testCustomElementNestedWithinUtilMap() throws Exception {
 		Map<?, ?> things = (Map<?, ?>) this.beanFactory.getBean("map.of.things");
 		assertThat(things).isNotNull();
-		assertThat(things.size()).isEqualTo(2);
+		assertThat(things).hasSize(2);
 	}
 
 

spring-context/src/test/java/org/springframework/cache/concurrent/ConcurrentMapCacheTests.java

@@ -88,7 +88,7 @@ public class ConcurrentMapCacheTests extends AbstractValueAdaptingCacheTests<Con
 		serializeCache.put(key, content);
 		content.remove(0);
 		List<String> entry = (List<String>) serializeCache.get(key).get();
-		assertThat(entry.size()).isEqualTo(3);
+		assertThat(entry).hasSize(3);
 		assertThat(entry.get(0)).isEqualTo("one");
 	}
 

spring-context/src/test/java/org/springframework/cache/interceptor/ExpressionEvaluatorTests.java

@@ -61,7 +61,7 @@ public class ExpressionEvaluatorTests {
 	@Test
 	public void testMultipleCachingSource() {
 		Collection<CacheOperation> ops = getOps("multipleCaching");
-		assertThat(ops.size()).isEqualTo(2);
+		assertThat(ops).hasSize(2);
 		Iterator<CacheOperation> it = ops.iterator();
 		CacheOperation next = it.next();
 		assertThat(next instanceof CacheableOperation).isTrue();

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

@@ -465,7 +465,7 @@ public class ClassPathBeanDefinitionScannerTests {
 		assertThat(fooService.foo(123)).isEqualTo("bar");
 		assertThat(fooService.lookupFoo(123)).isEqualTo("bar");
 		assertThat(fooService.beanFactory).isSameAs(context.getDefaultListableBeanFactory());
-		assertThat(fooService.listableBeanFactory.size()).isEqualTo(2);
+		assertThat(fooService.listableBeanFactory).hasSize(2);
 		assertThat(fooService.listableBeanFactory.get(0)).isSameAs(context.getDefaultListableBeanFactory());
 		assertThat(fooService.listableBeanFactory.get(1)).isSameAs(myBf);
 		assertThat(fooService.resourceLoader).isSameAs(context);

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

@@ -98,7 +98,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 		assertThat(containsBeanClass(candidates, NamedStubDao.class)).isTrue();
 		assertThat(containsBeanClass(candidates, ServiceInvocationCounter.class)).isTrue();
 		assertThat(containsBeanClass(candidates, BarComponent.class)).isTrue();
-		assertThat(candidates.size()).isEqualTo(7);
+		assertThat(candidates).hasSize(7);
 		assertBeanDefinitionType(candidates);
 	}
 
@@ -120,7 +120,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 	private void testAntStyle(ClassPathScanningCandidateComponentProvider provider) {
 		Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_BASE_PACKAGE + ".**.sub");
 		assertThat(containsBeanClass(candidates, BarComponent.class)).isTrue();
-		assertThat(candidates.size()).isEqualTo(1);
+		assertThat(candidates).hasSize(1);
 		assertBeanDefinitionType(candidates);
 	}
 
@@ -130,7 +130,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 		provider.setResourceLoader(new DefaultResourceLoader(
 				CandidateComponentsTestClassLoader.disableIndex(getClass().getClassLoader())));
 		Set<BeanDefinition> candidates = provider.findCandidateComponents("bogus");
-		assertThat(candidates.size()).isEqualTo(0);
+		assertThat(candidates).hasSize(0);
 	}
 
 	@Test
@@ -138,7 +138,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 		ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(true);
 		provider.setResourceLoader(new DefaultResourceLoader(TEST_BASE_CLASSLOADER));
 		Set<BeanDefinition> candidates = provider.findCandidateComponents("bogus");
-		assertThat(candidates.size()).isEqualTo(0);
+		assertThat(candidates).hasSize(0);
 	}
 
 	@Test
@@ -193,7 +193,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 		assertThat(containsBeanClass(candidates, AutowiredQualifierFooService.class)).isTrue();
 		assertThat(containsBeanClass(candidates, FooServiceImpl.class)).isTrue();
 		assertThat(containsBeanClass(candidates, ScopedProxyTestBean.class)).isTrue();
-		assertThat(candidates.size()).isEqualTo(3);
+		assertThat(candidates).hasSize(3);
 		assertBeanDefinitionType(candidates);
 	}
 
@@ -220,7 +220,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 		assertThat(containsBeanClass(candidates, NamedComponent.class)).isTrue();
 		assertThat(containsBeanClass(candidates, ServiceInvocationCounter.class)).isTrue();
 		assertThat(containsBeanClass(candidates, BarComponent.class)).isTrue();
-		assertThat(candidates.size()).isEqualTo(3);
+		assertThat(candidates).hasSize(3);
 		assertBeanDefinitionType(candidates);
 	}
 
@@ -233,7 +233,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 		provider.addIncludeFilter(new AnnotationTypeFilter(CustomStereotype.class));
 		Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_BASE_PACKAGE);
 		assertThat(containsBeanClass(candidates, DefaultNamedComponent.class)).isTrue();
-		assertThat(candidates.size()).isEqualTo(1);
+		assertThat(candidates).hasSize(1);
 		assertBeanDefinitionType(candidates);
 	}
 
@@ -244,7 +244,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 		provider.addIncludeFilter(new AssignableTypeFilter(FooDao.class));
 		Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_BASE_PACKAGE);
 		assertThat(containsBeanClass(candidates, StubFooDao.class)).isTrue();
-		assertThat(candidates.size()).isEqualTo(1);
+		assertThat(candidates).hasSize(1);
 		assertBeanDefinitionType(candidates);
 	}
 
@@ -271,7 +271,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 		assertThat(containsBeanClass(candidates, StubFooDao.class)).isTrue();
 		assertThat(containsBeanClass(candidates, ServiceInvocationCounter.class)).isTrue();
 		assertThat(containsBeanClass(candidates, BarComponent.class)).isTrue();
-		assertThat(candidates.size()).isEqualTo(4);
+		assertThat(candidates).hasSize(4);
 		assertBeanDefinitionType(candidates);
 	}
 
@@ -279,7 +279,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 	void withNoFilters() {
 		ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
 		Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_BASE_PACKAGE);
-		assertThat(candidates.size()).isEqualTo(0);
+		assertThat(candidates).hasSize(0);
 	}
 
 	@Test
@@ -290,7 +290,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 		provider.addExcludeFilter(new AnnotationTypeFilter(Service.class));
 		provider.addExcludeFilter(new AnnotationTypeFilter(Controller.class));
 		Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_BASE_PACKAGE);
-		assertThat(candidates.size()).isEqualTo(3);
+		assertThat(candidates).hasSize(3);
 		assertThat(containsBeanClass(candidates, NamedComponent.class)).isTrue();
 		assertThat(containsBeanClass(candidates, ServiceInvocationCounter.class)).isTrue();
 		assertThat(containsBeanClass(candidates, BarComponent.class)).isTrue();
@@ -304,7 +304,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 		ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
 		provider.addIncludeFilter(new AnnotationTypeFilter(Aspect.class));
 		Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_BASE_PACKAGE);
-		assertThat(candidates.size()).isEqualTo(1);
+		assertThat(candidates).hasSize(1);
 		assertThat(containsBeanClass(candidates, ServiceInvocationCounter.class)).isTrue();
 	}
 
@@ -313,7 +313,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 		ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
 		provider.addIncludeFilter(new AssignableTypeFilter(FooDao.class));
 		Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_BASE_PACKAGE);
-		assertThat(candidates.size()).isEqualTo(1);
+		assertThat(candidates).hasSize(1);
 		assertThat(containsBeanClass(candidates, StubFooDao.class)).isTrue();
 	}
 
@@ -322,7 +322,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 		ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
 		provider.addIncludeFilter(new AssignableTypeFilter(MessageBean.class));
 		Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_BASE_PACKAGE);
-		assertThat(candidates.size()).isEqualTo(1);
+		assertThat(candidates).hasSize(1);
 		assertThat(containsBeanClass(candidates, MessageBean.class)).isTrue();
 	}
 
@@ -332,7 +332,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 		provider.addIncludeFilter(new AnnotationTypeFilter(Component.class));
 		provider.addIncludeFilter(new AssignableTypeFilter(FooServiceImpl.class));
 		Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_BASE_PACKAGE);
-		assertThat(candidates.size()).isEqualTo(7);
+		assertThat(candidates).hasSize(7);
 		assertThat(containsBeanClass(candidates, NamedComponent.class)).isTrue();
 		assertThat(containsBeanClass(candidates, ServiceInvocationCounter.class)).isTrue();
 		assertThat(containsBeanClass(candidates, FooServiceImpl.class)).isTrue();
@@ -346,7 +346,7 @@ class ClassPathScanningCandidateComponentProviderTests {
 		provider.addIncludeFilter(new AssignableTypeFilter(FooServiceImpl.class));
 		provider.addExcludeFilter(new AssignableTypeFilter(FooService.class));
 		Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_BASE_PACKAGE);
-		assertThat(candidates.size()).isEqualTo(6);
+		assertThat(candidates).hasSize(6);
 		assertThat(containsBeanClass(candidates, NamedComponent.class)).isTrue();
 		assertThat(containsBeanClass(candidates, ServiceInvocationCounter.class)).isTrue();
 		assertThat(containsBeanClass(candidates, BarComponent.class)).isTrue();

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

@@ -1049,7 +1049,7 @@ class ConfigurationClassPostProcessorTests {
 		ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(CollectionArgumentConfiguration.class, TestBean.class);
 		CollectionArgumentConfiguration bean = ctx.getBean(CollectionArgumentConfiguration.class);
 		assertThat(bean.testBeans).isNotNull();
-		assertThat(bean.testBeans.size()).isEqualTo(1);
+		assertThat(bean.testBeans).hasSize(1);
 		assertThat(bean.testBeans.get(0)).isSameAs(ctx.getBean(TestBean.class));
 		ctx.close();
 	}
@@ -1068,7 +1068,7 @@ class ConfigurationClassPostProcessorTests {
 		ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(MapArgumentConfiguration.class, DummyRunnable.class);
 		MapArgumentConfiguration bean = ctx.getBean(MapArgumentConfiguration.class);
 		assertThat(bean.testBeans).isNotNull();
-		assertThat(bean.testBeans.size()).isEqualTo(1);
+		assertThat(bean.testBeans).hasSize(1);
 		assertThat(bean.testBeans.values().iterator().next()).isSameAs(ctx.getBean(Runnable.class));
 		ctx.close();
 	}
@@ -1087,7 +1087,7 @@ class ConfigurationClassPostProcessorTests {
 		ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(CollectionInjectionConfiguration.class);
 		CollectionInjectionConfiguration bean = ctx.getBean(CollectionInjectionConfiguration.class);
 		assertThat(bean.testBeans).isNotNull();
-		assertThat(bean.testBeans.size()).isEqualTo(1);
+		assertThat(bean.testBeans).hasSize(1);
 		assertThat(bean.testBeans.get(0)).isSameAs(ctx.getBean(TestBean.class));
 		ctx.close();
 	}
@@ -1097,7 +1097,7 @@ class ConfigurationClassPostProcessorTests {
 		ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(MapInjectionConfiguration.class);
 		MapInjectionConfiguration bean = ctx.getBean(MapInjectionConfiguration.class);
 		assertThat(bean.testBeans).isNotNull();
-		assertThat(bean.testBeans.size()).isEqualTo(1);
+		assertThat(bean.testBeans).hasSize(1);
 		assertThat(bean.testBeans.get("testBean")).isSameAs(ctx.getBean(Runnable.class));
 		ctx.close();
 	}

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

@@ -138,14 +138,14 @@ public class ConfigurationClassWithConditionTests {
 	@Test
 	public void conditionOnOverriddenMethodHonored() {
 		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConfigWithBeanSkipped.class);
-		assertThat(context.getBeansOfType(ExampleBean.class).size()).isEqualTo(0);
+		assertThat(context.getBeansOfType(ExampleBean.class)).hasSize(0);
 	}
 
 	@Test
 	public void noConditionOnOverriddenMethodHonored() {
 		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConfigWithBeanReactivated.class);
 		Map<String, ExampleBean> beans = context.getBeansOfType(ExampleBean.class);
-		assertThat(beans.size()).isEqualTo(1);
+		assertThat(beans).hasSize(1);
 		assertThat(beans.keySet().iterator().next()).isEqualTo("baz");
 	}
 
@@ -153,7 +153,7 @@ public class ConfigurationClassWithConditionTests {
 	public void configWithAlternativeBeans() {
 		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConfigWithAlternativeBeans.class);
 		Map<String, ExampleBean> beans = context.getBeansOfType(ExampleBean.class);
-		assertThat(beans.size()).isEqualTo(1);
+		assertThat(beans).hasSize(1);
 		assertThat(beans.keySet().iterator().next()).isEqualTo("baz");
 	}
 

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

@@ -126,8 +126,8 @@ public class ImportSelectorTests {
 		ordered.verify(beanFactory).registerBeanDefinition(eq("c"), any());
 		ordered.verify(beanFactory).registerBeanDefinition(eq("d"), any());
 		assertThat(TestImportGroup.instancesCount.get()).isEqualTo(1);
-		assertThat(TestImportGroup.imports.size()).isEqualTo(1);
-		assertThat(TestImportGroup.imports.values().iterator().next().size()).isEqualTo(2);
+		assertThat(TestImportGroup.imports).hasSize(1);
+		assertThat(TestImportGroup.imports.values().iterator().next()).hasSize(2);
 	}
 
 	@Test
@@ -141,7 +141,7 @@ public class ImportSelectorTests {
 		ordered.verify(beanFactory).registerBeanDefinition(eq("c"), any());
 		ordered.verify(beanFactory).registerBeanDefinition(eq("d"), any());
 		assertThat(TestImportGroup.instancesCount.get()).isEqualTo(1);
-		assertThat(TestImportGroup.imports.size()).isEqualTo(2);
+		assertThat(TestImportGroup.imports).hasSize(2);
 		Iterator<AnnotationMetadata> iterator = TestImportGroup.imports.keySet().iterator();
 		assertThat(iterator.next().getClassName()).isEqualTo(GroupedConfig2.class.getName());
 		assertThat(iterator.next().getClassName()).isEqualTo(GroupedConfig1.class.getName());
@@ -158,7 +158,7 @@ public class ImportSelectorTests {
 		ordered.verify(beanFactory).registerBeanDefinition(eq("e"), any());
 		ordered.verify(beanFactory).registerBeanDefinition(eq("c"), any());
 		assertThat(TestImportGroup.instancesCount.get()).isEqualTo(2);
-		assertThat(TestImportGroup.imports.size()).isEqualTo(2);
+		assertThat(TestImportGroup.imports).hasSize(2);
 		assertThat(TestImportGroup.allImports())
 			.containsOnlyKeys(ParentConfiguration1.class.getName(), ChildConfiguration1.class.getName());
 		assertThat(TestImportGroup.allImports().get(ParentConfiguration1.class.getName()))
@@ -177,7 +177,7 @@ public class ImportSelectorTests {
 		ordered.verify(beanFactory).registerBeanDefinition(eq("b"), any());
 		ordered.verify(beanFactory).registerBeanDefinition(eq("d"), any());
 		assertThat(TestImportGroup.instancesCount.get()).isEqualTo(2);
-		assertThat(TestImportGroup.allImports().size()).isEqualTo(2);
+		assertThat(TestImportGroup.allImports()).hasSize(2);
 		assertThat(TestImportGroup.allImports())
 			.containsOnlyKeys(ParentConfiguration2.class.getName(), ChildConfiguration2.class.getName());
 		assertThat(TestImportGroup.allImports().get(ParentConfiguration2.class.getName()))

spring-context/src/test/java/org/springframework/context/conversionservice/ConversionServiceContextConfigTests.java

@@ -31,7 +31,7 @@ class ConversionServiceContextConfigTests {
 	void testConfigOk() {
 		try (ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("org/springframework/context/conversionservice/conversionService.xml")) {
 			TestClient client = context.getBean("testClient", TestClient.class);
-			assertThat(client.getBars().size()).isEqualTo(2);
+			assertThat(client.getBars()).hasSize(2);
 			assertThat(client.getBars().get(0).getValue()).isEqualTo("value1");
 			assertThat(client.getBars().get(1).getValue()).isEqualTo("value2");
 			assertThat(client.isBool()).isTrue();

spring-context/src/test/java/org/springframework/context/event/ApplicationContextEventTests.java

@@ -191,7 +191,7 @@ public class ApplicationContextEventTests extends AbstractApplicationEventListen
 
 		smc.multicastEvent(new MyEvent(this));
 		smc.multicastEvent(new MyOtherEvent(this));
-		assertThat(listener1.seenEvents.size()).isEqualTo(2);
+		assertThat(listener1.seenEvents).hasSize(2);
 	}
 
 	@Test
@@ -205,7 +205,7 @@ public class ApplicationContextEventTests extends AbstractApplicationEventListen
 
 		smc.multicastEvent(new MyEvent(this));
 		smc.multicastEvent(new MyOtherEvent(this));
-		assertThat(listener1.seenEvents.size()).isEqualTo(2);
+		assertThat(listener1.seenEvents).hasSize(2);
 	}
 
 	@Test
@@ -222,7 +222,7 @@ public class ApplicationContextEventTests extends AbstractApplicationEventListen
 
 		smc.multicastEvent(new MyEvent(this));
 		smc.multicastEvent(new MyOtherEvent(this));
-		assertThat(listener1.seenEvents.size()).isEqualTo(2);
+		assertThat(listener1.seenEvents).hasSize(2);
 	}
 
 	@Test
@@ -241,7 +241,7 @@ public class ApplicationContextEventTests extends AbstractApplicationEventListen
 
 		smc.multicastEvent(new MyEvent(this));
 		smc.multicastEvent(new MyOtherEvent(this));
-		assertThat(listener1.seenEvents.size()).isEqualTo(2);
+		assertThat(listener1.seenEvents).hasSize(2);
 	}
 
 	@Test
@@ -298,7 +298,7 @@ public class ApplicationContextEventTests extends AbstractApplicationEventListen
 		assertThat(listener1.seenEvents.contains(event4)).isTrue();
 
 		AbstractApplicationEventMulticaster multicaster = context.getBean(AbstractApplicationEventMulticaster.class);
-		assertThat(multicaster.retrieverCache.size()).isEqualTo(2);
+		assertThat(multicaster.retrieverCache).hasSize(2);
 
 		context.close();
 	}
@@ -320,7 +320,7 @@ public class ApplicationContextEventTests extends AbstractApplicationEventListen
 		assertThat(listener.seenPayloads.contains("event4")).isTrue();
 
 		AbstractApplicationEventMulticaster multicaster = context.getBean(AbstractApplicationEventMulticaster.class);
-		assertThat(multicaster.retrieverCache.size()).isEqualTo(2);
+		assertThat(multicaster.retrieverCache).hasSize(2);
 
 		context.close();
 	}
@@ -384,7 +384,7 @@ public class ApplicationContextEventTests extends AbstractApplicationEventListen
 		MyNonSingletonListener.seenEvents.clear();
 
 		AbstractApplicationEventMulticaster multicaster = context.getBean(AbstractApplicationEventMulticaster.class);
-		assertThat(multicaster.retrieverCache.size()).isEqualTo(3);
+		assertThat(multicaster.retrieverCache).hasSize(3);
 
 		context.close();
 	}

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

@@ -195,7 +195,7 @@ public class ClassPathXmlApplicationContextTests {
 	void factoryBeanAndApplicationListener() {
 		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(CONTEXT_WILDCARD);
 		ctx.getBeanFactory().registerSingleton("manualFBAAL", new FactoryBeanAndApplicationListener());
-		assertThat(ctx.getBeansOfType(ApplicationListener.class).size()).isEqualTo(2);
+		assertThat(ctx.getBeansOfType(ApplicationListener.class)).hasSize(2);
 		ctx.close();
 	}
 
@@ -312,16 +312,16 @@ public class ClassPathXmlApplicationContextTests {
 		assertThat(beanNamesForType[0]).isEqualTo("myMessageSource");
 
 		Map<?, StaticMessageSource> beansOfType = ctx.getBeansOfType(StaticMessageSource.class);
-		assertThat(beansOfType.size()).isEqualTo(1);
+		assertThat(beansOfType).hasSize(1);
 		assertThat(beansOfType.values().iterator().next()).isSameAs(myMessageSource);
 		beansOfType = ctx.getBeansOfType(StaticMessageSource.class, true, true);
-		assertThat(beansOfType.size()).isEqualTo(1);
+		assertThat(beansOfType).hasSize(1);
 		assertThat(beansOfType.values().iterator().next()).isSameAs(myMessageSource);
 		beansOfType = BeanFactoryUtils.beansOfTypeIncludingAncestors(ctx, StaticMessageSource.class);
-		assertThat(beansOfType.size()).isEqualTo(1);
+		assertThat(beansOfType).hasSize(1);
 		assertThat(beansOfType.values().iterator().next()).isSameAs(myMessageSource);
 		beansOfType = BeanFactoryUtils.beansOfTypeIncludingAncestors(ctx, StaticMessageSource.class, true, true);
-		assertThat(beansOfType.size()).isEqualTo(1);
+		assertThat(beansOfType).hasSize(1);
 		assertThat(beansOfType.values().iterator().next()).isSameAs(myMessageSource);
 	}
 

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

@@ -74,7 +74,7 @@ class DefaultLifecycleProcessorTests {
 		assertThat(bean.isRunning()).isTrue();
 		context.stop();
 		assertThat(bean.isRunning()).isFalse();
-		assertThat(startedBeans.size()).isEqualTo(1);
+		assertThat(startedBeans).hasSize(1);
 		context.close();
 	}
 
@@ -116,10 +116,10 @@ class DefaultLifecycleProcessorTests {
 		assertThat(bean.isRunning()).isFalse();
 		context.refresh();
 		assertThat(bean.isRunning()).isFalse();
-		assertThat(startedBeans.size()).isEqualTo(0);
+		assertThat(startedBeans).hasSize(0);
 		context.start();
 		assertThat(bean.isRunning()).isTrue();
-		assertThat(startedBeans.size()).isEqualTo(1);
+		assertThat(startedBeans).hasSize(1);
 		context.stop();
 		context.close();
 	}
@@ -143,7 +143,7 @@ class DefaultLifecycleProcessorTests {
 		context.stop();
 		assertThat(bean.isRunning()).isFalse();
 		assertThat(dependency.isRunning()).isFalse();
-		assertThat(startedBeans.size()).isEqualTo(1);
+		assertThat(startedBeans).hasSize(1);
 		context.close();
 	}
 
@@ -173,7 +173,7 @@ class DefaultLifecycleProcessorTests {
 		assertThat(bean3.isRunning()).isTrue();
 		assertThat(beanMax.isRunning()).isTrue();
 		context.stop();
-		assertThat(startedBeans.size()).isEqualTo(5);
+		assertThat(startedBeans).hasSize(5);
 		assertThat(getPhase(startedBeans.get(0))).isEqualTo(Integer.MIN_VALUE);
 		assertThat(getPhase(startedBeans.get(1))).isEqualTo(1);
 		assertThat(getPhase(startedBeans.get(2))).isEqualTo(2);
@@ -203,7 +203,7 @@ class DefaultLifecycleProcessorTests {
 		assertThat(smartBean2.isRunning()).isTrue();
 		assertThat(simpleBean1.isRunning()).isFalse();
 		assertThat(simpleBean2.isRunning()).isFalse();
-		assertThat(startedBeans.size()).isEqualTo(2);
+		assertThat(startedBeans).hasSize(2);
 		assertThat(getPhase(startedBeans.get(0))).isEqualTo(-3);
 		assertThat(getPhase(startedBeans.get(1))).isEqualTo(5);
 		context.start();
@@ -211,7 +211,7 @@ class DefaultLifecycleProcessorTests {
 		assertThat(smartBean2.isRunning()).isTrue();
 		assertThat(simpleBean1.isRunning()).isTrue();
 		assertThat(simpleBean2.isRunning()).isTrue();
-		assertThat(startedBeans.size()).isEqualTo(4);
+		assertThat(startedBeans).hasSize(4);
 		assertThat(getPhase(startedBeans.get(2))).isEqualTo(0);
 		assertThat(getPhase(startedBeans.get(3))).isEqualTo(0);
 		context.close();
@@ -238,7 +238,7 @@ class DefaultLifecycleProcessorTests {
 		assertThat(smartBean2.isRunning()).isTrue();
 		assertThat(simpleBean1.isRunning()).isFalse();
 		assertThat(simpleBean2.isRunning()).isFalse();
-		assertThat(startedBeans.size()).isEqualTo(2);
+		assertThat(startedBeans).hasSize(2);
 		assertThat(getPhase(startedBeans.get(0))).isEqualTo(-3);
 		assertThat(getPhase(startedBeans.get(1))).isEqualTo(5);
 		context.stop();
@@ -251,7 +251,7 @@ class DefaultLifecycleProcessorTests {
 		assertThat(smartBean2.isRunning()).isTrue();
 		assertThat(simpleBean1.isRunning()).isTrue();
 		assertThat(simpleBean2.isRunning()).isTrue();
-		assertThat(startedBeans.size()).isEqualTo(6);
+		assertThat(startedBeans).hasSize(6);
 		assertThat(getPhase(startedBeans.get(2))).isEqualTo(-3);
 		assertThat(getPhase(startedBeans.get(3))).isEqualTo(0);
 		assertThat(getPhase(startedBeans.get(4))).isEqualTo(0);
@@ -300,7 +300,7 @@ class DefaultLifecycleProcessorTests {
 		context.refresh();
 		assertThat(bean.isRunning()).isTrue();
 		context.stop();
-		assertThat(stoppedBeans.size()).isEqualTo(1);
+		assertThat(stoppedBeans).hasSize(1);
 		assertThat(bean.isRunning()).isFalse();
 		assertThat(stoppedBeans.get(0)).isEqualTo(bean);
 		context.close();
@@ -317,7 +317,7 @@ class DefaultLifecycleProcessorTests {
 		bean.start();
 		assertThat(bean.isRunning()).isTrue();
 		context.stop();
-		assertThat(stoppedBeans.size()).isEqualTo(1);
+		assertThat(stoppedBeans).hasSize(1);
 		assertThat(bean.isRunning()).isFalse();
 		assertThat(stoppedBeans.get(0)).isEqualTo(bean);
 		context.close();
@@ -361,7 +361,7 @@ class DefaultLifecycleProcessorTests {
 		assertThat(bean5.isRunning()).isFalse();
 		assertThat(bean6.isRunning()).isFalse();
 		assertThat(bean7.isRunning()).isFalse();
-		assertThat(stoppedBeans.size()).isEqualTo(7);
+		assertThat(stoppedBeans).hasSize(7);
 		assertThat(getPhase(stoppedBeans.get(0))).isEqualTo(Integer.MAX_VALUE);
 		assertThat(getPhase(stoppedBeans.get(1))).isEqualTo(500);
 		assertThat(getPhase(stoppedBeans.get(2))).isEqualTo(1);
@@ -390,7 +390,7 @@ class DefaultLifecycleProcessorTests {
 		assertThat(bean2.isRunning()).isTrue();
 		assertThat(bean99.isRunning()).isTrue();
 		assertThat(beanMax.isRunning()).isTrue();
-		assertThat(startedBeans.size()).isEqualTo(4);
+		assertThat(startedBeans).hasSize(4);
 		assertThat(getPhase(startedBeans.get(0))).isEqualTo(Integer.MIN_VALUE);
 		assertThat(getPhase(startedBeans.get(1))).isEqualTo(99);
 		assertThat(startedBeans.get(1)).isEqualTo(bean99);
@@ -433,7 +433,7 @@ class DefaultLifecycleProcessorTests {
 		assertThat(bean7.isRunning()).isFalse();
 		assertThat(bean99.isRunning()).isFalse();
 		assertThat(beanMax.isRunning()).isFalse();
-		assertThat(stoppedBeans.size()).isEqualTo(6);
+		assertThat(stoppedBeans).hasSize(6);
 		assertThat(getPhase(stoppedBeans.get(0))).isEqualTo(Integer.MAX_VALUE);
 		assertThat(getPhase(stoppedBeans.get(1))).isEqualTo(2);
 		assertThat(stoppedBeans.get(1)).isEqualTo(bean2);
@@ -467,7 +467,7 @@ class DefaultLifecycleProcessorTests {
 		assertThat(bean99.isRunning()).isTrue();
 		assertThat(bean7.isRunning()).isTrue();
 		assertThat(simpleBean.isRunning()).isTrue();
-		assertThat(startedBeans.size()).isEqualTo(4);
+		assertThat(startedBeans).hasSize(4);
 		assertThat(getPhase(startedBeans.get(0))).isEqualTo(-99);
 		assertThat(getPhase(startedBeans.get(1))).isEqualTo(7);
 		assertThat(getPhase(startedBeans.get(2))).isEqualTo(0);
@@ -509,7 +509,7 @@ class DefaultLifecycleProcessorTests {
 		assertThat(bean2.isRunning()).isFalse();
 		assertThat(bean7.isRunning()).isFalse();
 		assertThat(simpleBean.isRunning()).isFalse();
-		assertThat(stoppedBeans.size()).isEqualTo(6);
+		assertThat(stoppedBeans).hasSize(6);
 		assertThat(getPhase(stoppedBeans.get(0))).isEqualTo(7);
 		assertThat(getPhase(stoppedBeans.get(1))).isEqualTo(2);
 		assertThat(getPhase(stoppedBeans.get(2))).isEqualTo(1);
@@ -534,7 +534,7 @@ class DefaultLifecycleProcessorTests {
 		assertThat(beanMin.isRunning()).isTrue();
 		assertThat(bean7.isRunning()).isTrue();
 		assertThat(simpleBean.isRunning()).isTrue();
-		assertThat(startedBeans.size()).isEqualTo(3);
+		assertThat(startedBeans).hasSize(3);
 		assertThat(getPhase(startedBeans.get(0))).isEqualTo(0);
 		assertThat(getPhase(startedBeans.get(1))).isEqualTo(Integer.MIN_VALUE);
 		assertThat(getPhase(startedBeans.get(2))).isEqualTo(7);
@@ -572,7 +572,7 @@ class DefaultLifecycleProcessorTests {
 		assertThat(bean2.isRunning()).isFalse();
 		assertThat(bean7.isRunning()).isFalse();
 		assertThat(simpleBean.isRunning()).isFalse();
-		assertThat(stoppedBeans.size()).isEqualTo(5);
+		assertThat(stoppedBeans).hasSize(5);
 		assertThat(getPhase(stoppedBeans.get(0))).isEqualTo(7);
 		assertThat(getPhase(stoppedBeans.get(1))).isEqualTo(0);
 		assertThat(getPhase(stoppedBeans.get(2))).isEqualTo(2);

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

@@ -389,32 +389,32 @@ class ResourceBundleMessageSourceTests {
 		ReloadableResourceBundleMessageSource ms = new ReloadableResourceBundleMessageSource();
 
 		List<String> filenames = ms.calculateFilenamesForLocale("messages", Locale.ENGLISH);
-		assertThat(filenames.size()).isEqualTo(1);
+		assertThat(filenames).hasSize(1);
 		assertThat(filenames.get(0)).isEqualTo("messages_en");
 
 		filenames = ms.calculateFilenamesForLocale("messages", Locale.UK);
-		assertThat(filenames.size()).isEqualTo(2);
+		assertThat(filenames).hasSize(2);
 		assertThat(filenames.get(1)).isEqualTo("messages_en");
 		assertThat(filenames.get(0)).isEqualTo("messages_en_GB");
 
 		filenames = ms.calculateFilenamesForLocale("messages", new Locale("en", "GB", "POSIX"));
-		assertThat(filenames.size()).isEqualTo(3);
+		assertThat(filenames).hasSize(3);
 		assertThat(filenames.get(2)).isEqualTo("messages_en");
 		assertThat(filenames.get(1)).isEqualTo("messages_en_GB");
 		assertThat(filenames.get(0)).isEqualTo("messages_en_GB_POSIX");
 
 		filenames = ms.calculateFilenamesForLocale("messages", new Locale("en", "", "POSIX"));
-		assertThat(filenames.size()).isEqualTo(2);
+		assertThat(filenames).hasSize(2);
 		assertThat(filenames.get(1)).isEqualTo("messages_en");
 		assertThat(filenames.get(0)).isEqualTo("messages_en__POSIX");
 
 		filenames = ms.calculateFilenamesForLocale("messages", new Locale("", "UK", "POSIX"));
-		assertThat(filenames.size()).isEqualTo(2);
+		assertThat(filenames).hasSize(2);
 		assertThat(filenames.get(1)).isEqualTo("messages__UK");
 		assertThat(filenames.get(0)).isEqualTo("messages__UK_POSIX");
 
 		filenames = ms.calculateFilenamesForLocale("messages", new Locale("", "", "POSIX"));
-		assertThat(filenames.size()).isEqualTo(0);
+		assertThat(filenames).hasSize(0);
 	}
 
 	@Test

spring-context/src/test/java/org/springframework/scheduling/annotation/EnableSchedulingTests.java

@@ -63,7 +63,7 @@ public class EnableSchedulingTests {
 	@EnabledForTestGroups(LONG_RUNNING)
 	public void withFixedRateTask() throws InterruptedException {
 		ctx = new AnnotationConfigApplicationContext(FixedRateTaskConfig.class);
-		assertThat(ctx.getBean(ScheduledTaskHolder.class).getScheduledTasks().size()).isEqualTo(2);
+		assertThat(ctx.getBean(ScheduledTaskHolder.class).getScheduledTasks()).hasSize(2);
 
 		Thread.sleep(100);
 		assertThat(ctx.getBean(AtomicInteger.class).get()).isGreaterThanOrEqualTo(10);
@@ -73,7 +73,7 @@ public class EnableSchedulingTests {
 	@EnabledForTestGroups(LONG_RUNNING)
 	public void withSubclass() throws InterruptedException {
 		ctx = new AnnotationConfigApplicationContext(FixedRateTaskConfigSubclass.class);
-		assertThat(ctx.getBean(ScheduledTaskHolder.class).getScheduledTasks().size()).isEqualTo(2);
+		assertThat(ctx.getBean(ScheduledTaskHolder.class).getScheduledTasks()).hasSize(2);
 
 		Thread.sleep(100);
 		assertThat(ctx.getBean(AtomicInteger.class).get()).isGreaterThanOrEqualTo(10);
@@ -83,7 +83,7 @@ public class EnableSchedulingTests {
 	@EnabledForTestGroups(LONG_RUNNING)
 	public void withExplicitScheduler() throws InterruptedException {
 		ctx = new AnnotationConfigApplicationContext(ExplicitSchedulerConfig.class);
-		assertThat(ctx.getBean(ScheduledTaskHolder.class).getScheduledTasks().size()).isEqualTo(1);
+		assertThat(ctx.getBean(ScheduledTaskHolder.class).getScheduledTasks()).hasSize(1);
 
 		Thread.sleep(100);
 		assertThat(ctx.getBean(AtomicInteger.class).get()).isGreaterThanOrEqualTo(10);
@@ -102,7 +102,7 @@ public class EnableSchedulingTests {
 	@EnabledForTestGroups(LONG_RUNNING)
 	public void withExplicitScheduledTaskRegistrar() throws InterruptedException {
 		ctx = new AnnotationConfigApplicationContext(ExplicitScheduledTaskRegistrarConfig.class);
-		assertThat(ctx.getBean(ScheduledTaskHolder.class).getScheduledTasks().size()).isEqualTo(1);
+		assertThat(ctx.getBean(ScheduledTaskHolder.class).getScheduledTasks()).hasSize(1);
 
 		Thread.sleep(100);
 		assertThat(ctx.getBean(AtomicInteger.class).get()).isGreaterThanOrEqualTo(10);

spring-context/src/test/java/org/springframework/scheduling/annotation/ScheduledAnnotationBeanPostProcessorTests.java

@@ -104,7 +104,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -137,7 +137,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -145,7 +145,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		@SuppressWarnings("unchecked")
 		List<IntervalTask> fixedRateTasks = (List<IntervalTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
-		assertThat(fixedRateTasks.size()).isEqualTo(1);
+		assertThat(fixedRateTasks).hasSize(1);
 		IntervalTask task = fixedRateTasks.get(0);
 		ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
 		Object targetObject = runnable.getTarget();
@@ -172,7 +172,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -180,7 +180,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		@SuppressWarnings("unchecked")
 		List<IntervalTask> fixedRateTasks = (List<IntervalTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
-		assertThat(fixedRateTasks.size()).isEqualTo(1);
+		assertThat(fixedRateTasks).hasSize(1);
 		IntervalTask task = fixedRateTasks.get(0);
 		ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
 		Object targetObject = runnable.getTarget();
@@ -237,7 +237,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(2);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(2);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -245,7 +245,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		@SuppressWarnings("unchecked")
 		List<IntervalTask> fixedRateTasks = (List<IntervalTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
-		assertThat(fixedRateTasks.size()).isEqualTo(2);
+		assertThat(fixedRateTasks).hasSize(2);
 		IntervalTask task1 = fixedRateTasks.get(0);
 		ScheduledMethodRunnable runnable1 = (ScheduledMethodRunnable) task1.getRunnable();
 		Object targetObject = runnable1.getTarget();
@@ -273,7 +273,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -281,7 +281,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		@SuppressWarnings("unchecked")
 		List<CronTask> cronTasks = (List<CronTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
-		assertThat(cronTasks.size()).isEqualTo(1);
+		assertThat(cronTasks).hasSize(1);
 		CronTask task = cronTasks.get(0);
 		ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
 		Object targetObject = runnable.getTarget();
@@ -300,7 +300,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -308,7 +308,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		@SuppressWarnings("unchecked")
 		List<CronTask> cronTasks = (List<CronTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
-		assertThat(cronTasks.size()).isEqualTo(1);
+		assertThat(cronTasks).hasSize(1);
 		CronTask task = cronTasks.get(0);
 		ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
 		Object targetObject = runnable.getTarget();
@@ -367,14 +367,14 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
 				new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
 		@SuppressWarnings("unchecked")
 		List<CronTask> cronTasks = (List<CronTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
-		assertThat(cronTasks.size()).isEqualTo(1);
+		assertThat(cronTasks).hasSize(1);
 		CronTask task = cronTasks.get(0);
 		ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
 		Object targetObject = runnable.getTarget();
@@ -393,7 +393,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -401,7 +401,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		@SuppressWarnings("unchecked")
 		List<IntervalTask> fixedRateTasks = (List<IntervalTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
-		assertThat(fixedRateTasks.size()).isEqualTo(1);
+		assertThat(fixedRateTasks).hasSize(1);
 		IntervalTask task = fixedRateTasks.get(0);
 		ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
 		Object targetObject = runnable.getTarget();
@@ -420,7 +420,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -428,7 +428,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		@SuppressWarnings("unchecked")
 		List<IntervalTask> fixedRateTasks = (List<IntervalTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
-		assertThat(fixedRateTasks.size()).isEqualTo(1);
+		assertThat(fixedRateTasks).hasSize(1);
 		IntervalTask task = fixedRateTasks.get(0);
 		ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
 		Object targetObject = runnable.getTarget();
@@ -448,7 +448,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -456,7 +456,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		@SuppressWarnings("unchecked")
 		List<CronTask> cronTasks = (List<CronTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
-		assertThat(cronTasks.size()).isEqualTo(1);
+		assertThat(cronTasks).hasSize(1);
 		CronTask task = cronTasks.get(0);
 		ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
 		Object targetObject = runnable.getTarget();
@@ -481,7 +481,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -489,7 +489,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		@SuppressWarnings("unchecked")
 		List<CronTask> cronTasks = (List<CronTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
-		assertThat(cronTasks.size()).isEqualTo(1);
+		assertThat(cronTasks).hasSize(1);
 		CronTask task = cronTasks.get(0);
 		ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
 		Object targetObject = runnable.getTarget();
@@ -540,7 +540,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -548,7 +548,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		@SuppressWarnings("unchecked")
 		List<IntervalTask> fixedDelayTasks = (List<IntervalTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("fixedDelayTasks");
-		assertThat(fixedDelayTasks.size()).isEqualTo(1);
+		assertThat(fixedDelayTasks).hasSize(1);
 		IntervalTask task = fixedDelayTasks.get(0);
 		ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
 		Object targetObject = runnable.getTarget();
@@ -584,7 +584,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -592,7 +592,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		@SuppressWarnings("unchecked")
 		List<IntervalTask> fixedRateTasks = (List<IntervalTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
-		assertThat(fixedRateTasks.size()).isEqualTo(1);
+		assertThat(fixedRateTasks).hasSize(1);
 		IntervalTask task = fixedRateTasks.get(0);
 		ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
 		Object targetObject = runnable.getTarget();
@@ -618,7 +618,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -626,7 +626,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		@SuppressWarnings("unchecked")
 		List<CronTask> cronTasks = (List<CronTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
-		assertThat(cronTasks.size()).isEqualTo(1);
+		assertThat(cronTasks).hasSize(1);
 		CronTask task = cronTasks.get(0);
 		ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
 		Object targetObject = runnable.getTarget();
@@ -651,7 +651,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -659,7 +659,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		@SuppressWarnings("unchecked")
 		List<CronTask> cronTasks = (List<CronTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
-		assertThat(cronTasks.size()).isEqualTo(1);
+		assertThat(cronTasks).hasSize(1);
 		CronTask task = cronTasks.get(0);
 		ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
 		Object targetObject = runnable.getTarget();
@@ -678,7 +678,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		context.refresh();
 
 		ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.class);
-		assertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
+		assertThat(postProcessor.getScheduledTasks()).hasSize(1);
 
 		Object target = context.getBean("target");
 		ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar)
@@ -686,7 +686,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
 		@SuppressWarnings("unchecked")
 		List<CronTask> cronTasks = (List<CronTask>)
 				new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
-		assertThat(cronTasks.size()).isEqualTo(1);
+		assertThat(cronTasks).hasSize(1);
 		CronTask task = cronTasks.get(0);
 		ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
 		Object targetObject = runnable.getTarget();

spring-context/src/test/java/org/springframework/scripting/groovy/GroovyScriptFactoryTests.java

@@ -463,7 +463,7 @@ public class GroovyScriptFactoryTests {
 	public void testAnonymousScriptDetected() throws Exception {
 		ApplicationContext ctx = new ClassPathXmlApplicationContext("groovy-with-xsd.xml", getClass());
 		Map<?, Messenger> beans = ctx.getBeansOfType(Messenger.class);
-		assertThat(beans.size()).isEqualTo(4);
+		assertThat(beans).hasSize(4);
 		assertThat(ctx.getBean(MyBytecodeProcessor.class).processed.contains(
 				"org.springframework.scripting.groovy.GroovyMessenger2")).isTrue();
 	}

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

@@ -44,7 +44,7 @@ public class ModelMapTests {
 
 	@Test
 	public void testNoArgCtorYieldsEmptyModel() throws Exception {
-		assertThat(new ModelMap().size()).isEqualTo(0);
+		assertThat(new ModelMap()).hasSize(0);
 	}
 
 	/*
@@ -71,7 +71,7 @@ public class ModelMapTests {
 	@Test
 	public void testNamedObjectCtor() throws Exception {
 		ModelMap model = new ModelMap("foo", "bing");
-		assertThat(model.size()).isEqualTo(1);
+		assertThat(model).hasSize(1);
 		String bing = (String) model.get("foo");
 		assertThat(bing).isNotNull();
 		assertThat(bing).isEqualTo("bing");
@@ -80,7 +80,7 @@ public class ModelMapTests {
 	@Test
 	public void testUnnamedCtorScalar() throws Exception {
 		ModelMap model = new ModelMap("foo", "bing");
-		assertThat(model.size()).isEqualTo(1);
+		assertThat(model).hasSize(1);
 		String bing = (String) model.get("foo");
 		assertThat(bing).isNotNull();
 		assertThat(bing).isEqualTo("bing");
@@ -89,7 +89,7 @@ public class ModelMapTests {
 	@Test
 	public void testOneArgCtorWithScalar() throws Exception {
 		ModelMap model = new ModelMap("bing");
-		assertThat(model.size()).isEqualTo(1);
+		assertThat(model).hasSize(1);
 		String string = (String) model.get("string");
 		assertThat(string).isNotNull();
 		assertThat(string).isEqualTo("bing");
@@ -105,7 +105,7 @@ public class ModelMapTests {
 	@Test
 	public void testOneArgCtorWithCollection() throws Exception {
 		ModelMap model = new ModelMap(new String[]{"foo", "boing"});
-		assertThat(model.size()).isEqualTo(1);
+		assertThat(model).hasSize(1);
 		String[] strings = (String[]) model.get("stringList");
 		assertThat(strings).isNotNull();
 		assertThat(strings.length).isEqualTo(2);
@@ -117,7 +117,7 @@ public class ModelMapTests {
 	public void testOneArgCtorWithEmptyCollection() throws Exception {
 		ModelMap model = new ModelMap(new HashSet<>());
 		// must not add if collection is empty...
-		assertThat(model.size()).isEqualTo(0);
+		assertThat(model).hasSize(0);
 	}
 
 	@Test
@@ -131,7 +131,7 @@ public class ModelMapTests {
 	@Test
 	public void testAddObjectWithEmptyArray() throws Exception {
 		ModelMap model = new ModelMap(new int[]{});
-		assertThat(model.size()).isEqualTo(1);
+		assertThat(model).hasSize(1);
 		int[] ints = (int[]) model.get("intList");
 		assertThat(ints).isNotNull();
 		assertThat(ints.length).isEqualTo(0);
@@ -141,14 +141,14 @@ public class ModelMapTests {
 	public void testAddAllObjectsWithNullMap() throws Exception {
 		ModelMap model = new ModelMap();
 		model.addAllAttributes((Map<String, ?>) null);
-		assertThat(model.size()).isEqualTo(0);
+		assertThat(model).hasSize(0);
 	}
 
 	@Test
 	public void testAddAllObjectsWithNullCollection() throws Exception {
 		ModelMap model = new ModelMap();
 		model.addAllAttributes((Collection<Object>) null);
-		assertThat(model.size()).isEqualTo(0);
+		assertThat(model).hasSize(0);
 	}
 
 	@Test
@@ -169,7 +169,7 @@ public class ModelMapTests {
 		map.put("two", "two-value");
 		ModelMap model = new ModelMap();
 		model.addAttribute(map);
-		assertThat(model.size()).isEqualTo(1);
+		assertThat(model).hasSize(1);
 		String key = StringUtils.uncapitalize(ClassUtils.getShortName(map.getClass()));
 		assertThat(model.containsKey(key)).isTrue();
 	}
@@ -179,7 +179,7 @@ public class ModelMapTests {
 		ModelMap model = new ModelMap();
 		model.addAttribute("foo");
 		model.addAttribute("bar");
-		assertThat(model.size()).isEqualTo(1);
+		assertThat(model).hasSize(1);
 		String bar = (String) model.get("string");
 		assertThat(bar).isEqualTo("bar");
 	}
@@ -192,7 +192,7 @@ public class ModelMapTests {
 		beans.add(new TestBean("three"));
 		ModelMap model = new ModelMap();
 		model.addAllAttributes(beans);
-		assertThat(model.size()).isEqualTo(1);
+		assertThat(model).hasSize(1);
 	}
 
 	@Test
@@ -204,7 +204,7 @@ public class ModelMapTests {
 		ModelMap model = new ModelMap();
 		model.put("one", new TestBean("oneOld"));
 		model.mergeAttributes(beans);
-		assertThat(model.size()).isEqualTo(3);
+		assertThat(model).hasSize(3);
 		assertThat(((TestBean) model.get("one")).getName()).isEqualTo("oneOld");
 	}
 

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

@@ -1926,7 +1926,7 @@ class DataBinderTests {
 		List<Object> list = (List<Object>) form.getF().get("list");
 		assertThat(list.get(0)).isEqualTo("firstValue");
 		assertThat(list.get(1)).isEqualTo("secondValue");
-		assertThat(list.size()).isEqualTo(2);
+		assertThat(list).hasSize(2);
 	}
 
 	@Test
@@ -1959,7 +1959,7 @@ class DataBinderTests {
 		pvs.add("integerList[256]", "1");
 
 		binder.bind(pvs);
-		assertThat(tb.getIntegerList().size()).isEqualTo(257);
+		assertThat(tb.getIntegerList()).hasSize(257);
 		assertThat(tb.getIntegerList().get(256)).isEqualTo(Integer.valueOf(1));
 		assertThat(binder.getBindingResult().getFieldValue("integerList[256]")).isEqualTo(1);
 	}

spring-context/src/test/java/org/springframework/validation/beanvalidation/ValidatorFactoryTests.java

@@ -68,7 +68,7 @@ class ValidatorFactoryTests {
 
 		ValidPerson person = new ValidPerson();
 		Set<ConstraintViolation<ValidPerson>> result = validator.validate(person);
-		assertThat(result.size()).isEqualTo(2);
+		assertThat(result).hasSize(2);
 		for (ConstraintViolation<ValidPerson> cv : result) {
 			String path = cv.getPropertyPath().toString();
 			assertThat(path).matches(actual -> "name".equals(actual) || "address.street".equals(actual));
@@ -92,7 +92,7 @@ class ValidatorFactoryTests {
 
 		ValidPerson person = new ValidPerson();
 		Set<ConstraintViolation<ValidPerson>> result = validator.validate(person);
-		assertThat(result.size()).isEqualTo(2);
+		assertThat(result).hasSize(2);
 		for (ConstraintViolation<ValidPerson> cv : result) {
 			String path = cv.getPropertyPath().toString();
 			assertThat(path).matches(actual -> "name".equals(actual) || "address.street".equals(actual));
@@ -117,7 +117,7 @@ class ValidatorFactoryTests {
 		person.setName("Juergen");
 		person.getAddress().setStreet("Juergen's Street");
 		Set<ConstraintViolation<ValidPerson>> result = validator.validate(person);
-		assertThat(result.size()).isEqualTo(1);
+		assertThat(result).hasSize(1);
 		Iterator<ConstraintViolation<ValidPerson>> iterator = result.iterator();
 		ConstraintViolation<?> cv = iterator.next();
 		assertThat(cv.getPropertyPath().toString()).isEqualTo("");
@@ -158,7 +158,7 @@ class ValidatorFactoryTests {
 		FieldError fieldError = result.getFieldError("name");
 		assertThat(fieldError.getField()).isEqualTo("name");
 		List<String> errorCodes = Arrays.asList(fieldError.getCodes());
-		assertThat(errorCodes.size()).isEqualTo(4);
+		assertThat(errorCodes).hasSize(4);
 		assertThat(errorCodes.contains("NotNull.person.name")).isTrue();
 		assertThat(errorCodes.contains("NotNull.name")).isTrue();
 		assertThat(errorCodes.contains("NotNull.java.lang.String")).isTrue();
@@ -166,7 +166,7 @@ class ValidatorFactoryTests {
 		fieldError = result.getFieldError("address.street");
 		assertThat(fieldError.getField()).isEqualTo("address.street");
 		errorCodes = Arrays.asList(fieldError.getCodes());
-		assertThat(errorCodes.size()).isEqualTo(5);
+		assertThat(errorCodes).hasSize(5);
 		assertThat(errorCodes.contains("NotNull.person.address.street")).isTrue();
 		assertThat(errorCodes.contains("NotNull.address.street")).isTrue();
 		assertThat(errorCodes.contains("NotNull.street")).isTrue();
@@ -190,7 +190,7 @@ class ValidatorFactoryTests {
 		assertThat(result.getErrorCount()).isEqualTo(1);
 		ObjectError globalError = result.getGlobalError();
 		List<String> errorCodes = Arrays.asList(globalError.getCodes());
-		assertThat(errorCodes.size()).isEqualTo(2);
+		assertThat(errorCodes).hasSize(2);
 		assertThat(errorCodes.contains("NameAddressValid.person")).isTrue();
 		assertThat(errorCodes.contains("NameAddressValid")).isTrue();
 
@@ -212,7 +212,7 @@ class ValidatorFactoryTests {
 		assertThat(result.getErrorCount()).isEqualTo(1);
 		ObjectError globalError = result.getGlobalError();
 		List<String> errorCodes = Arrays.asList(globalError.getCodes());
-		assertThat(errorCodes.size()).isEqualTo(2);
+		assertThat(errorCodes).hasSize(2);
 		assertThat(errorCodes.contains("NameAddressValid.person")).isTrue();
 		assertThat(errorCodes.contains("NameAddressValid")).isTrue();
 

spring-context/src/testFixtures/java/org/springframework/context/testfixture/cache/AbstractCacheTests.java

@@ -204,7 +204,7 @@ public abstract class AbstractCacheTests<T extends Cache> {
 		}
 		latch.await();
 
-		assertThat(results.size()).isEqualTo(10);
+		assertThat(results).hasSize(10);
 		results.forEach(r -> assertThat(r).isEqualTo(1)); // Only one method got invoked
 	}
 

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

@@ -56,17 +56,17 @@ class ConstantsTests {
 		Constants c = new Constants(A.class);
 
 		Set<?> names = c.getNames("");
-		assertThat(names.size()).isEqualTo(c.getSize());
+		assertThat(names).hasSize(c.getSize());
 		assertThat(names.contains("DOG")).isTrue();
 		assertThat(names.contains("CAT")).isTrue();
 		assertThat(names.contains("S1")).isTrue();
 
 		names = c.getNames("D");
-		assertThat(names.size()).isEqualTo(1);
+		assertThat(names).hasSize(1);
 		assertThat(names.contains("DOG")).isTrue();
 
 		names = c.getNames("d");
-		assertThat(names.size()).isEqualTo(1);
+		assertThat(names).hasSize(1);
 		assertThat(names.contains("DOG")).isTrue();
 	}
 
@@ -75,22 +75,22 @@ class ConstantsTests {
 		Constants c = new Constants(A.class);
 
 		Set<?> values = c.getValues("");
-		assertThat(values.size()).isEqualTo(7);
+		assertThat(values).hasSize(7);
 		assertThat(values.contains(0)).isTrue();
 		assertThat(values.contains(66)).isTrue();
 		assertThat(values.contains("")).isTrue();
 
 		values = c.getValues("D");
-		assertThat(values.size()).isEqualTo(1);
+		assertThat(values).hasSize(1);
 		assertThat(values.contains(0)).isTrue();
 
 		values = c.getValues("prefix");
-		assertThat(values.size()).isEqualTo(2);
+		assertThat(values).hasSize(2);
 		assertThat(values.contains(1)).isTrue();
 		assertThat(values.contains(2)).isTrue();
 
 		values = c.getValuesForProperty("myProperty");
-		assertThat(values.size()).isEqualTo(2);
+		assertThat(values).hasSize(2);
 		assertThat(values.contains(1)).isTrue();
 		assertThat(values.contains(2)).isTrue();
 	}
@@ -103,22 +103,22 @@ class ConstantsTests {
 			Constants c = new Constants(A.class);
 
 			Set<?> values = c.getValues("");
-			assertThat(values.size()).isEqualTo(7);
+			assertThat(values).hasSize(7);
 			assertThat(values.contains(0)).isTrue();
 			assertThat(values.contains(66)).isTrue();
 			assertThat(values.contains("")).isTrue();
 
 			values = c.getValues("D");
-			assertThat(values.size()).isEqualTo(1);
+			assertThat(values).hasSize(1);
 			assertThat(values.contains(0)).isTrue();
 
 			values = c.getValues("prefix");
-			assertThat(values.size()).isEqualTo(2);
+			assertThat(values).hasSize(2);
 			assertThat(values.contains(1)).isTrue();
 			assertThat(values.contains(2)).isTrue();
 
 			values = c.getValuesForProperty("myProperty");
-			assertThat(values.size()).isEqualTo(2);
+			assertThat(values).hasSize(2);
 			assertThat(values.contains(1)).isTrue();
 			assertThat(values.contains(2)).isTrue();
 		}
@@ -132,12 +132,12 @@ class ConstantsTests {
 		Constants c = new Constants(A.class);
 
 		Set<?> names = c.getNamesForSuffix("_PROPERTY");
-		assertThat(names.size()).isEqualTo(2);
+		assertThat(names).hasSize(2);
 		assertThat(names.contains("NO_PROPERTY")).isTrue();
 		assertThat(names.contains("YES_PROPERTY")).isTrue();
 
 		Set<?> values = c.getValuesForSuffix("_PROPERTY");
-		assertThat(values.size()).isEqualTo(2);
+		assertThat(values).hasSize(2);
 		assertThat(values.contains(3)).isTrue();
 		assertThat(values.contains(4)).isTrue();
 	}
@@ -217,7 +217,7 @@ class ConstantsTests {
 		assertThat(c.getSize()).isEqualTo(0);
 		final Set<?> values = c.getValues("");
 		assertThat(values).isNotNull();
-		assertThat(values.size()).isEqualTo(0);
+		assertThat(values).hasSize(0);
 	}
 
 	@Test

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

@@ -121,7 +121,7 @@ class GenericTypeResolverTests {
 		assertThat(map.toString()).isEqualTo("{T=class java.lang.Integer}");
 
 		map = GenericTypeResolver.getTypeVariableMap(TypedTopLevelClass.TypedNested.class);
-		assertThat(map.size()).isEqualTo(2);
+		assertThat(map).hasSize(2);
 		Type t = null;
 		Type x = null;
 		for (Map.Entry<TypeVariable, Type> entry : map.entrySet()) {

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

@@ -874,7 +874,7 @@ class AnnotatedElementUtilsTests {
 	void findAllMergedAnnotationsOnClassWithInterface() throws Exception {
 		Method method = TransactionalServiceImpl.class.getMethod("doIt");
 		Set<Transactional> allMergedAnnotations = findAllMergedAnnotations(method, Transactional.class);
-		assertThat(allMergedAnnotations.size()).isEqualTo(1);
+		assertThat(allMergedAnnotations).hasSize(1);
 	}
 
 	@Test  // SPR-16060

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

@@ -112,7 +112,7 @@ class ComposedRepeatableAnnotationsTests {
 		Class<?> element = SubNoninheritedRepeatableClass.class;
 		Set<Noninherited> annotations = getMergedRepeatableAnnotations(element, Noninherited.class);
 		assertThat(annotations).isNotNull();
-		assertThat(annotations.size()).isEqualTo(0);
+		assertThat(annotations).hasSize(0);
 	}
 
 	@Test
@@ -216,7 +216,7 @@ class ComposedRepeatableAnnotationsTests {
 
 		Set<PeteRepeat> peteRepeats = getMergedRepeatableAnnotations(element, PeteRepeat.class);
 		assertThat(peteRepeats).isNotNull();
-		assertThat(peteRepeats.size()).isEqualTo(3);
+		assertThat(peteRepeats).hasSize(3);
 
 		Iterator<PeteRepeat> iterator = peteRepeats.iterator();
 		assertThat(iterator.next().value()).isEqualTo("A");
@@ -229,7 +229,7 @@ class ComposedRepeatableAnnotationsTests {
 
 		Set<PeteRepeat> peteRepeats = findMergedRepeatableAnnotations(element, PeteRepeat.class);
 		assertThat(peteRepeats).isNotNull();
-		assertThat(peteRepeats.size()).isEqualTo(3);
+		assertThat(peteRepeats).hasSize(3);
 
 		Iterator<PeteRepeat> iterator = peteRepeats.iterator();
 		assertThat(iterator.next().value()).isEqualTo("A");
@@ -239,7 +239,7 @@ class ComposedRepeatableAnnotationsTests {
 
 	private void assertNoninheritedRepeatableAnnotations(Set<Noninherited> annotations) {
 		assertThat(annotations).isNotNull();
-		assertThat(annotations.size()).isEqualTo(3);
+		assertThat(annotations).hasSize(3);
 
 		Iterator<Noninherited> iterator = annotations.iterator();
 		assertThat(iterator.next().value()).isEqualTo("A");

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

@@ -62,7 +62,7 @@ class MultipleComposedAnnotationsOnSingleAnnotatedElementTests {
 		Class<?> element = MultipleNoninheritedComposedCachesClass.class;
 		Set<Cacheable> cacheables = getAllMergedAnnotations(element, Cacheable.class);
 		assertThat(cacheables).isNotNull();
-		assertThat(cacheables.size()).isEqualTo(2);
+		assertThat(cacheables).hasSize(2);
 
 		Iterator<Cacheable> iterator = cacheables.iterator();
 		Cacheable cacheable1 = iterator.next();
@@ -76,7 +76,7 @@ class MultipleComposedAnnotationsOnSingleAnnotatedElementTests {
 		Class<?> element = SubMultipleNoninheritedComposedCachesClass.class;
 		Set<Cacheable> cacheables = getAllMergedAnnotations(element, Cacheable.class);
 		assertThat(cacheables).isNotNull();
-		assertThat(cacheables.size()).isEqualTo(0);
+		assertThat(cacheables).hasSize(0);
 	}
 
 	@Test
@@ -89,7 +89,7 @@ class MultipleComposedAnnotationsOnSingleAnnotatedElementTests {
 		Class<MultipleComposedCachesOnInterfaceClass> element = MultipleComposedCachesOnInterfaceClass.class;
 		Set<Cacheable> cacheables = getAllMergedAnnotations(element, Cacheable.class);
 		assertThat(cacheables).isNotNull();
-		assertThat(cacheables.size()).isEqualTo(0);
+		assertThat(cacheables).hasSize(0);
 	}
 
 	@Test
@@ -109,7 +109,7 @@ class MultipleComposedAnnotationsOnSingleAnnotatedElementTests {
 	void getMultipleComposedAnnotationsOnBridgeMethod() throws Exception {
 		Set<Cacheable> cacheables = getAllMergedAnnotations(getBridgeMethod(), Cacheable.class);
 		assertThat(cacheables).isNotNull();
-		assertThat(cacheables.size()).isEqualTo(0);
+		assertThat(cacheables).hasSize(0);
 	}
 
 	@Test
@@ -127,7 +127,7 @@ class MultipleComposedAnnotationsOnSingleAnnotatedElementTests {
 		Class<?> element = MultipleNoninheritedComposedCachesClass.class;
 		Set<Cacheable> cacheables = findAllMergedAnnotations(element, Cacheable.class);
 		assertThat(cacheables).isNotNull();
-		assertThat(cacheables.size()).isEqualTo(2);
+		assertThat(cacheables).hasSize(2);
 
 		Iterator<Cacheable> iterator = cacheables.iterator();
 		Cacheable cacheable1 = iterator.next();
@@ -141,7 +141,7 @@ class MultipleComposedAnnotationsOnSingleAnnotatedElementTests {
 		Class<?> element = SubMultipleNoninheritedComposedCachesClass.class;
 		Set<Cacheable> cacheables = findAllMergedAnnotations(element, Cacheable.class);
 		assertThat(cacheables).isNotNull();
-		assertThat(cacheables.size()).isEqualTo(2);
+		assertThat(cacheables).hasSize(2);
 
 		Iterator<Cacheable> iterator = cacheables.iterator();
 		Cacheable cacheable1 = iterator.next();
@@ -213,7 +213,7 @@ class MultipleComposedAnnotationsOnSingleAnnotatedElementTests {
 
 		Set<Cacheable> cacheables = getAllMergedAnnotations(element, Cacheable.class);
 		assertThat(cacheables).isNotNull();
-		assertThat(cacheables.size()).isEqualTo(2);
+		assertThat(cacheables).hasSize(2);
 
 		Iterator<Cacheable> iterator = cacheables.iterator();
 		Cacheable fooCacheable = iterator.next();
@@ -229,7 +229,7 @@ class MultipleComposedAnnotationsOnSingleAnnotatedElementTests {
 
 		Set<Cacheable> cacheables = findAllMergedAnnotations(element, Cacheable.class);
 		assertThat(cacheables).isNotNull();
-		assertThat(cacheables.size()).isEqualTo(2);
+		assertThat(cacheables).hasSize(2);
 
 		Iterator<Cacheable> iterator = cacheables.iterator();
 		Cacheable fooCacheable = iterator.next();

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

@@ -681,7 +681,7 @@ class DefaultConversionServiceTests {
 		Collection values = map.values();
 		List<Integer> bar = (List<Integer>) conversionService.convert(values,
 				TypeDescriptor.forObject(values), new TypeDescriptor(getClass().getField("genericList")));
-		assertThat(bar.size()).isEqualTo(3);
+		assertThat(bar).hasSize(3);
 		assertThat(bar.get(0)).isEqualTo(1);
 		assertThat(bar.get(1)).isEqualTo(2);
 		assertThat(bar.get(2)).isEqualTo(3);
@@ -745,7 +745,7 @@ class DefaultConversionServiceTests {
 	@Test
 	void convertStringToProperties() {
 		Properties result = conversionService.convert("a=b\nc=2\nd=", Properties.class);
-		assertThat(result.size()).isEqualTo(3);
+		assertThat(result).hasSize(3);
 		assertThat(result.getProperty("a")).isEqualTo("b");
 		assertThat(result.getProperty("c")).isEqualTo("2");
 		assertThat(result.getProperty("d")).isEqualTo("");

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

@@ -195,7 +195,7 @@ class CollectionToCollectionConverterTests {
 				aSource, TypeDescriptor.forObject(aSource), TypeDescriptor.forObject(new ArrayList()));
 		boolean condition = myConverted instanceof ArrayList<?>;
 		assertThat(condition).isTrue();
-		assertThat(((ArrayList<?>) myConverted).size()).isEqualTo(aSource.size());
+		assertThat(((ArrayList<?>) myConverted)).hasSize(aSource.size());
 	}
 
 	@Test

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

@@ -240,7 +240,7 @@ class MapToMapConverterTests {
 		TypeDescriptor targetType = new TypeDescriptor(getClass().getField("multiValueMapTarget"));
 
 		MultiValueMap<String, String> converted = (MultiValueMap<String, String>) conversionService.convert(source, targetType);
-		assertThat(converted.size()).isEqualTo(2);
+		assertThat(converted).hasSize(2);
 		assertThat(converted.get("a")).isEqualTo(Arrays.asList("1", "2", "3"));
 		assertThat(converted.get("b")).isEqualTo(Arrays.asList("4", "5", "6"));
 	}
@@ -255,7 +255,7 @@ class MapToMapConverterTests {
 		TypeDescriptor targetType = new TypeDescriptor(getClass().getField("multiValueMapTarget"));
 
 		MultiValueMap<String, String> converted = (MultiValueMap<String, String>) conversionService.convert(source, targetType);
-		assertThat(converted.size()).isEqualTo(2);
+		assertThat(converted).hasSize(2);
 		assertThat(converted.get("a")).isEqualTo(Arrays.asList("1"));
 		assertThat(converted.get("b")).isEqualTo(Arrays.asList("2"));
 	}

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

@@ -39,7 +39,7 @@ class MutablePropertySourcesTests {
 		sources.addLast(new MockPropertySource("d").withProperty("p1", "dValue"));
 		sources.addLast(new MockPropertySource("f").withProperty("p1", "fValue"));
 
-		assertThat(sources.size()).isEqualTo(3);
+		assertThat(sources).hasSize(3);
 		assertThat(sources.contains("a")).isFalse();
 		assertThat(sources.contains("b")).isTrue();
 		assertThat(sources.contains("c")).isFalse();
@@ -56,7 +56,7 @@ class MutablePropertySourcesTests {
 		sources.addBefore("b", new MockPropertySource("a"));
 		sources.addAfter("b", new MockPropertySource("c"));
 
-		assertThat(sources.size()).isEqualTo(5);
+		assertThat(sources).hasSize(5);
 		assertThat(sources.precedenceOf(PropertySource.named("a"))).isEqualTo(0);
 		assertThat(sources.precedenceOf(PropertySource.named("b"))).isEqualTo(1);
 		assertThat(sources.precedenceOf(PropertySource.named("c"))).isEqualTo(2);
@@ -66,7 +66,7 @@ class MutablePropertySourcesTests {
 		sources.addBefore("f", new MockPropertySource("e"));
 		sources.addAfter("f", new MockPropertySource("g"));
 
-		assertThat(sources.size()).isEqualTo(7);
+		assertThat(sources).hasSize(7);
 		assertThat(sources.precedenceOf(PropertySource.named("a"))).isEqualTo(0);
 		assertThat(sources.precedenceOf(PropertySource.named("b"))).isEqualTo(1);
 		assertThat(sources.precedenceOf(PropertySource.named("c"))).isEqualTo(2);
@@ -76,7 +76,7 @@ class MutablePropertySourcesTests {
 		assertThat(sources.precedenceOf(PropertySource.named("g"))).isEqualTo(6);
 
 		sources.addLast(new MockPropertySource("a"));
-		assertThat(sources.size()).isEqualTo(7);
+		assertThat(sources).hasSize(7);
 		assertThat(sources.precedenceOf(PropertySource.named("b"))).isEqualTo(0);
 		assertThat(sources.precedenceOf(PropertySource.named("c"))).isEqualTo(1);
 		assertThat(sources.precedenceOf(PropertySource.named("d"))).isEqualTo(2);
@@ -86,7 +86,7 @@ class MutablePropertySourcesTests {
 		assertThat(sources.precedenceOf(PropertySource.named("a"))).isEqualTo(6);
 
 		sources.addFirst(new MockPropertySource("a"));
-		assertThat(sources.size()).isEqualTo(7);
+		assertThat(sources).hasSize(7);
 		assertThat(sources.precedenceOf(PropertySource.named("a"))).isEqualTo(0);
 		assertThat(sources.precedenceOf(PropertySource.named("b"))).isEqualTo(1);
 		assertThat(sources.precedenceOf(PropertySource.named("c"))).isEqualTo(2);
@@ -96,11 +96,11 @@ class MutablePropertySourcesTests {
 		assertThat(sources.precedenceOf(PropertySource.named("g"))).isEqualTo(6);
 
 		assertThat(PropertySource.named("a")).isEqualTo(sources.remove("a"));
-		assertThat(sources.size()).isEqualTo(6);
+		assertThat(sources).hasSize(6);
 		assertThat(sources.contains("a")).isFalse();
 
 		assertThat((Object) sources.remove("a")).isNull();
-		assertThat(sources.size()).isEqualTo(6);
+		assertThat(sources).hasSize(6);
 
 		String bogusPS = "bogus";
 		assertThatIllegalArgumentException().isThrownBy(() ->
@@ -108,13 +108,13 @@ class MutablePropertySourcesTests {
 			.withMessageContaining("does not exist");
 
 		sources.addFirst(new MockPropertySource("a"));
-		assertThat(sources.size()).isEqualTo(7);
+		assertThat(sources).hasSize(7);
 		assertThat(sources.precedenceOf(PropertySource.named("a"))).isEqualTo(0);
 		assertThat(sources.precedenceOf(PropertySource.named("b"))).isEqualTo(1);
 		assertThat(sources.precedenceOf(PropertySource.named("c"))).isEqualTo(2);
 
 		sources.replace("a", new MockPropertySource("a-replaced"));
-		assertThat(sources.size()).isEqualTo(7);
+		assertThat(sources).hasSize(7);
 		assertThat(sources.precedenceOf(PropertySource.named("a-replaced"))).isEqualTo(0);
 		assertThat(sources.precedenceOf(PropertySource.named("b"))).isEqualTo(1);
 		assertThat(sources.precedenceOf(PropertySource.named("c"))).isEqualTo(2);

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

@@ -114,7 +114,7 @@ class AnnotationMetadataTests {
 		assertThat(metadata.getAnnotationAttributes(Component.class.getName())).isNull();
 		assertThat(metadata.getAnnotationAttributes(MetaAnnotation.class.getName(), false)).isNull();
 		assertThat(metadata.getAnnotationAttributes(MetaAnnotation.class.getName(), true)).isNull();
-		assertThat(metadata.getAnnotatedMethods(DirectAnnotation.class.getName()).size()).isEqualTo(0);
+		assertThat(metadata.getAnnotatedMethods(DirectAnnotation.class.getName())).hasSize(0);
 		assertThat(metadata.isAnnotated(IsAnnotatedAnnotation.class.getName())).isFalse();
 		assertThat(metadata.getAllAnnotationAttributes(DirectAnnotation.class.getName())).isNull();
 	}

spring-core/src/test/java/org/springframework/tests/MockitoUtils.java

@@ -50,7 +50,7 @@ public abstract class MockitoUtils {
 	private static void verifySameInvocations(List<Invocation> expectedInvocations, List<Invocation> actualInvocations,
 			InvocationArgumentsAdapter... argumentAdapters) {
 
-		assertThat(expectedInvocations.size()).isEqualTo(actualInvocations.size());
+		assertThat(expectedInvocations).hasSize(actualInvocations.size());
 		for (int i = 0; i < expectedInvocations.size(); i++) {
 			verifySameInvocation(expectedInvocations.get(i), actualInvocations.get(i), argumentAdapters);
 		}

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

@@ -647,22 +647,22 @@ class AntPathMatcherTests {
 	@Test
 	void preventCreatingStringMatchersIfPathDoesNotStartsWithPatternPrefix() {
 		pathMatcher.setCachePatterns(true);
-		assertThat(pathMatcher.stringMatcherCache.size()).isEqualTo(0);
+		assertThat(pathMatcher.stringMatcherCache).hasSize(0);
 
 		pathMatcher.match("test?", "test");
-		assertThat(pathMatcher.stringMatcherCache.size()).isEqualTo(1);
+		assertThat(pathMatcher.stringMatcherCache).hasSize(1);
 
 		pathMatcher.match("test?", "best");
 		pathMatcher.match("test/*", "view/test.jpg");
 		pathMatcher.match("test/**/test.jpg", "view/test.jpg");
 		pathMatcher.match("test/{name}.jpg", "view/test.jpg");
-		assertThat(pathMatcher.stringMatcherCache.size()).isEqualTo(1);
+		assertThat(pathMatcher.stringMatcherCache).hasSize(1);
 	}
 
 	@Test
 	void creatingStringMatchersIfPatternPrefixCannotDetermineIfPathMatch() {
 		pathMatcher.setCachePatterns(true);
-		assertThat(pathMatcher.stringMatcherCache.size()).isEqualTo(0);
+		assertThat(pathMatcher.stringMatcherCache).hasSize(0);
 
 		pathMatcher.match("test", "testian");
 		pathMatcher.match("test?", "testFf");
@@ -673,7 +673,7 @@ class AntPathMatcherTests {
 		pathMatcher.match("/**/{name}.jpg", "/test/lorem.jpg");
 		pathMatcher.match("/*/dir/{name}.jpg", "/*/dir/lorem.jpg");
 
-		assertThat(pathMatcher.stringMatcherCache.size()).isEqualTo(7);
+		assertThat(pathMatcher.stringMatcherCache).hasSize(7);
 	}
 
 	@Test

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

@@ -38,7 +38,7 @@ class LinkedCaseInsensitiveMapTests {
 		assertThat(map.put("key", "value1")).isNull();
 		assertThat(map.put("key", "value2")).isEqualTo("value1");
 		assertThat(map.put("key", "value3")).isEqualTo("value2");
-		assertThat(map.size()).isEqualTo(1);
+		assertThat(map).hasSize(1);
 		assertThat(map.get("key")).isEqualTo("value3");
 		assertThat(map.get("KEY")).isEqualTo("value3");
 		assertThat(map.get("Key")).isEqualTo("value3");
@@ -55,7 +55,7 @@ class LinkedCaseInsensitiveMapTests {
 		assertThat(map.put("key", "value1")).isNull();
 		assertThat(map.put("KEY", "value2")).isEqualTo("value1");
 		assertThat(map.put("Key", "value3")).isEqualTo("value2");
-		assertThat(map.size()).isEqualTo(1);
+		assertThat(map).hasSize(1);
 		assertThat(map.get("key")).isEqualTo("value3");
 		assertThat(map.get("KEY")).isEqualTo("value3");
 		assertThat(map.get("Key")).isEqualTo("value3");
@@ -128,8 +128,8 @@ class LinkedCaseInsensitiveMapTests {
 		assertThat(copy.get("Key")).isEqualTo("value1");
 
 		copy.put("Key", "value2");
-		assertThat(map.size()).isEqualTo(1);
-		assertThat(copy.size()).isEqualTo(1);
+		assertThat(map).hasSize(1);
+		assertThat(copy).hasSize(1);
 		assertThat(map.get("key")).isEqualTo("value1");
 		assertThat(map.get("KEY")).isEqualTo("value1");
 		assertThat(map.get("Key")).isEqualTo("value1");
@@ -159,7 +159,7 @@ class LinkedCaseInsensitiveMapTests {
 	void removeFromKeySetViaIterator() {
 		map.put("key", "value");
 		nextAndRemove(map.keySet().iterator());
-		assertThat(map.size()).isEqualTo(0);
+		assertThat(map).hasSize(0);
 		map.computeIfAbsent("key", k -> "newvalue");
 		assertThat(map.get("key")).isEqualTo("newvalue");
 	}
@@ -168,7 +168,7 @@ class LinkedCaseInsensitiveMapTests {
 	void clearFromValues() {
 		map.put("key", "value");
 		map.values().clear();
-		assertThat(map.size()).isEqualTo(0);
+		assertThat(map).hasSize(0);
 		map.computeIfAbsent("key", k -> "newvalue");
 		assertThat(map.get("key")).isEqualTo("newvalue");
 	}
@@ -177,7 +177,7 @@ class LinkedCaseInsensitiveMapTests {
 	void removeFromValues() {
 		map.put("key", "value");
 		map.values().remove("value");
-		assertThat(map.size()).isEqualTo(0);
+		assertThat(map).hasSize(0);
 		map.computeIfAbsent("key", k -> "newvalue");
 		assertThat(map.get("key")).isEqualTo("newvalue");
 	}
@@ -186,7 +186,7 @@ class LinkedCaseInsensitiveMapTests {
 	void removeFromValuesViaIterator() {
 		map.put("key", "value");
 		nextAndRemove(map.values().iterator());
-		assertThat(map.size()).isEqualTo(0);
+		assertThat(map).hasSize(0);
 		map.computeIfAbsent("key", k -> "newvalue");
 		assertThat(map.get("key")).isEqualTo("newvalue");
 	}
@@ -195,7 +195,7 @@ class LinkedCaseInsensitiveMapTests {
 	void clearFromEntrySet() {
 		map.put("key", "value");
 		map.entrySet().clear();
-		assertThat(map.size()).isEqualTo(0);
+		assertThat(map).hasSize(0);
 		map.computeIfAbsent("key", k -> "newvalue");
 		assertThat(map.get("key")).isEqualTo("newvalue");
 	}
@@ -204,7 +204,7 @@ class LinkedCaseInsensitiveMapTests {
 	void removeFromEntrySet() {
 		map.put("key", "value");
 		map.entrySet().remove(map.entrySet().iterator().next());
-		assertThat(map.size()).isEqualTo(0);
+		assertThat(map).hasSize(0);
 		map.computeIfAbsent("key", k -> "newvalue");
 		assertThat(map.get("key")).isEqualTo("newvalue");
 	}
@@ -213,7 +213,7 @@ class LinkedCaseInsensitiveMapTests {
 	void removeFromEntrySetViaIterator() {
 		map.put("key", "value");
 		nextAndRemove(map.entrySet().iterator());
-		assertThat(map.size()).isEqualTo(0);
+		assertThat(map).hasSize(0);
 		map.computeIfAbsent("key", k -> "newvalue");
 		assertThat(map.get("key")).isEqualTo("newvalue");
 	}

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

@@ -344,7 +344,7 @@ class MimeTypeTests {
 		String s = String.join(",", mimeTypes);
 		List<MimeType> actual = MimeTypeUtils.parseMimeTypes(s);
 
-		assertThat(actual.size()).isEqualTo(mimeTypes.length);
+		assertThat(actual).hasSize(mimeTypes.length);
 		for (int i = 0; i < mimeTypes.length; i++) {
 			assertThat(actual.get(i).toString()).isEqualTo(mimeTypes[i]);
 		}

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

@@ -47,7 +47,7 @@ class UnmodifiableMultiValueMapTests {
 		UnmodifiableMultiValueMap<String, String> map = new UnmodifiableMultiValueMap<>(mock);
 
 		given(mock.size()).willReturn(1);
-		assertThat(map.size()).isEqualTo(1);
+		assertThat(map).hasSize(1);
 
 		given(mock.isEmpty()).willReturn(false);
 		assertThat(map.isEmpty()).isFalse();
@@ -107,7 +107,7 @@ class UnmodifiableMultiValueMapTests {
 		Set<Map.Entry<String, List<String>>> set = new UnmodifiableMultiValueMap<>(mockMap).entrySet();
 
 		given(mockSet.size()).willReturn(1);
-		assertThat(set.size()).isEqualTo(1);
+		assertThat(set).hasSize(1);
 
 		given(mockSet.isEmpty()).willReturn(false);
 		assertThat(set.isEmpty()).isFalse();
@@ -149,7 +149,7 @@ class UnmodifiableMultiValueMapTests {
 		Collection<List<String>> values = new UnmodifiableMultiValueMap<>(mockMap).values();
 
 		given(mockValues.size()).willReturn(1);
-		assertThat(values.size()).isEqualTo(1);
+		assertThat(values).hasSize(1);
 
 		given(mockValues.isEmpty()).willReturn(false);
 		assertThat(values.isEmpty()).isFalse();

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

@@ -156,19 +156,19 @@ public class ConstructorInvocationTests extends AbstractExpressionTests {
 
 		// reflective constructor accessor is the only one by default
 		List<ConstructorResolver> constructorResolvers = ctx.getConstructorResolvers();
-		assertThat(constructorResolvers.size()).isEqualTo(1);
+		assertThat(constructorResolvers).hasSize(1);
 
 		ConstructorResolver dummy = new DummyConstructorResolver();
 		ctx.addConstructorResolver(dummy);
-		assertThat(ctx.getConstructorResolvers().size()).isEqualTo(2);
+		assertThat(ctx.getConstructorResolvers()).hasSize(2);
 
 		List<ConstructorResolver> copy = new ArrayList<>(ctx.getConstructorResolvers());
 		assertThat(ctx.removeConstructorResolver(dummy)).isTrue();
 		assertThat(ctx.removeConstructorResolver(dummy)).isFalse();
-		assertThat(ctx.getConstructorResolvers().size()).isEqualTo(1);
+		assertThat(ctx.getConstructorResolvers()).hasSize(1);
 
 		ctx.setConstructorResolvers(copy);
-		assertThat(ctx.getConstructorResolvers().size()).isEqualTo(2);
+		assertThat(ctx.getConstructorResolvers()).hasSize(2);
 	}
 
 

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

@@ -70,14 +70,14 @@ class EvaluationTests extends AbstractExpressionTests {
 			assertThat(o).isEqualTo("");
 			o = parser.parseExpression("list[3]").getValue(new StandardEvaluationContext(testClass));
 			assertThat(o).isEqualTo("");
-			assertThat(testClass.list.size()).isEqualTo(4);
+			assertThat(testClass.list).hasSize(4);
 
 			assertThatExceptionOfType(EvaluationException.class).isThrownBy(() ->
 			parser.parseExpression("list2[3]").getValue(new StandardEvaluationContext(testClass)));
 
 			o = parser.parseExpression("foo[3]").getValue(new StandardEvaluationContext(testClass));
 			assertThat(o).isEqualTo("");
-			assertThat(testClass.getFoo().size()).isEqualTo(4);
+			assertThat(testClass.getFoo()).hasSize(4);
 		}
 
 		@Test
@@ -319,7 +319,7 @@ class EvaluationTests extends AbstractExpressionTests {
 			ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true));
 			Expression e =  parser.parseExpression("listOfStrings[++index3]='def'");
 			e.getValue(ctx);
-			assertThat(instance.listOfStrings.size()).isEqualTo(2);
+			assertThat(instance.listOfStrings).hasSize(2);
 			assertThat(instance.listOfStrings.get(1)).isEqualTo("def");
 
 			// Check reference beyond end of collection
@@ -351,14 +351,14 @@ class EvaluationTests extends AbstractExpressionTests {
 			SpelExpressionParser parser = new SpelExpressionParser( new SpelParserConfiguration(true, true, 3));
 			Expression e = parser.parseExpression("foo[2]");
 			e.setValue(ctx, "2");
-			assertThat(instance.getFoo().size()).isEqualTo(3);
+			assertThat(instance.getFoo()).hasSize(3);
 			e = parser.parseExpression("foo[3]");
 			try {
 				e.setValue(ctx, "3");
 			}
 			catch (SpelEvaluationException see) {
 				assertThat(see.getMessageCode()).isEqualTo(SpelMessage.UNABLE_TO_GROW_COLLECTION);
-				assertThat(instance.getFoo().size()).isEqualTo(3);
+				assertThat(instance.getFoo()).hasSize(3);
 			}
 		}
 

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

@@ -220,19 +220,19 @@ public class MethodInvocationTests extends AbstractExpressionTests {
 
 		// reflective method accessor is the only one by default
 		List<MethodResolver> methodResolvers = ctx.getMethodResolvers();
-		assertThat(methodResolvers.size()).isEqualTo(1);
+		assertThat(methodResolvers).hasSize(1);
 
 		MethodResolver dummy = new DummyMethodResolver();
 		ctx.addMethodResolver(dummy);
-		assertThat(ctx.getMethodResolvers().size()).isEqualTo(2);
+		assertThat(ctx.getMethodResolvers()).hasSize(2);
 
 		List<MethodResolver> copy = new ArrayList<>(ctx.getMethodResolvers());
 		assertThat(ctx.removeMethodResolver(dummy)).isTrue();
 		assertThat(ctx.removeMethodResolver(dummy)).isFalse();
-		assertThat(ctx.getMethodResolvers().size()).isEqualTo(1);
+		assertThat(ctx.getMethodResolvers()).hasSize(1);
 
 		ctx.setMethodResolvers(copy);
-		assertThat(ctx.getMethodResolvers().size()).isEqualTo(2);
+		assertThat(ctx.getMethodResolvers()).hasSize(2);
 	}
 
 	@Test

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

@@ -189,7 +189,7 @@ class SelectionAndProjectionTests {
 
 		Expression exp = parser.parseExpression("colors.^[key.startsWith('b')]");
 		Map<String, String> colorsMap = (Map<String, String>) exp.getValue(context);
-		assertThat(colorsMap.size()).isEqualTo(1);
+		assertThat(colorsMap).hasSize(1);
 		assertThat(colorsMap.keySet().iterator().next()).isEqualTo("beige");
 	}
 
@@ -201,7 +201,7 @@ class SelectionAndProjectionTests {
 
 		Expression exp = parser.parseExpression("colors.$[key.startsWith('b')]");
 		Map<String, String> colorsMap = (Map<String, String>) exp.getValue(context);
-		assertThat(colorsMap.size()).isEqualTo(1);
+		assertThat(colorsMap).hasSize(1);
 		assertThat(colorsMap.keySet().iterator().next()).isEqualTo("brown");
 	}
 

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

@@ -445,7 +445,7 @@ class SpelDocumentationTests extends AbstractExpressionTests {
 		StandardEvaluationContext societyContext = new StandardEvaluationContext();
 		societyContext.setRootObject(new IEEE());
 		List<Inventor> list = (List<Inventor>) parser.parseExpression("Members2.?[nationality == 'Serbian']").getValue(societyContext);
-		assertThat(list.size()).isEqualTo(1);
+		assertThat(list).hasSize(1);
 		assertThat(list.get(0).getName()).isEqualTo("Nikola Tesla");
 	}
 

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

@@ -40,7 +40,7 @@ class StandardTypeLocatorTests {
 		assertThat(locator.findType("java.lang.String")).isEqualTo(String.class);
 
 		List<String> prefixes = locator.getImportPrefixes();
-		assertThat(prefixes.size()).isEqualTo(1);
+		assertThat(prefixes).hasSize(1);
 		assertThat(prefixes.contains("java.lang")).isTrue();
 		assertThat(prefixes.contains("java.util")).isFalse();
 

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

@@ -59,13 +59,13 @@ public class StandardComponentsTests {
 	public void testStandardTypeLocator() {
 		StandardTypeLocator tl = new StandardTypeLocator();
 		List<String> prefixes = tl.getImportPrefixes();
-		assertThat(prefixes.size()).isEqualTo(1);
+		assertThat(prefixes).hasSize(1);
 		tl.registerImport("java.util");
 		prefixes = tl.getImportPrefixes();
-		assertThat(prefixes.size()).isEqualTo(2);
+		assertThat(prefixes).hasSize(2);
 		tl.removeImport("java.util");
 		prefixes = tl.getImportPrefixes();
-		assertThat(prefixes.size()).isEqualTo(1);
+		assertThat(prefixes).hasSize(1);
 	}
 
 	@Test

spring-jdbc/src/test/java/org/springframework/jdbc/config/InitializeDatabaseIntegrationTests.java

@@ -110,7 +110,7 @@ public class InitializeDatabaseIntegrationTests {
 		context = new ClassPathXmlApplicationContext("org/springframework/jdbc/config/jdbc-initialize-cache-config.xml");
 		assertCorrectSetup(context.getBean("dataSource", DataSource.class));
 		CacheData cache = context.getBean(CacheData.class);
-		assertThat(cache.getCachedData().size()).isEqualTo(1);
+		assertThat(cache.getCachedData()).hasSize(1);
 	}
 
 	private void assertCorrectSetup(DataSource dataSource) {

spring-jdbc/src/test/java/org/springframework/jdbc/core/DataClassRowMapperTests.java

@@ -41,7 +41,7 @@ public class DataClassRowMapperTests extends AbstractRowMapperTests {
 		List<ConstructorPerson> result = mock.getJdbcTemplate().query(
 				"select name, age, birth_date, balance from people",
 				new DataClassRowMapper<>(ConstructorPerson.class));
-		assertThat(result.size()).isEqualTo(1);
+		assertThat(result).hasSize(1);
 		verifyPerson(result.get(0));
 
 		mock.verifyClosed();
@@ -53,7 +53,7 @@ public class DataClassRowMapperTests extends AbstractRowMapperTests {
 		List<ConstructorPersonWithGenerics> result = mock.getJdbcTemplate().query(
 				"select name, age, birth_date, balance from people",
 				new DataClassRowMapper<>(ConstructorPersonWithGenerics.class));
-		assertThat(result.size()).isEqualTo(1);
+		assertThat(result).hasSize(1);
 		ConstructorPersonWithGenerics person = result.get(0);
 		assertThat(person.name()).isEqualTo("Bubba");
 		assertThat(person.age()).isEqualTo(22L);
@@ -69,7 +69,7 @@ public class DataClassRowMapperTests extends AbstractRowMapperTests {
 		List<ConstructorPersonWithSetters> result = mock.getJdbcTemplate().query(
 				"select name, age, birthdate, balance from people",
 				new DataClassRowMapper<>(ConstructorPersonWithSetters.class));
-		assertThat(result.size()).isEqualTo(1);
+		assertThat(result).hasSize(1);
 		ConstructorPersonWithSetters person = result.get(0);
 		assertThat(person.name()).isEqualTo("BUBBA");
 		assertThat(person.age()).isEqualTo(22L);
@@ -85,7 +85,7 @@ public class DataClassRowMapperTests extends AbstractRowMapperTests {
 		List<RecordPerson> result = mock.getJdbcTemplate().query(
 				"select name, age, birth_date, balance from people",
 				new DataClassRowMapper<>(RecordPerson.class));
-		assertThat(result.size()).isEqualTo(1);
+		assertThat(result).hasSize(1);
 		verifyPerson(result.get(0));
 
 		mock.verifyClosed();

spring-jdbc/src/test/java/org/springframework/jdbc/core/JdbcTemplateTests.java

@@ -1082,7 +1082,7 @@ public class JdbcTemplateTests {
 		given(this.resultSet.getObject(2)).willReturn("second value");
 
 		Map<String, Object> map = this.template.queryForMap("my query");
-		assertThat(map.size()).isEqualTo(1);
+		assertThat(map).hasSize(1);
 		assertThat(map.get("x")).isEqualTo("first value");
 	}
 

spring-jdbc/src/test/java/org/springframework/jdbc/core/RowMapperTests.java

@@ -83,7 +83,7 @@ public class RowMapperTests {
 	@AfterEach
 	public void verifyResults() {
 		assertThat(result).isNotNull();
-		assertThat(result.size()).isEqualTo(2);
+		assertThat(result).hasSize(2);
 		TestBean testBean1 = result.get(0);
 		TestBean testBean2 = result.get(1);
 		assertThat(testBean1.getName()).isEqualTo("tb1");

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

@@ -283,7 +283,7 @@ public class NamedParameterJdbcTemplateTests {
 			customers.add(cust);
 		});
 
-		assertThat(customers.size()).isEqualTo(1);
+		assertThat(customers).hasSize(1);
 		assertThat(customers.get(0).getId() == 1).as("Customer id was assigned correctly").isTrue();
 		assertThat(customers.get(0).getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
 		verify(connection).prepareStatement(SELECT_NAMED_PARAMETERS_PARSED);
@@ -308,7 +308,7 @@ public class NamedParameterJdbcTemplateTests {
 			customers.add(cust);
 		});
 
-		assertThat(customers.size()).isEqualTo(1);
+		assertThat(customers).hasSize(1);
 		assertThat(customers.get(0).getId() == 1).as("Customer id was assigned correctly").isTrue();
 		assertThat(customers.get(0).getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
 		verify(connection).prepareStatement(SELECT_NO_PARAMETERS);
@@ -333,7 +333,7 @@ public class NamedParameterJdbcTemplateTests {
 					return cust;
 				});
 
-		assertThat(customers.size()).isEqualTo(1);
+		assertThat(customers).hasSize(1);
 		assertThat(customers.get(0).getId() == 1).as("Customer id was assigned correctly").isTrue();
 		assertThat(customers.get(0).getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
 		verify(connection).prepareStatement(SELECT_NAMED_PARAMETERS_PARSED);
@@ -358,7 +358,7 @@ public class NamedParameterJdbcTemplateTests {
 					return cust;
 				});
 
-		assertThat(customers.size()).isEqualTo(1);
+		assertThat(customers).hasSize(1);
 		assertThat(customers.get(0).getId() == 1).as("Customer id was assigned correctly").isTrue();
 		assertThat(customers.get(0).getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
 		verify(connection).prepareStatement(SELECT_NO_PARAMETERS);

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

@@ -224,7 +224,7 @@ public class NamedParameterUtilsTests {
 		String sql = "select '0\\:0' as a, foo from bar where baz < DATE(:p1 23\\:59\\:59) and baz = :p2";
 
 		ParsedSql parsedSql = NamedParameterUtils.parseSqlStatement(sql);
-		assertThat(parsedSql.getParameterNames().size()).isEqualTo(2);
+		assertThat(parsedSql.getParameterNames()).hasSize(2);
 		assertThat(parsedSql.getParameterNames().get(0)).isEqualTo("p1");
 		assertThat(parsedSql.getParameterNames().get(1)).isEqualTo("p2");
 		String finalSql = NamedParameterUtils.substituteNamedParameters(parsedSql, null);
@@ -237,7 +237,7 @@ public class NamedParameterUtilsTests {
 		String sql = "select foo from bar where baz = b:{p1}:{p2}z";
 
 		ParsedSql parsedSql = NamedParameterUtils.parseSqlStatement(sql);
-		assertThat(parsedSql.getParameterNames().size()).isEqualTo(2);
+		assertThat(parsedSql.getParameterNames()).hasSize(2);
 		assertThat(parsedSql.getParameterNames().get(0)).isEqualTo("p1");
 		assertThat(parsedSql.getParameterNames().get(1)).isEqualTo("p2");
 		String finalSql = NamedParameterUtils.substituteNamedParameters(parsedSql, null);
@@ -249,7 +249,7 @@ public class NamedParameterUtilsTests {
 		String expectedSql = "select foo from bar where baz = b:{}z";
 		String sql = "select foo from bar where baz = b:{}z";
 		ParsedSql parsedSql = NamedParameterUtils.parseSqlStatement(sql);
-		assertThat(parsedSql.getParameterNames().size()).isEqualTo(0);
+		assertThat(parsedSql.getParameterNames()).hasSize(0);
 		String finalSql = NamedParameterUtils.substituteNamedParameters(parsedSql, null);
 		assertThat(finalSql).isEqualTo(expectedSql);
 
@@ -257,7 +257,7 @@ public class NamedParameterUtilsTests {
 		String sql2 = "select foo from bar where baz = 'b:{p1}z'";
 
 		ParsedSql parsedSql2 = NamedParameterUtils.parseSqlStatement(sql2);
-		assertThat(parsedSql2.getParameterNames().size()).isEqualTo(0);
+		assertThat(parsedSql2.getParameterNames()).hasSize(0);
 		String finalSql2 = NamedParameterUtils.substituteNamedParameters(parsedSql2, null);
 		assertThat(finalSql2).isEqualTo(expectedSql2);
 	}
@@ -268,7 +268,7 @@ public class NamedParameterUtilsTests {
 		String sql = "select foo from bar where baz = b:{p}z";
 
 		ParsedSql parsedSql = NamedParameterUtils.parseSqlStatement(sql);
-		assertThat(parsedSql.getParameterNames().size()).isEqualTo(1);
+		assertThat(parsedSql.getParameterNames()).hasSize(1);
 		assertThat(parsedSql.getParameterNames().get(0)).isEqualTo("p");
 		String finalSql = NamedParameterUtils.substituteNamedParameters(parsedSql, null);
 		assertThat(finalSql).isEqualTo(expectedSql);

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

@@ -167,7 +167,7 @@ public class RdbmsOperationTests {
 				new SqlParameter("two", Types.NUMERIC)});
 		operation.afterPropertiesSet();
 		operation.validateParameters(new Object[] { 1, "2" });
-		assertThat(operation.getDeclaredParameters().size()).isEqualTo(2);
+		assertThat(operation.getDeclaredParameters()).hasSize(2);
 	}
 
 

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

@@ -224,7 +224,7 @@ public class SqlUpdateTests {
 		int rowsAffected = pc.run("rod", generatedKeyHolder);
 
 		assertThat(rowsAffected).isEqualTo(1);
-		assertThat(generatedKeyHolder.getKeyList().size()).isEqualTo(1);
+		assertThat(generatedKeyHolder.getKeyList()).hasSize(1);
 		assertThat(generatedKeyHolder.getKey().intValue()).isEqualTo(11);
 		verify(preparedStatement).setString(1, "rod");
 		verify(resultSet).close();

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

@@ -317,7 +317,7 @@ public class StoredProcedureTests {
 		assertThat(rs1).containsExactly("Foo", "Bar");
 
 		List<Object> rs2 = (List<Object>) res.get("#result-set-2");
-		assertThat(rs2.size()).isEqualTo(1);
+		assertThat(rs2).hasSize(1);
 		Object o2 = rs2.get(0);
 		assertThat(o2).as("wron type returned for result set 2").isInstanceOf(Map.class);
 		Map<String, String> m2 = (Map<String, String>) o2;
@@ -362,7 +362,7 @@ public class StoredProcedureTests {
 
 		assertThat(res.size()).as("incorrect number of returns").isEqualTo(1);
 		List<String> rs1 = (List<String>) res.get("rs");
-		assertThat(rs1.size()).isEqualTo(2);
+		assertThat(rs1).hasSize(2);
 		assertThat(rs1.get(0)).isEqualTo("Foo");
 		assertThat(rs1.get(1)).isEqualTo("Bar");
 		verify(resultSet).close();

spring-jms/src/test/java/org/springframework/jms/annotation/AbstractJmsAnnotationDrivenTests.java

@@ -84,8 +84,8 @@ abstract class AbstractJmsAnnotationDrivenTests {
 				context.getBean("jmsListenerContainerFactory", JmsListenerContainerTestFactory.class);
 		JmsListenerContainerTestFactory simpleFactory =
 				context.getBean("simpleFactory", JmsListenerContainerTestFactory.class);
-		assertThat(defaultFactory.getListenerContainers().size()).isEqualTo(1);
-		assertThat(simpleFactory.getListenerContainers().size()).isEqualTo(1);
+		assertThat(defaultFactory.getListenerContainers()).hasSize(1);
+		assertThat(simpleFactory.getListenerContainers()).hasSize(1);
 	}
 
 	/**
@@ -96,7 +96,7 @@ abstract class AbstractJmsAnnotationDrivenTests {
 	protected void testFullConfiguration(ApplicationContext context) {
 		JmsListenerContainerTestFactory simpleFactory =
 				context.getBean("simpleFactory", JmsListenerContainerTestFactory.class);
-		assertThat(simpleFactory.getListenerContainers().size()).isEqualTo(1);
+		assertThat(simpleFactory.getListenerContainers()).hasSize(1);
 		MethodJmsListenerEndpoint endpoint = (MethodJmsListenerEndpoint)
 				simpleFactory.getListenerContainers().get(0).getEndpoint();
 		assertThat(endpoint.getId()).isEqualTo("listener1");
@@ -121,8 +121,8 @@ abstract class AbstractJmsAnnotationDrivenTests {
 				context.getBean("jmsListenerContainerFactory", JmsListenerContainerTestFactory.class);
 		JmsListenerContainerTestFactory customFactory =
 				context.getBean("customFactory", JmsListenerContainerTestFactory.class);
-		assertThat(defaultFactory.getListenerContainers().size()).isEqualTo(1);
-		assertThat(customFactory.getListenerContainers().size()).isEqualTo(1);
+		assertThat(defaultFactory.getListenerContainers()).hasSize(1);
+		assertThat(customFactory.getListenerContainers()).hasSize(1);
 		JmsListenerEndpoint endpoint = defaultFactory.getListenerContainers().get(0).getEndpoint();
 		assertThat(endpoint.getClass()).as("Wrong endpoint type").isEqualTo(SimpleJmsListenerEndpoint.class);
 		assertThat(((SimpleJmsListenerEndpoint) endpoint).getMessageListener()).as("Wrong listener set in custom endpoint").isEqualTo(context.getBean("simpleMessageListener"));
@@ -143,7 +143,7 @@ abstract class AbstractJmsAnnotationDrivenTests {
 	protected void testExplicitContainerFactoryConfiguration(ApplicationContext context) {
 		JmsListenerContainerTestFactory defaultFactory =
 				context.getBean("simpleFactory", JmsListenerContainerTestFactory.class);
-		assertThat(defaultFactory.getListenerContainers().size()).isEqualTo(1);
+		assertThat(defaultFactory.getListenerContainers()).hasSize(1);
 	}
 
 	/**
@@ -153,7 +153,7 @@ abstract class AbstractJmsAnnotationDrivenTests {
 	protected void testDefaultContainerFactoryConfiguration(ApplicationContext context) {
 		JmsListenerContainerTestFactory defaultFactory =
 				context.getBean("jmsListenerContainerFactory", JmsListenerContainerTestFactory.class);
-		assertThat(defaultFactory.getListenerContainers().size()).isEqualTo(1);
+		assertThat(defaultFactory.getListenerContainers()).hasSize(1);
 	}
 
 	/**
@@ -165,7 +165,7 @@ abstract class AbstractJmsAnnotationDrivenTests {
 	protected void testJmsHandlerMethodFactoryConfiguration(ApplicationContext context) throws JMSException {
 		JmsListenerContainerTestFactory simpleFactory =
 				context.getBean("defaultFactory", JmsListenerContainerTestFactory.class);
-		assertThat(simpleFactory.getListenerContainers().size()).isEqualTo(1);
+		assertThat(simpleFactory.getListenerContainers()).hasSize(1);
 		MethodJmsListenerEndpoint endpoint = (MethodJmsListenerEndpoint)
 				simpleFactory.getListenerContainers().get(0).getEndpoint();
 
@@ -182,7 +182,7 @@ abstract class AbstractJmsAnnotationDrivenTests {
 	protected void testJmsListenerRepeatable(ApplicationContext context) {
 		JmsListenerContainerTestFactory simpleFactory =
 				context.getBean("jmsListenerContainerFactory", JmsListenerContainerTestFactory.class);
-		assertThat(simpleFactory.getListenerContainers().size()).isEqualTo(2);
+		assertThat(simpleFactory.getListenerContainers()).hasSize(2);
 
 		MethodJmsListenerEndpoint first = (MethodJmsListenerEndpoint)
 				simpleFactory.getListenerContainer("first").getEndpoint();

spring-jms/src/test/java/org/springframework/jms/annotation/EnableJmsTests.java

@@ -162,7 +162,7 @@ class EnableJmsTests extends AbstractJmsAnnotationDrivenTests {
 			EnableJmsDefaultContainerFactoryConfig.class, ComposedJmsListenersBean.class)) {
 			JmsListenerContainerTestFactory simpleFactory = context.getBean("jmsListenerContainerFactory",
 				JmsListenerContainerTestFactory.class);
-			assertThat(simpleFactory.getListenerContainers().size()).isEqualTo(2);
+			assertThat(simpleFactory.getListenerContainers()).hasSize(2);
 
 			MethodJmsListenerEndpoint first = (MethodJmsListenerEndpoint) simpleFactory.getListenerContainer(
 				"first").getEndpoint();
@@ -193,10 +193,10 @@ class EnableJmsTests extends AbstractJmsAnnotationDrivenTests {
 				EnableJmsDefaultContainerFactoryConfig.class, LazyBean.class);
 		JmsListenerContainerTestFactory defaultFactory =
 				context.getBean("jmsListenerContainerFactory", JmsListenerContainerTestFactory.class);
-		assertThat(defaultFactory.getListenerContainers().size()).isEqualTo(0);
+		assertThat(defaultFactory.getListenerContainers()).hasSize(0);
 
 		context.getBean(LazyBean.class);  // trigger lazy resolution
-		assertThat(defaultFactory.getListenerContainers().size()).isEqualTo(1);
+		assertThat(defaultFactory.getListenerContainers()).hasSize(1);
 		MessageListenerTestContainer container = defaultFactory.getListenerContainers().get(0);
 		assertThat(container.isStarted()).as("Should have been started " + container).isTrue();
 		context.close();  // close and stop the listeners

spring-jms/src/test/java/org/springframework/jms/config/JmsListenerEndpointRegistrarTests.java

@@ -73,7 +73,7 @@ public class JmsListenerEndpointRegistrarTests {
 		this.registrar.registerEndpoint(endpoint, null);
 		this.registrar.afterPropertiesSet();
 		assertThat(this.registry.getListenerContainer("some id")).as("Container not created").isNotNull();
-		assertThat(this.registry.getListenerContainers().size()).isEqualTo(1);
+		assertThat(this.registry.getListenerContainers()).hasSize(1);
 		assertThat(this.registry.getListenerContainerIds().iterator().next()).isEqualTo("some id");
 	}
 
@@ -96,7 +96,7 @@ public class JmsListenerEndpointRegistrarTests {
 		this.registrar.registerEndpoint(endpoint);
 		this.registrar.afterPropertiesSet();
 		assertThat(this.registry.getListenerContainer("myEndpoint")).as("Container not created").isNotNull();
-		assertThat(this.registry.getListenerContainers().size()).isEqualTo(1);
+		assertThat(this.registry.getListenerContainers()).hasSize(1);
 		assertThat(this.registry.getListenerContainerIds().iterator().next()).isEqualTo("myEndpoint");
 	}
 

spring-jms/src/test/java/org/springframework/jms/core/JmsTemplateTests.java

@@ -237,7 +237,7 @@ class JmsTemplateTests {
 			tac.close();
 
 			List<TransactionSynchronization> synchs = TransactionSynchronizationManager.getSynchronizations();
-			assertThat(synchs.size()).isEqualTo(1);
+			assertThat(synchs).hasSize(1);
 			TransactionSynchronization synch = synchs.get(0);
 			synch.beforeCommit(false);
 			synch.beforeCompletion();

spring-jms/src/test/java/org/springframework/jms/listener/adapter/MessagingMessageListenerAdapterTests.java

@@ -153,7 +153,7 @@ public class MessagingMessageListenerAdapterTests {
 		listener.setMessageConverter(messageConverter);
 		listener.onMessage(jmsMessage, session);
 		verify(messageConverter, times(1)).fromMessage(jmsMessage);
-		assertThat(sample.simples.size()).isEqualTo(1);
+		assertThat(sample.simples).hasSize(1);
 		assertThat(sample.simples.get(0).getPayload()).isEqualTo("FooBar");
 	}
 

spring-messaging/src/test/java/org/springframework/messaging/MessageHeadersTests.java

@@ -196,7 +196,7 @@ public class MessageHeadersTests {
 		}
 		MessageHeaders headers = new MyMH();
 		assertThat(headers.getId().toString()).isEqualTo("00000000-0000-0000-0000-000000000001");
-		assertThat(headers.size()).isEqualTo(1);
+		assertThat(headers).hasSize(1);
 	}
 
 }

spring-messaging/src/test/java/org/springframework/messaging/handler/invocation/InvocableHandlerMethodTests.java

@@ -51,8 +51,8 @@ public class InvocableHandlerMethodTests {
 		Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method();
 		Object value = invoke(new Handler(), method);
 
-		assertThat(getStubResolver(0).getResolvedParameters().size()).isEqualTo(1);
-		assertThat(getStubResolver(1).getResolvedParameters().size()).isEqualTo(1);
+		assertThat(getStubResolver(0).getResolvedParameters()).hasSize(1);
+		assertThat(getStubResolver(1).getResolvedParameters()).hasSize(1);
 		assertThat(value).isEqualTo("99-value");
 		assertThat(getStubResolver(0).getResolvedParameters().get(0).getParameterName()).isEqualTo("intArg");
 		assertThat(getStubResolver(1).getResolvedParameters().get(0).getParameterName()).isEqualTo("stringArg");
@@ -65,8 +65,8 @@ public class InvocableHandlerMethodTests {
 		Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method();
 		Object value = invoke(new Handler(), method);
 
-		assertThat(getStubResolver(0).getResolvedParameters().size()).isEqualTo(1);
-		assertThat(getStubResolver(1).getResolvedParameters().size()).isEqualTo(1);
+		assertThat(getStubResolver(0).getResolvedParameters()).hasSize(1);
+		assertThat(getStubResolver(1).getResolvedParameters()).hasSize(1);
 		assertThat(value).isEqualTo("null-null");
 	}
 

spring-messaging/src/test/java/org/springframework/messaging/handler/invocation/reactive/InvocableHandlerMethodTests.java

@@ -58,8 +58,8 @@ public class InvocableHandlerMethodTests {
 		Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method();
 		Object value = invokeAndBlock(new Handler(), method);
 
-		assertThat(getStubResolver(0).getResolvedParameters().size()).isEqualTo(1);
-		assertThat(getStubResolver(1).getResolvedParameters().size()).isEqualTo(1);
+		assertThat(getStubResolver(0).getResolvedParameters()).hasSize(1);
+		assertThat(getStubResolver(1).getResolvedParameters()).hasSize(1);
 		assertThat(value).isEqualTo("99-value");
 		assertThat(getStubResolver(0).getResolvedParameters().get(0).getParameterName()).isEqualTo("intArg");
 		assertThat(getStubResolver(1).getResolvedParameters().get(0).getParameterName()).isEqualTo("stringArg");
@@ -72,8 +72,8 @@ public class InvocableHandlerMethodTests {
 		Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method();
 		Object value = invokeAndBlock(new Handler(), method);
 
-		assertThat(getStubResolver(0).getResolvedParameters().size()).isEqualTo(1);
-		assertThat(getStubResolver(1).getResolvedParameters().size()).isEqualTo(1);
+		assertThat(getStubResolver(0).getResolvedParameters()).hasSize(1);
+		assertThat(getStubResolver(1).getResolvedParameters()).hasSize(1);
 		assertThat(value).isEqualTo("null-null");
 	}
 
@@ -145,7 +145,7 @@ public class InvocableHandlerMethodTests {
 		Object value = invokeAndBlock(handler, method);
 
 		assertThat(value).isNull();
-		assertThat(getStubResolver(0).getResolvedParameters().size()).isEqualTo(1);
+		assertThat(getStubResolver(0).getResolvedParameters()).hasSize(1);
 		assertThat(handler.getResult()).isEqualTo("5.25");
 		assertThat(getStubResolver(0).getResolvedParameters().get(0).getParameterName()).isEqualTo("amount");
 	}

spring-messaging/src/test/java/org/springframework/messaging/handler/invocation/reactive/MethodMessageHandlerTests.java

@@ -66,7 +66,7 @@ public class MethodMessageHandlerTests {
 		TestMethodMessageHandler messageHandler = initMethodMessageHandler(TestController.class);
 		Map<String, HandlerMethod> mappings = messageHandler.getHandlerMethods();
 
-		assertThat(mappings.keySet().size()).isEqualTo(5);
+		assertThat(mappings.keySet()).hasSize(5);
 		assertThat(mappings).containsOnlyKeys(
 				"/handleMessage", "/handleMessageWithArgument", "/handleMessageWithError",
 				"/handleMessageMatch1", "/handleMessageMatch2");

spring-messaging/src/test/java/org/springframework/messaging/rsocket/DefaultRSocketRequesterTests.java

@@ -119,7 +119,7 @@ public class DefaultRSocketRequesterTests {
 		assertThat(payloads).isNotNull();
 
 		if (Arrays.equals(new String[] {""}, expectedValues)) {
-			assertThat(payloads.size()).isEqualTo(1);
+			assertThat(payloads).hasSize(1);
 			assertThat(payloads.get(0).getMetadataUtf8()).isEqualTo("toA");
 			assertThat(payloads.get(0).getDataUtf8()).isEqualTo("");
 		}

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

@@ -62,7 +62,7 @@ public class SimpMessagingTemplateTests {
 		this.messagingTemplate.convertAndSendToUser("joe", "/queue/foo", "data");
 		List<Message<byte[]>> messages = this.messageChannel.getMessages();
 
-		assertThat(messages.size()).isEqualTo(1);
+		assertThat(messages).hasSize(1);
 
 		Message<byte[]> message = messages.get(0);
 		SimpMessageHeaderAccessor headerAccessor =
@@ -78,7 +78,7 @@ public class SimpMessagingTemplateTests {
 		this.messagingTemplate.convertAndSendToUser("https://joe.openid.example.org/", "/queue/foo", "data");
 		List<Message<byte[]>> messages = this.messageChannel.getMessages();
 
-		assertThat(messages.size()).isEqualTo(1);
+		assertThat(messages).hasSize(1);
 
 		SimpMessageHeaderAccessor headerAccessor =
 				MessageHeaderAccessor.getAccessor(messages.get(0), SimpMessageHeaderAccessor.class);
@@ -133,7 +133,7 @@ public class SimpMessagingTemplateTests {
 		this.messagingTemplate.convertAndSendToUser("joe", "/queue/foo", "data");
 		List<Message<byte[]>> messages = this.messageChannel.getMessages();
 
-		assertThat(messages.size()).isEqualTo(1);
+		assertThat(messages).hasSize(1);
 
 		Message<byte[]> message = messages.get(0);
 		SimpMessageHeaderAccessor headerAccessor =

spring-messaging/src/test/java/org/springframework/messaging/simp/broker/DefaultSubscriptionRegistryTests.java

@@ -53,17 +53,17 @@ public class DefaultSubscriptionRegistryTests {
 		this.registry.registerSubscription(subscribeMessage(null, subsId, dest));
 		MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(0);
+		assertThat(actual).hasSize(0);
 
 		this.registry.registerSubscription(subscribeMessage(sessId, null, dest));
 		actual = this.registry.findSubscriptions(createMessage(dest));
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(0);
+		assertThat(actual).hasSize(0);
 
 		this.registry.registerSubscription(subscribeMessage(sessId, subsId, null));
 		actual = this.registry.findSubscriptions(createMessage(dest));
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(0);
+		assertThat(actual).hasSize(0);
 	}
 
 	@Test
@@ -92,7 +92,7 @@ public class DefaultSubscriptionRegistryTests {
 
 		MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(1);
+		assertThat(actual).hasSize(1);
 		assertThat(sort(actual.get(sessId))).isEqualTo(subscriptionIds);
 	}
 
@@ -107,7 +107,7 @@ public class DefaultSubscriptionRegistryTests {
 
 		MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(1);
+		assertThat(actual).hasSize(1);
 		assertThat(actual.get(sessId)).containsExactly(subId);
 	}
 
@@ -125,7 +125,7 @@ public class DefaultSubscriptionRegistryTests {
 
 		MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(3);
+		assertThat(actual).hasSize(3);
 		assertThat(sort(actual.get(sessIds.get(0)))).isEqualTo(subscriptionIds);
 		assertThat(sort(actual.get(sessIds.get(1)))).isEqualTo(subscriptionIds);
 		assertThat(sort(actual.get(sessIds.get(2)))).isEqualTo(subscriptionIds);
@@ -162,7 +162,7 @@ public class DefaultSubscriptionRegistryTests {
 
 		MultiValueMap<String, String> actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(1);
+		assertThat(actual).hasSize(1);
 		assertThat(actual.get(sess1)).containsExactlyInAnyOrder(subs2, subs1);
 
 		this.registry.registerSubscription(subscribeMessage(sess2, subs1, destNasdaqIbm));
@@ -171,7 +171,7 @@ public class DefaultSubscriptionRegistryTests {
 
 		actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(2);
+		assertThat(actual).hasSize(2);
 		assertThat(actual.get(sess1)).containsExactlyInAnyOrder(subs2, subs1);
 		assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
 
@@ -179,7 +179,7 @@ public class DefaultSubscriptionRegistryTests {
 
 		actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(1);
+		assertThat(actual).hasSize(1);
 		assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
 
 		this.registry.registerSubscription(subscribeMessage(sess1, subs1, "/topic/PRICE.STOCK.*.IBM"));
@@ -187,7 +187,7 @@ public class DefaultSubscriptionRegistryTests {
 
 		actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(2);
+		assertThat(actual).hasSize(2);
 		assertThat(actual.get(sess1)).containsExactlyInAnyOrder(subs1, subs2);
 		assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
 
@@ -195,7 +195,7 @@ public class DefaultSubscriptionRegistryTests {
 
 		actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(2);
+		assertThat(actual).hasSize(2);
 		assertThat(actual.get(sess1)).isEqualTo(Collections.singletonList(subs1));
 		assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
 
@@ -203,14 +203,14 @@ public class DefaultSubscriptionRegistryTests {
 
 		actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(1);
+		assertThat(actual).hasSize(1);
 		assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
 
 		this.registry.unregisterSubscription(unsubscribeMessage(sess2, subs1));
 
 		actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(0);
+		assertThat(actual).hasSize(0);
 	}
 
 	@Test  // SPR-11755
@@ -289,14 +289,14 @@ public class DefaultSubscriptionRegistryTests {
 
 		MultiValueMap<String, String> actual = this.registry.findSubscriptions(message);
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(1);
+		assertThat(actual).hasSize(1);
 		assertThat(actual.get(sessionId)).isEqualTo(Collections.singletonList(subscriptionId));
 
 		// Then without
 
 		actual = this.registry.findSubscriptions(createMessage(destination));
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(0);
+		assertThat(actual).hasSize(0);
 	}
 
 	@Test
@@ -316,7 +316,7 @@ public class DefaultSubscriptionRegistryTests {
 
 		MultiValueMap<String, String> actual = this.registry.findSubscriptions(message);
 		assertThat(actual).isNotNull();
-		assertThat(actual.size()).isEqualTo(1);
+		assertThat(actual).hasSize(1);
 		assertThat(actual.get(sessionId)).isEqualTo(Collections.singletonList(subscriptionId));
 	}
 
@@ -408,7 +408,7 @@ public class DefaultSubscriptionRegistryTests {
 
 		MultiValueMap<String, String> subscriptions = this.registry.findSubscriptions(createMessage("/foo"));
 		assertThat(subscriptions).isNotNull();
-		assertThat(subscriptions.size()).isEqualTo(2);
+		assertThat(subscriptions).hasSize(2);
 
 		Iterator<Map.Entry<String, List<String>>> iterator = subscriptions.entrySet().iterator();
 		iterator.next();
@@ -426,7 +426,7 @@ public class DefaultSubscriptionRegistryTests {
 
 		MultiValueMap<String, String> allSubscriptions = this.registry.findSubscriptions(createMessage("/foo"));
 		assertThat(allSubscriptions).isNotNull();
-		assertThat(allSubscriptions.size()).isEqualTo(1);
+		assertThat(allSubscriptions).hasSize(1);
 
 		Iterator<String> iteratorValues = allSubscriptions.get("sess1").iterator();
 		iteratorValues.next();
@@ -443,14 +443,14 @@ public class DefaultSubscriptionRegistryTests {
 		this.registry.registerSubscription(subscribeMessage("sess1", "1", "/foo"));
 		this.registry.registerSubscription(subscribeMessage("sess1", "2", "/bar"));
 
-		assertThat(this.registry.findSubscriptions(createMessage("/foo")).size()).isEqualTo(1);
-		assertThat(this.registry.findSubscriptions(createMessage("/bar")).size()).isEqualTo(1);
+		assertThat(this.registry.findSubscriptions(createMessage("/foo"))).hasSize(1);
+		assertThat(this.registry.findSubscriptions(createMessage("/bar"))).hasSize(1);
 
 		this.registry.registerSubscription(subscribeMessage("sess2", "1", "/foo"));
 		this.registry.registerSubscription(subscribeMessage("sess2", "2", "/bar"));
 
-		assertThat(this.registry.findSubscriptions(createMessage("/foo")).size()).isEqualTo(2);
-		assertThat(this.registry.findSubscriptions(createMessage("/bar")).size()).isEqualTo(2);
+		assertThat(this.registry.findSubscriptions(createMessage("/foo"))).hasSize(2);
+		assertThat(this.registry.findSubscriptions(createMessage("/bar"))).hasSize(2);
 	}
 
 	private Message<?> createMessage(String destination) {

spring-messaging/src/test/java/org/springframework/messaging/simp/broker/SimpleBrokerMessageHandlerTests.java

@@ -230,7 +230,7 @@ public class SimpleBrokerMessageHandlerTests {
 
 		verify(this.clientOutChannel, atLeast(2)).send(this.messageCaptor.capture());
 		List<Message<?>> messages = this.messageCaptor.getAllValues();
-		assertThat(messages.size()).isEqualTo(2);
+		assertThat(messages).hasSize(2);
 
 		MessageHeaders headers = messages.get(0).getHeaders();
 		assertThat(headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER)).isEqualTo(SimpMessageType.CONNECT_ACK);
@@ -261,7 +261,7 @@ public class SimpleBrokerMessageHandlerTests {
 
 		verify(this.clientOutChannel, times(2)).send(this.messageCaptor.capture());
 		List<Message<?>> messages = this.messageCaptor.getAllValues();
-		assertThat(messages.size()).isEqualTo(2);
+		assertThat(messages).hasSize(2);
 
 		MessageHeaders headers = messages.get(0).getHeaders();
 		assertThat(headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER)).isEqualTo(SimpMessageType.CONNECT_ACK);
@@ -292,7 +292,7 @@ public class SimpleBrokerMessageHandlerTests {
 
 		verify(this.clientOutChannel, times(1)).send(this.messageCaptor.capture());
 		List<Message<?>> messages = this.messageCaptor.getAllValues();
-		assertThat(messages.size()).isEqualTo(1);
+		assertThat(messages).hasSize(1);
 		assertThat(messages.get(0).getHeaders().get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER)).isEqualTo(SimpMessageType.CONNECT_ACK);
 	}
 

spring-messaging/src/test/java/org/springframework/messaging/simp/config/MessageBrokerConfigurationTests.java

@@ -97,7 +97,7 @@ public class MessageBrokerConfigurationTests {
 		TestChannel channel = context.getBean("clientInboundChannel", TestChannel.class);
 		Set<MessageHandler> handlers = channel.getSubscribers();
 
-		assertThat(handlers.size()).isEqualTo(3);
+		assertThat(handlers).hasSize(3);
 		assertThat(handlers.contains(context.getBean(SimpAnnotationMethodMessageHandler.class))).isTrue();
 		assertThat(handlers.contains(context.getBean(UserDestinationMessageHandler.class))).isTrue();
 		assertThat(handlers.contains(context.getBean(SimpleBrokerMessageHandler.class))).isTrue();
@@ -110,7 +110,7 @@ public class MessageBrokerConfigurationTests {
 		TestChannel channel = context.getBean("clientInboundChannel", TestChannel.class);
 		Set<MessageHandler> handlers = channel.getSubscribers();
 
-		assertThat(handlers.size()).isEqualTo(3);
+		assertThat(handlers).hasSize(3);
 		assertThat(handlers.contains(context.getBean(SimpAnnotationMethodMessageHandler.class))).isTrue();
 		assertThat(handlers.contains(context.getBean(UserDestinationMessageHandler.class))).isTrue();
 		assertThat(handlers.contains(context.getBean(StompBrokerRelayMessageHandler.class))).isTrue();
@@ -122,7 +122,7 @@ public class MessageBrokerConfigurationTests {
 
 		AbstractSubscribableChannel channel = context.getBean(
 				"clientInboundChannel", AbstractSubscribableChannel.class);
-		assertThat(channel.getInterceptors().size()).isEqualTo(3);
+		assertThat(channel.getInterceptors()).hasSize(3);
 
 		CustomThreadPoolTaskExecutor taskExecutor = context.getBean(
 				"clientInboundChannelExecutor", CustomThreadPoolTaskExecutor.class);
@@ -196,7 +196,7 @@ public class MessageBrokerConfigurationTests {
 		AbstractSubscribableChannel channel = context.getBean(
 				"clientOutboundChannel", AbstractSubscribableChannel.class);
 
-		assertThat(channel.getInterceptors().size()).isEqualTo(4);
+		assertThat(channel.getInterceptors()).hasSize(4);
 
 		ThreadPoolTaskExecutor taskExecutor = context.getBean(
 				"clientOutboundChannelExecutor", ThreadPoolTaskExecutor.class);
@@ -217,7 +217,7 @@ public class MessageBrokerConfigurationTests {
 		TestChannel channel = context.getBean("brokerChannel", TestChannel.class);
 		Set<MessageHandler> handlers = channel.getSubscribers();
 
-		assertThat(handlers.size()).isEqualTo(2);
+		assertThat(handlers).hasSize(2);
 		assertThat(handlers.contains(context.getBean(UserDestinationMessageHandler.class))).isTrue();
 		assertThat(handlers.contains(context.getBean(SimpleBrokerMessageHandler.class))).isTrue();
 
@@ -231,7 +231,7 @@ public class MessageBrokerConfigurationTests {
 		TestChannel channel = context.getBean("brokerChannel", TestChannel.class);
 		Set<MessageHandler> handlers = channel.getSubscribers();
 
-		assertThat(handlers.size()).isEqualTo(2);
+		assertThat(handlers).hasSize(2);
 		assertThat(handlers.contains(context.getBean(UserDestinationMessageHandler.class))).isTrue();
 		assertThat(handlers.contains(context.getBean(StompBrokerRelayMessageHandler.class))).isTrue();
 	}
@@ -267,7 +267,7 @@ public class MessageBrokerConfigurationTests {
 		AbstractSubscribableChannel channel = context.getBean(
 				"brokerChannel", AbstractSubscribableChannel.class);
 
-		assertThat(channel.getInterceptors().size()).isEqualTo(4);
+		assertThat(channel.getInterceptors()).hasSize(4);
 
 		ThreadPoolTaskExecutor taskExecutor = context.getBean(
 				"brokerChannelExecutor", ThreadPoolTaskExecutor.class);
@@ -359,11 +359,11 @@ public class MessageBrokerConfigurationTests {
 				context.getBean(SimpAnnotationMethodMessageHandler.class);
 
 		List<HandlerMethodArgumentResolver> customResolvers = handler.getCustomArgumentResolvers();
-		assertThat(customResolvers.size()).isEqualTo(1);
+		assertThat(customResolvers).hasSize(1);
 		assertThat(handler.getArgumentResolvers().contains(customResolvers.get(0))).isTrue();
 
 		List<HandlerMethodReturnValueHandler> customHandlers = handler.getCustomReturnValueHandlers();
-		assertThat(customHandlers.size()).isEqualTo(1);
+		assertThat(customHandlers).hasSize(1);
 		assertThat(handler.getReturnValueHandlers().contains(customHandlers.get(0))).isTrue();
 	}
 
@@ -461,7 +461,7 @@ public class MessageBrokerConfigurationTests {
 
 		StompBrokerRelayMessageHandler relay = context.getBean(StompBrokerRelayMessageHandler.class);
 		assertThat(relay.getSystemSubscriptions()).isNotNull();
-		assertThat(relay.getSystemSubscriptions().size()).isEqualTo(2);
+		assertThat(relay.getSystemSubscriptions()).hasSize(2);
 		assertThat(relay.getSystemSubscriptions().get("/topic/unresolved-user-destination")).isSameAs(handler1);
 		assertThat(relay.getSystemSubscriptions().get("/topic/simp-user-registry")).isSameAs(handler2);
 	}
@@ -517,7 +517,7 @@ public class MessageBrokerConfigurationTests {
 		message = MessageBuilder.createMessage("123".getBytes(), headers.getMessageHeaders());
 		inChannel.send(message);
 
-		assertThat(outChannel.messages.size()).isEqualTo(2);
+		assertThat(outChannel.messages).hasSize(2);
 		Message<?> outputMessage = outChannel.messages.remove(1);
 		headers = StompHeaderAccessor.wrap(outputMessage);
 
@@ -534,7 +534,7 @@ public class MessageBrokerConfigurationTests {
 		accessor.setSessionId("sess1");
 		template.convertAndSendToUser("sess1", "queue.q1", "456".getBytes(), accessor.getMessageHeaders());
 
-		assertThat(outChannel.messages.size()).isEqualTo(1);
+		assertThat(outChannel.messages).hasSize(1);
 		outputMessage = outChannel.messages.remove(0);
 		headers = StompHeaderAccessor.wrap(outputMessage);
 

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

@@ -45,7 +45,7 @@ public class BufferingStompDecoderTests {
 		String chunk = "SEND\na:alpha\n\nMessage body\0";
 
 		List<Message<byte[]>> messages = stompDecoder.decode(toByteBuffer(chunk));
-		assertThat(messages.size()).isEqualTo(1);
+		assertThat(messages).hasSize(1);
 		assertThat(new String(messages.get(0).getPayload())).isEqualTo("Message body");
 
 		assertThat(stompDecoder.getBufferSize()).isEqualTo(0);
@@ -62,7 +62,7 @@ public class BufferingStompDecoderTests {
 		assertThat(messages).isEqualTo(Collections.<Message<byte[]>>emptyList());
 
 		messages = stompDecoder.decode(toByteBuffer(chunk2));
-		assertThat(messages.size()).isEqualTo(1);
+		assertThat(messages).hasSize(1);
 		assertThat(new String(messages.get(0).getPayload())).isEqualTo("Message body");
 
 		assertThat(stompDecoder.getBufferSize()).isEqualTo(0);
@@ -75,7 +75,7 @@ public class BufferingStompDecoderTests {
 		String chunk = "SEND\na:alpha\n\nPayload1\0" + "SEND\na:alpha\n\nPayload2\0";
 		List<Message<byte[]>> messages = stompDecoder.decode(toByteBuffer(chunk));
 
-		assertThat(messages.size()).isEqualTo(2);
+		assertThat(messages).hasSize(2);
 		assertThat(new String(messages.get(0).getPayload())).isEqualTo("Payload1");
 		assertThat(new String(messages.get(1).getPayload())).isEqualTo("Payload2");
 
@@ -90,7 +90,7 @@ public class BufferingStompDecoderTests {
 		String chunk1 = "SEND\na:alpha\n\nPayload1\0SEND\ncontent-length:" + contentLength + "\n";
 		List<Message<byte[]>> messages = stompDecoder.decode(toByteBuffer(chunk1));
 
-		assertThat(messages.size()).isEqualTo(1);
+		assertThat(messages).hasSize(1);
 		assertThat(new String(messages.get(0).getPayload())).isEqualTo("Payload1");
 
 		assertThat(stompDecoder.getBufferSize()).isEqualTo(23);
@@ -99,14 +99,14 @@ public class BufferingStompDecoderTests {
 		String chunk2 = "\nPayload2a";
 		messages = stompDecoder.decode(toByteBuffer(chunk2));
 
-		assertThat(messages.size()).isEqualTo(0);
+		assertThat(messages).hasSize(0);
 		assertThat(stompDecoder.getBufferSize()).isEqualTo(33);
 		assertThat((int) stompDecoder.getExpectedContentLength()).isEqualTo(contentLength);
 
 		String chunk3 = "-Payload2b\0";
 		messages = stompDecoder.decode(toByteBuffer(chunk3));
 
-		assertThat(messages.size()).isEqualTo(1);
+		assertThat(messages).hasSize(1);
 		assertThat(new String(messages.get(0).getPayload())).isEqualTo("Payload2a-Payload2b");
 		assertThat(stompDecoder.getBufferSize()).isEqualTo(0);
 		assertThat(stompDecoder.getExpectedContentLength()).isNull();
@@ -118,7 +118,7 @@ public class BufferingStompDecoderTests {
 		String chunk1 = "SEND\na:alpha\n\nPayload1\0SEND\na:alpha\n";
 		List<Message<byte[]>> messages = stompDecoder.decode(toByteBuffer(chunk1));
 
-		assertThat(messages.size()).isEqualTo(1);
+		assertThat(messages).hasSize(1);
 		assertThat(new String(messages.get(0).getPayload())).isEqualTo("Payload1");
 
 		assertThat(stompDecoder.getBufferSize()).isEqualTo(13);
@@ -127,14 +127,14 @@ public class BufferingStompDecoderTests {
 		String chunk2 = "\nPayload2a";
 		messages = stompDecoder.decode(toByteBuffer(chunk2));
 
-		assertThat(messages.size()).isEqualTo(0);
+		assertThat(messages).hasSize(0);
 		assertThat(stompDecoder.getBufferSize()).isEqualTo(23);
 		assertThat(stompDecoder.getExpectedContentLength()).isNull();
 
 		String chunk3 = "-Payload2b\0";
 		messages = stompDecoder.decode(toByteBuffer(chunk3));
 
-		assertThat(messages.size()).isEqualTo(1);
+		assertThat(messages).hasSize(1);
 		assertThat(new String(messages.get(0).getPayload())).isEqualTo("Payload2a-Payload2b");
 		assertThat(stompDecoder.getBufferSize()).isEqualTo(0);
 		assertThat(stompDecoder.getExpectedContentLength()).isNull();
@@ -171,7 +171,7 @@ public class BufferingStompDecoderTests {
 		String chunk = "MESSAG";
 
 		List<Message<byte[]>> messages = stompDecoder.decode(toByteBuffer(chunk));
-		assertThat(messages.size()).isEqualTo(0);
+		assertThat(messages).hasSize(0);
 	}
 
 	// SPR-13416
@@ -182,7 +182,7 @@ public class BufferingStompDecoderTests {
 		String chunk = "SEND\na:long\\";
 
 		List<Message<byte[]>> messages = stompDecoder.decode(toByteBuffer(chunk));
-		assertThat(messages.size()).isEqualTo(0);
+		assertThat(messages).hasSize(0);
 	}
 
 	@Test

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

@@ -597,7 +597,7 @@ public class DefaultStompSessionTests {
 		assertThat(received.get()).isNotNull();
 		assertThat(received.get()).isTrue();
 		assertThat(receivedHeaders.get()).isNotNull();
-		assertThat(receivedHeaders.get().get("foo").size()).isEqualTo(1);
+		assertThat(receivedHeaders.get().get("foo")).hasSize(1);
 		assertThat(receivedHeaders.get().get("foo").get(0)).isEqualTo("bar");
 	}
 
@@ -628,7 +628,7 @@ public class DefaultStompSessionTests {
 		assertThat(received.get()).isNotNull();
 		assertThat(received.get()).isTrue();
 		assertThat(receivedHeaders.get()).isNotNull();
-		assertThat(receivedHeaders.get().get("foo").size()).isEqualTo(1);
+		assertThat(receivedHeaders.get().get("foo")).hasSize(1);
 		assertThat(receivedHeaders.get().get("foo").get(0)).isEqualTo("bar");
 	}
 
@@ -688,7 +688,7 @@ public class DefaultStompSessionTests {
 		StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
 		headers = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
 		assertThat(headers.size()).as(headers.toString()).isEqualTo(1);
-		assertThat(headers.get("foo").size()).isEqualTo(1);
+		assertThat(headers.get("foo")).hasSize(1);
 		assertThat(headers.get("foo").get(0)).isEqualTo("bar");
 
 		assertThat(this.session.isConnected()).isFalse();

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

@@ -92,7 +92,7 @@ class StompBrokerRelayMessageHandlerTests {
 		this.brokerRelay.start();
 		this.brokerRelay.handleMessage(connectMessage("sess1", "joe"));
 
-		assertThat(this.tcpClient.getSentMessages().size()).isEqualTo(2);
+		assertThat(this.tcpClient.getSentMessages()).hasSize(2);
 
 		StompHeaderAccessor headers1 = this.tcpClient.getSentHeaders(0);
 		assertThat(headers1.getCommand()).isEqualTo(StompCommand.CONNECT);
@@ -116,7 +116,7 @@ class StompBrokerRelayMessageHandlerTests {
 		this.brokerRelay.start();
 		this.brokerRelay.handleMessage(connectMessage("sess1", "joe"));
 
-		assertThat(this.tcpClient.getSentMessages().size()).isEqualTo(2);
+		assertThat(this.tcpClient.getSentMessages()).hasSize(2);
 
 		StompHeaderAccessor headers1 = this.tcpClient.getSentHeaders(0);
 		assertThat(headers1.getCommand()).isEqualTo(StompCommand.CONNECT);
@@ -143,7 +143,7 @@ class StompBrokerRelayMessageHandlerTests {
 		accessor.setDestination("/user/daisy/foo");
 		this.brokerRelay.handleMessage(MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders()));
 
-		assertThat(this.tcpClient.getSentMessages().size()).isEqualTo(2);
+		assertThat(this.tcpClient.getSentMessages()).hasSize(2);
 		StompHeaderAccessor headers = this.tcpClient.getSentHeaders(0);
 		assertThat(headers.getCommand()).isEqualTo(StompCommand.CONNECT);
 		assertThat(headers.getSessionId()).isEqualTo(StompBrokerRelayMessageHandler.SYSTEM_SESSION_ID);
@@ -174,7 +174,7 @@ class StompBrokerRelayMessageHandlerTests {
 		accessor.setDestination("/user/daisy/foo");
 		this.brokerRelay.handleMessage(MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders()));
 
-		assertThat(this.tcpClient.getSentMessages().size()).isEqualTo(3);
+		assertThat(this.tcpClient.getSentMessages()).hasSize(3);
 		assertThat(this.tcpClient.getSentHeaders(2).getMessageType()).isEqualTo(SimpMessageType.HEARTBEAT);
 	}
 
@@ -184,7 +184,7 @@ class StompBrokerRelayMessageHandlerTests {
 		this.brokerRelay.start();
 		this.brokerRelay.handleMessage(connectMessage("sess1", "joe"));
 
-		assertThat(this.tcpClient.getSentMessages().size()).isEqualTo(2);
+		assertThat(this.tcpClient.getSentMessages()).hasSize(2);
 		assertThat(this.tcpClient.getSentHeaders(0).getCommand()).isEqualTo(StompCommand.CONNECT);
 		assertThat(this.tcpClient.getSentHeaders(1).getCommand()).isEqualTo(StompCommand.CONNECT);
 
@@ -247,7 +247,7 @@ class StompBrokerRelayMessageHandlerTests {
 		MessageHeaders headers = accessor.getMessageHeaders();
 		this.tcpClient.handleMessage(MessageBuilder.createMessage(new byte[0], headers));
 
-		assertThat(this.tcpClient.getSentMessages().size()).isEqualTo(2);
+		assertThat(this.tcpClient.getSentMessages()).hasSize(2);
 		assertThat(this.tcpClient.getSentHeaders(0).getCommand()).isEqualTo(StompCommand.CONNECT);
 		assertThat(this.tcpClient.getSentHeaders(1).getCommand()).isEqualTo(StompCommand.SUBSCRIBE);
 		assertThat(this.tcpClient.getSentHeaders(1).getDestination()).isEqualTo("/topic/foo");
@@ -268,7 +268,7 @@ class StompBrokerRelayMessageHandlerTests {
 		Message<byte[]> connect = connectMessage("sess1", "joe");
 		this.brokerRelay.handleMessage(connect);
 
-		assertThat(this.tcpClient.getSentMessages().size()).isEqualTo(2);
+		assertThat(this.tcpClient.getSentMessages()).hasSize(2);
 
 		StompHeaderAccessor headers1 = this.tcpClient.getSentHeaders(0);
 		assertThat(headers1.getCommand()).isEqualTo(StompCommand.CONNECT);
@@ -280,7 +280,7 @@ class StompBrokerRelayMessageHandlerTests {
 
 		this.brokerRelay.handleMessage(connect);
 
-		assertThat(this.tcpClient.getSentMessages().size()).isEqualTo(2);
+		assertThat(this.tcpClient.getSentMessages()).hasSize(2);
 		assertThat(this.outboundChannel.getMessages()).isEmpty();
 	}
 

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

@@ -45,7 +45,7 @@ public class StompDecoderTests {
 		StompHeaderAccessor headers = StompHeaderAccessor.wrap(frame);
 
 		assertThat(headers.getCommand()).isEqualTo(StompCommand.DISCONNECT);
-		assertThat(headers.toNativeHeaderMap().size()).isEqualTo(0);
+		assertThat(headers.toNativeHeaderMap()).hasSize(0);
 		assertThat(frame.getPayload().length).isEqualTo(0);
 	}
 
@@ -55,7 +55,7 @@ public class StompDecoderTests {
 		StompHeaderAccessor headers = StompHeaderAccessor.wrap(frame);
 
 		assertThat(headers.getCommand()).isEqualTo(StompCommand.DISCONNECT);
-		assertThat(headers.toNativeHeaderMap().size()).isEqualTo(0);
+		assertThat(headers.toNativeHeaderMap()).hasSize(0);
 		assertThat(frame.getPayload().length).isEqualTo(0);
 	}
 
@@ -69,7 +69,7 @@ public class StompDecoderTests {
 
 		assertThat(headers.getCommand()).isEqualTo(StompCommand.CONNECT);
 
-		assertThat(headers.toNativeHeaderMap().size()).isEqualTo(2);
+		assertThat(headers.toNativeHeaderMap()).hasSize(2);
 		assertThat(headers.getFirstNativeHeader("accept-version")).isEqualTo("1.1");
 		assertThat(headers.getHost()).isEqualTo("github.org");
 
@@ -97,7 +97,7 @@ public class StompDecoderTests {
 
 		assertThat(headers.getCommand()).isEqualTo(StompCommand.SEND);
 
-		assertThat(headers.toNativeHeaderMap().size()).isEqualTo(1);
+		assertThat(headers.toNativeHeaderMap()).hasSize(1);
 		assertThat(headers.getContentLength()).isEqualTo(Integer.valueOf(23));
 
 		String bodyText = new String(message.getPayload());
@@ -113,7 +113,7 @@ public class StompDecoderTests {
 
 		assertThat(headers.getCommand()).isEqualTo(StompCommand.SEND);
 
-		assertThat(headers.toNativeHeaderMap().size()).isEqualTo(1);
+		assertThat(headers.toNativeHeaderMap()).hasSize(1);
 		assertThat(headers.getContentLength()).isEqualTo(Integer.valueOf(-1));
 
 		String bodyText = new String(message.getPayload());
@@ -127,7 +127,7 @@ public class StompDecoderTests {
 
 		assertThat(headers.getCommand()).isEqualTo(StompCommand.SEND);
 
-		assertThat(headers.toNativeHeaderMap().size()).isEqualTo(1);
+		assertThat(headers.toNativeHeaderMap()).hasSize(1);
 		assertThat(headers.getContentLength()).isEqualTo(Integer.valueOf(0));
 
 		String bodyText = new String(frame.getPayload());
@@ -141,7 +141,7 @@ public class StompDecoderTests {
 
 		assertThat(headers.getCommand()).isEqualTo(StompCommand.SEND);
 
-		assertThat(headers.toNativeHeaderMap().size()).isEqualTo(1);
+		assertThat(headers.toNativeHeaderMap()).hasSize(1);
 		assertThat(headers.getContentLength()).isEqualTo(Integer.valueOf(23));
 
 		String bodyText = new String(frame.getPayload());
@@ -155,7 +155,7 @@ public class StompDecoderTests {
 
 		assertThat(headers.getCommand()).isEqualTo(StompCommand.DISCONNECT);
 
-		assertThat(headers.toNativeHeaderMap().size()).isEqualTo(1);
+		assertThat(headers.toNativeHeaderMap()).hasSize(1);
 		assertThat(headers.getFirstNativeHeader("a:\r\n\\b")).isEqualTo("alpha:bravo\r\n\\");
 	}
 
@@ -169,7 +169,7 @@ public class StompDecoderTests {
 
 		assertThat(headers.getCommand()).isEqualTo(StompCommand.CONNECT);
 
-		assertThat(headers.toNativeHeaderMap().size()).isEqualTo(2);
+		assertThat(headers.toNativeHeaderMap()).hasSize(2);
 		assertThat(headers.getFirstNativeHeader("accept-version")).isEqualTo("1.1");
 		assertThat(headers.getFirstNativeHeader("key")).isEqualTo("\\value");
 
@@ -189,7 +189,7 @@ public class StompDecoderTests {
 
 		final List<Message<byte[]>> messages = decoder.decode(buffer);
 
-		assertThat(messages.size()).isEqualTo(1);
+		assertThat(messages).hasSize(1);
 		assertThat(StompHeaderAccessor.wrap(messages.get(0)).getCommand()).isEqualTo(StompCommand.SEND);
 	}
 
@@ -201,7 +201,7 @@ public class StompDecoderTests {
 
 		final List<Message<byte[]>> messages = decoder.decode(buffer);
 
-		assertThat(messages.size()).isEqualTo(2);
+		assertThat(messages).hasSize(2);
 		assertThat(StompHeaderAccessor.wrap(messages.get(0)).getCommand()).isEqualTo(StompCommand.SEND);
 		assertThat(StompHeaderAccessor.wrap(messages.get(1)).getCommand()).isEqualTo(StompCommand.DISCONNECT);
 	}
@@ -216,7 +216,7 @@ public class StompDecoderTests {
 
 		assertThat(headers.getCommand()).isEqualTo(StompCommand.CONNECT);
 
-		assertThat(headers.toNativeHeaderMap().size()).isEqualTo(2);
+		assertThat(headers.toNativeHeaderMap()).hasSize(2);
 		assertThat(headers.getFirstNativeHeader("accept-version")).isEqualTo("1.1");
 		assertThat(headers.getFirstNativeHeader("key")).isEqualTo("");
 
@@ -272,7 +272,7 @@ public class StompDecoderTests {
 
 		final List<Message<byte[]>> messages = decoder.decode(buffer);
 
-		assertThat(messages.size()).isEqualTo(1);
+		assertThat(messages).hasSize(1);
 		assertThat(StompHeaderAccessor.wrap(messages.get(0)).getMessageType()).isEqualTo(SimpMessageType.HEARTBEAT);
 	}
 

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

@@ -123,7 +123,7 @@ public class StompHeaderAccessorTests {
 
 		Map<String, List<String>> actual = headers.toNativeHeaderMap();
 
-		assertThat(actual.size()).isEqualTo(2);
+		assertThat(actual).hasSize(2);
 		assertThat(actual.get(StompHeaderAccessor.STOMP_ID_HEADER).get(0)).isEqualTo("s1");
 		assertThat(actual.get(StompHeaderAccessor.STOMP_DESTINATION_HEADER).get(0)).isEqualTo("/d");
 	}
@@ -135,7 +135,7 @@ public class StompHeaderAccessorTests {
 
 		Map<String, List<String>> actual = headers.toNativeHeaderMap();
 
-		assertThat(actual.size()).isEqualTo(1);
+		assertThat(actual).hasSize(1);
 		assertThat(actual.get(StompHeaderAccessor.STOMP_ID_HEADER).get(0)).isEqualTo("s1");
 	}
 
@@ -193,7 +193,7 @@ public class StompHeaderAccessorTests {
 		headers.setNativeHeader("accountId", accountId.toLowerCase());
 
 		Map<String, List<String>> actual = headers.toNativeHeaderMap();
-		assertThat(actual.size()).isEqualTo(3);
+		assertThat(actual).hasSize(3);
 
 		assertThat(actual.get(StompHeaderAccessor.STOMP_ID_HEADER).get(0)).isEqualTo("s1");
 		assertThat(actual.get(StompHeaderAccessor.STOMP_DESTINATION_HEADER).get(0)).isEqualTo("/d");

spring-messaging/src/test/java/org/springframework/messaging/simp/user/DefaultUserDestinationResolverTests.java

@@ -66,7 +66,7 @@ public class DefaultUserDestinationResolverTests {
 		UserDestinationResult actual = this.resolver.resolveDestination(message);
 
 		assertThat(actual.getSourceDestination()).isEqualTo(sourceDestination);
-		assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
+		assertThat(actual.getTargetDestinations()).hasSize(1);
 		assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("/queue/foo-user123");
 		assertThat(actual.getSubscribeDestination()).isEqualTo(sourceDestination);
 		assertThat(actual.getUser()).isEqualTo(user.getName());
@@ -81,7 +81,7 @@ public class DefaultUserDestinationResolverTests {
 		Message<?> message = createMessage(SimpMessageType.SUBSCRIBE, user, "123", destination);
 		UserDestinationResult actual = this.resolver.resolveDestination(message);
 
-		assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
+		assertThat(actual.getTargetDestinations()).hasSize(1);
 		assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("jms.queue.call-user123");
 		assertThat(actual.getSubscribeDestination()).isEqualTo(destination);
 	}
@@ -97,7 +97,7 @@ public class DefaultUserDestinationResolverTests {
 		Message<?> message = createMessage(SimpMessageType.SUBSCRIBE, user, "456", "/user/queue/foo");
 		UserDestinationResult actual = this.resolver.resolveDestination(message);
 
-		assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
+		assertThat(actual.getTargetDestinations()).hasSize(1);
 		assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("/queue/foo-user456");
 	}
 
@@ -108,7 +108,7 @@ public class DefaultUserDestinationResolverTests {
 		UserDestinationResult actual = this.resolver.resolveDestination(message);
 
 		assertThat(actual.getSourceDestination()).isEqualTo(sourceDestination);
-		assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
+		assertThat(actual.getTargetDestinations()).hasSize(1);
 		assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo(("/queue/foo-user" + "123"));
 		assertThat(actual.getSubscribeDestination()).isEqualTo(sourceDestination);
 		assertThat(actual.getUser()).isNull();
@@ -129,7 +129,7 @@ public class DefaultUserDestinationResolverTests {
 		Message<?> message = createMessage(SimpMessageType.UNSUBSCRIBE, user, "123", "/user/queue/foo");
 		UserDestinationResult actual = this.resolver.resolveDestination(message);
 
-		assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
+		assertThat(actual.getTargetDestinations()).hasSize(1);
 		assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("/queue/foo-user123");
 	}
 
@@ -141,7 +141,7 @@ public class DefaultUserDestinationResolverTests {
 		UserDestinationResult actual = this.resolver.resolveDestination(message);
 
 		assertThat(actual.getSourceDestination()).isEqualTo(sourceDestination);
-		assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
+		assertThat(actual.getTargetDestinations()).hasSize(1);
 		assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("/queue/foo-user123");
 		assertThat(actual.getSubscribeDestination()).isEqualTo("/user/queue/foo");
 		assertThat(actual.getUser()).isEqualTo(user.getName());
@@ -156,7 +156,7 @@ public class DefaultUserDestinationResolverTests {
 		Message<?> message = createMessage(SimpMessageType.MESSAGE, user, "123", destination);
 		UserDestinationResult actual = this.resolver.resolveDestination(message);
 
-		assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
+		assertThat(actual.getTargetDestinations()).hasSize(1);
 		assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("jms.queue.call-user123");
 		assertThat(actual.getSubscribeDestination()).isEqualTo("/user/jms.queue.call");
 	}
@@ -176,7 +176,7 @@ public class DefaultUserDestinationResolverTests {
 		UserDestinationResult actual = this.resolver.resolveDestination(message);
 
 		assertThat(actual.getSourceDestination()).isEqualTo(sourceDestination);
-		assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
+		assertThat(actual.getTargetDestinations()).hasSize(1);
 		assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("/queue/foo-user456");
 		assertThat(actual.getSubscribeDestination()).isEqualTo("/user/queue/foo");
 		assertThat(actual.getUser()).isEqualTo(otherUser.getName());
@@ -195,7 +195,7 @@ public class DefaultUserDestinationResolverTests {
 		Message<?> message = createMessage(SimpMessageType.MESSAGE, new TestPrincipal("joe"), null, destination);
 		UserDestinationResult actual = this.resolver.resolveDestination(message);
 
-		assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
+		assertThat(actual.getTargetDestinations()).hasSize(1);
 		assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("/queue/foo-useropenid123");
 	}
 
@@ -206,7 +206,7 @@ public class DefaultUserDestinationResolverTests {
 		UserDestinationResult actual = this.resolver.resolveDestination(message);
 
 		assertThat(actual.getSourceDestination()).isEqualTo(sourceDestination);
-		assertThat(actual.getTargetDestinations().size()).isEqualTo(1);
+		assertThat(actual.getTargetDestinations()).hasSize(1);
 		assertThat(actual.getTargetDestinations().iterator().next()).isEqualTo("/queue/foo-user123");
 		assertThat(actual.getSubscribeDestination()).isEqualTo("/user/queue/foo");
 		assertThat(actual.getUser()).isNull();

spring-messaging/src/test/java/org/springframework/messaging/simp/user/MultiServerUserRegistryTests.java

@@ -78,12 +78,12 @@ class MultiServerUserRegistryTests {
 		SimpUser user = this.registry.getUser("joe");
 		assertThat(user).isNotNull();
 		assertThat(user.hasSessions()).isTrue();
-		assertThat(user.getSessions().size()).isEqualTo(1);
+		assertThat(user.getSessions()).hasSize(1);
 		SimpSession session = user.getSession("remote-sess");
 		assertThat(session).isNotNull();
 		assertThat(session.getId()).isEqualTo("remote-sess");
 		assertThat(session.getUser()).isSameAs(user);
-		assertThat(session.getSubscriptions().size()).isEqualTo(1);
+		assertThat(session.getSubscriptions()).hasSize(1);
 		SimpSubscription subscription = session.getSubscriptions().iterator().next();
 		assertThat(subscription.getId()).isEqualTo("remote-sub");
 		assertThat(subscription.getSession()).isSameAs(session);
@@ -115,7 +115,7 @@ class MultiServerUserRegistryTests {
 
 		assertThat(this.registry.getUserCount()).isEqualTo(3);
 		Set<SimpSubscription> matches = this.registry.findSubscriptions(s -> s.getDestination().equals("/match"));
-		assertThat(matches.size()).isEqualTo(2);
+		assertThat(matches).hasSize(2);
 		Iterator<SimpSubscription> iterator = matches.iterator();
 		Set<String> sessionIds = new HashSet<>(2);
 		sessionIds.add(iterator.next().getSession().getId());
@@ -147,13 +147,13 @@ class MultiServerUserRegistryTests {
 		assertThat(this.registry.getUserCount()).isEqualTo(1);
 		SimpUser user = this.registry.getUsers().iterator().next();
 		assertThat(user.hasSessions()).isTrue();
-		assertThat(user.getSessions().size()).isEqualTo(2);
+		assertThat(user.getSessions()).hasSize(2);
 		assertThat(user.getSessions()).containsExactlyInAnyOrder(localSession, remoteSession);
 		assertThat(user.getSession("sess123")).isSameAs(localSession);
 		assertThat(user.getSession("sess456")).isEqualTo(remoteSession);
 
 		user = this.registry.getUser("joe");
-		assertThat(user.getSessions().size()).isEqualTo(2);
+		assertThat(user.getSessions()).hasSize(2);
 		assertThat(user.getSessions()).containsExactlyInAnyOrder(localSession, remoteSession);
 		assertThat(user.getSession("sess123")).isSameAs(localSession);
 		assertThat(user.getSession("sess456")).isEqualTo(remoteSession);

spring-messaging/src/test/java/org/springframework/messaging/support/ChannelInterceptorTests.java

@@ -60,7 +60,7 @@ public class ChannelInterceptorTests {
 		this.channel.addInterceptor(interceptor);
 		this.channel.send(MessageBuilder.withPayload("test").build());
 
-		assertThat(this.messageHandler.getMessages().size()).isEqualTo(1);
+		assertThat(this.messageHandler.getMessages()).hasSize(1);
 		Message<?> result = this.messageHandler.getMessages().get(0);
 
 		assertThat(result).isNotNull();
@@ -79,7 +79,7 @@ public class ChannelInterceptorTests {
 
 		assertThat(interceptor1.getCounter().get()).isEqualTo(1);
 		assertThat(interceptor2.getCounter().get()).isEqualTo(1);
-		assertThat(this.messageHandler.getMessages().size()).isEqualTo(0);
+		assertThat(this.messageHandler.getMessages()).hasSize(0);
 		assertThat(interceptor1.wasAfterCompletionInvoked()).isTrue();
 		assertThat(interceptor2.wasAfterCompletionInvoked()).isFalse();
 	}

spring-messaging/src/test/java/org/springframework/messaging/support/MessageHeaderAccessorTests.java

@@ -44,7 +44,7 @@ public class MessageHeaderAccessorTests {
 	@Test
 	public void newEmptyHeaders() {
 		MessageHeaderAccessor accessor = new MessageHeaderAccessor();
-		assertThat(accessor.toMap().size()).isEqualTo(0);
+		assertThat(accessor.toMap()).hasSize(0);
 	}
 
 	@Test
@@ -57,7 +57,7 @@ public class MessageHeaderAccessorTests {
 		MessageHeaderAccessor accessor = new MessageHeaderAccessor(message);
 		MessageHeaders actual = accessor.getMessageHeaders();
 
-		assertThat(actual.size()).isEqualTo(3);
+		assertThat(actual).hasSize(3);
 		assertThat(actual.get("foo")).isEqualTo("bar");
 		assertThat(actual.get("bar")).isEqualTo("baz");
 	}
@@ -75,7 +75,7 @@ public class MessageHeaderAccessorTests {
 		accessor.setHeader("foo", "BAR");
 		MessageHeaders actual = accessor.getMessageHeaders();
 
-		assertThat(actual.size()).isEqualTo(3);
+		assertThat(actual).hasSize(3);
 		assertThat(actual.getId()).isNotEqualTo(message.getHeaders().getId());
 		assertThat(actual.get("foo")).isEqualTo("BAR");
 		assertThat(actual.get("bar")).isEqualTo("baz");
@@ -110,7 +110,7 @@ public class MessageHeaderAccessorTests {
 		accessor.removeHeaders("fo*");
 
 		MessageHeaders actual = accessor.getMessageHeaders();
-		assertThat(actual.size()).isEqualTo(2);
+		assertThat(actual).hasSize(2);
 		assertThat(actual.get("foo")).isNull();
 		assertThat(actual.get("bar")).isEqualTo("baz");
 	}
@@ -128,7 +128,7 @@ public class MessageHeaderAccessorTests {
 		accessor.copyHeaders(map2);
 
 		MessageHeaders actual = accessor.getMessageHeaders();
-		assertThat(actual.size()).isEqualTo(3);
+		assertThat(actual).hasSize(3);
 		assertThat(actual.get("foo")).isEqualTo("BAR");
 		assertThat(actual.get("bar")).isEqualTo("baz");
 	}
@@ -146,7 +146,7 @@ public class MessageHeaderAccessorTests {
 		accessor.copyHeadersIfAbsent(map2);
 
 		MessageHeaders actual = accessor.getMessageHeaders();
-		assertThat(actual.size()).isEqualTo(3);
+		assertThat(actual).hasSize(3);
 		assertThat(actual.get("foo")).isEqualTo("bar");
 		assertThat(actual.get("bar")).isEqualTo("baz");
 	}
@@ -157,7 +157,7 @@ public class MessageHeaderAccessorTests {
 		headers.copyHeaders(null);
 		headers.copyHeadersIfAbsent(null);
 
-		assertThat(headers.getMessageHeaders().size()).isEqualTo(1);
+		assertThat(headers.getMessageHeaders()).hasSize(1);
 		assertThat(headers.getMessageHeaders().keySet()).isEqualTo(Collections.singleton("id"));
 	}
 
@@ -174,9 +174,9 @@ public class MessageHeaderAccessorTests {
 		accessor.setHeader("foo", "bar3");
 		Map<String, Object> map3 = accessor.toMap();
 
-		assertThat(map1.size()).isEqualTo(1);
-		assertThat(map2.size()).isEqualTo(1);
-		assertThat(map3.size()).isEqualTo(1);
+		assertThat(map1).hasSize(1);
+		assertThat(map2).hasSize(1);
+		assertThat(map3).hasSize(1);
 
 		assertThat(map1.get("foo")).isEqualTo("bar1");
 		assertThat(map2.get("foo")).isEqualTo("bar2");

spring-messaging/src/test/java/org/springframework/messaging/support/NativeMessageHeaderAccessorTests.java

@@ -67,7 +67,7 @@ public class NativeMessageHeaderAccessorTests {
 		NativeMessageHeaderAccessor headerAccessor = new NativeMessageHeaderAccessor(message);
 		Map<String, Object> actual = headerAccessor.toMap();
 
-		assertThat(actual.size()).isEqualTo(2);
+		assertThat(actual).hasSize(2);
 		assertThat(actual.get("a")).isEqualTo("b");
 		assertThat(actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS)).isNotNull();
 		assertThat(actual.get(NativeMessageHeaderAccessor.NATIVE_HEADERS)).isEqualTo(inputNativeHeaders);
@@ -79,7 +79,7 @@ public class NativeMessageHeaderAccessorTests {
 		NativeMessageHeaderAccessor headerAccessor = new NativeMessageHeaderAccessor((Message<?>) null);
 
 		Map<String, Object> actual = headerAccessor.toMap();
-		assertThat(actual.size()).isEqualTo(0);
+		assertThat(actual).hasSize(0);
 
 		Map<String, List<String>> actualNativeHeaders = headerAccessor.toNativeHeaderMap();
 		assertThat(actualNativeHeaders).isEqualTo(Collections.emptyMap());
@@ -104,7 +104,7 @@ public class NativeMessageHeaderAccessorTests {
 
 		Map<String, Object> actual = headerAccessor.toMap();
 
-		assertThat(actual.size()).isEqualTo(2);
+		assertThat(actual).hasSize(2);
 		assertThat(actual.get("a")).isEqualTo("B");
 
 		@SuppressWarnings("unchecked")