Replace assertThat(x.get(i)). with assertThat(x).element(i).

Search for   : assertThat\((.+)\.get\((\d+)\)\)\.
Replace with : assertThat($1).element($2).

Closes gh-31759

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

@@ -354,8 +354,8 @@ public class ProxyFactoryTests {
 		list.add(proxy1);
 		list.add(proxy2);
 		AnnotationAwareOrderComparator.sort(list);
-		assertThat(list.get(0)).isSameAs(proxy2);
-		assertThat(list.get(1)).isSameAs(proxy1);
+		assertThat(list).element(0).isSameAs(proxy2);
+		assertThat(list).element(1).isSameAs(proxy1);
 	}
 
 	@Test
@@ -370,8 +370,8 @@ public class ProxyFactoryTests {
 		list.add(proxy1);
 		list.add(proxy2);
 		AnnotationAwareOrderComparator.sort(list);
-		assertThat(list.get(0)).isSameAs(proxy2);
-		assertThat(list.get(1)).isSameAs(proxy1);
+		assertThat(list).element(0).isSameAs(proxy2);
+		assertThat(list).element(1).isSameAs(proxy1);
 	}
 
 	@Test

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

@@ -414,7 +414,7 @@ abstract class AbstractPropertyAccessorTests {
 		Map<String, String> map = new HashMap<>();
 		map.put("favoriteNumber", "9");
 		accessor.setPropertyValue("list[0]", map);
-		assertThat(target.list.get(0)).isEqualTo(map);
+		assertThat(target.list).element(0).isEqualTo(map);
 	}
 
 	@Test

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

@@ -126,7 +126,7 @@ public class BeanWrapperAutoGrowingTests {
 	public void getPropertyValueAutoGrowList() {
 		assertNotNull(wrapper.getPropertyValue("list[0]"));
 		assertThat(bean.getList()).hasSize(1);
-		assertThat(bean.getList().get(0)).isInstanceOf(Bean.class);
+		assertThat(bean.getList()).element(0).isInstanceOf(Bean.class);
 	}
 
 	@Test
@@ -139,11 +139,11 @@ public class BeanWrapperAutoGrowingTests {
 	public void getPropertyValueAutoGrowListBySeveralElements() {
 		assertNotNull(wrapper.getPropertyValue("list[4]"));
 		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);
-		assertThat(bean.getList().get(3)).isInstanceOf(Bean.class);
-		assertThat(bean.getList().get(4)).isInstanceOf(Bean.class);
+		assertThat(bean.getList()).element(0).isInstanceOf(Bean.class);
+		assertThat(bean.getList()).element(1).isInstanceOf(Bean.class);
+		assertThat(bean.getList()).element(2).isInstanceOf(Bean.class);
+		assertThat(bean.getList()).element(3).isInstanceOf(Bean.class);
+		assertThat(bean.getList()).element(4).isInstanceOf(Bean.class);
 		assertNotNull(wrapper.getPropertyValue("list[0]"));
 		assertNotNull(wrapper.getPropertyValue("list[1]"));
 		assertNotNull(wrapper.getPropertyValue("list[2]"));
@@ -161,8 +161,8 @@ public class BeanWrapperAutoGrowingTests {
 	@Test
 	public void getPropertyValueAutoGrowMultiDimensionalList() {
 		assertNotNull(wrapper.getPropertyValue("multiList[0][0]"));
-		assertThat(bean.getMultiList().get(0)).hasSize(1);
-		assertThat(bean.getMultiList().get(0).get(0)).isInstanceOf(Bean.class);
+		assertThat(bean.getMultiList()).element(0).asList().hasSize(1);
+		assertThat(bean.getMultiList().get(0)).element(0).isInstanceOf(Bean.class);
 	}
 
 	@Test

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

@@ -94,8 +94,8 @@ class BeanWrapperGenericsTests {
 		input.add("http://localhost:8080");
 		input.add("http://localhost:9090");
 		bw.setPropertyValue("resourceList", input);
-		assertThat(gb.getResourceList().get(0)).isEqualTo(new UrlResource("http://localhost:8080"));
-		assertThat(gb.getResourceList().get(1)).isEqualTo(new UrlResource("http://localhost:9090"));
+		assertThat(gb.getResourceList()).element(0).isEqualTo(new UrlResource("http://localhost:8080"));
+		assertThat(gb.getResourceList()).element(1).isEqualTo(new UrlResource("http://localhost:9090"));
 	}
 
 	@Test
@@ -104,7 +104,7 @@ class BeanWrapperGenericsTests {
 		gb.setResourceList(new ArrayList<>());
 		BeanWrapper bw = new BeanWrapperImpl(gb);
 		bw.setPropertyValue("resourceList[0]", "http://localhost:8080");
-		assertThat(gb.getResourceList().get(0)).isEqualTo(new UrlResource("http://localhost:8080"));
+		assertThat(gb.getResourceList()).element(0).isEqualTo(new UrlResource("http://localhost:8080"));
 	}
 
 	@Test
@@ -201,7 +201,7 @@ class BeanWrapperGenericsTests {
 		BeanWrapper bw = new BeanWrapperImpl(gb);
 		bw.setPropertyValue("listOfLists[0][0]", 5);
 		assertThat(bw.getPropertyValue("listOfLists[0][0]")).isEqualTo(5);
-		assertThat(gb.getListOfLists().get(0).get(0)).isEqualTo(5);
+		assertThat(gb.getListOfLists().get(0)).element(0).isEqualTo(5);
 	}
 
 	@Test
@@ -213,7 +213,7 @@ class BeanWrapperGenericsTests {
 		BeanWrapper bw = new BeanWrapperImpl(gb);
 		bw.setPropertyValue("listOfLists[0][0]", "5");
 		assertThat(bw.getPropertyValue("listOfLists[0][0]")).isEqualTo(5);
-		assertThat(gb.getListOfLists().get(0).get(0)).isEqualTo(5);
+		assertThat(gb.getListOfLists().get(0)).element(0).isEqualTo(5);
 	}
 
 	@Test
@@ -298,7 +298,7 @@ class BeanWrapperGenericsTests {
 		BeanWrapper bw = new BeanWrapperImpl(gb);
 		bw.setPropertyValue("mapOfLists[1][0]", 5);
 		assertThat(bw.getPropertyValue("mapOfLists[1][0]")).isEqualTo(5);
-		assertThat(gb.getMapOfLists().get(1).get(0)).isEqualTo(5);
+		assertThat(gb.getMapOfLists().get(1)).element(0).isEqualTo(5);
 	}
 
 	@Test
@@ -310,7 +310,7 @@ class BeanWrapperGenericsTests {
 		BeanWrapper bw = new BeanWrapperImpl(gb);
 		bw.setPropertyValue("mapOfLists[1][0]", "5");
 		assertThat(bw.getPropertyValue("mapOfLists[1][0]")).isEqualTo(5);
-		assertThat(gb.getMapOfLists().get(1).get(0)).isEqualTo(5);
+		assertThat(gb.getMapOfLists().get(1)).element(0).isEqualTo(5);
 	}
 
 	@Test
@@ -516,8 +516,8 @@ class BeanWrapperGenericsTests {
 		bw.setPropertyValue("genericProperty", "10");
 		bw.setPropertyValue("genericListProperty", new String[] {"20", "30"});
 		assertThat(gb.getGenericProperty()).isEqualTo(10);
-		assertThat(gb.getGenericListProperty().get(0)).isEqualTo(20);
-		assertThat(gb.getGenericListProperty().get(1)).isEqualTo(30);
+		assertThat(gb.getGenericListProperty()).element(0).isEqualTo(20);
+		assertThat(gb.getGenericListProperty()).element(1).isEqualTo(30);
 	}
 
 	@Test

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

@@ -2238,9 +2238,9 @@ class DefaultListableBeanFactoryTests {
 		ObjectProvider<TestBean> testBeanProvider = lbf.getBeanProvider(ResolvableType.forClass(TestBean.class));
 		List<TestBean> resolved = testBeanProvider.orderedStream().toList();
 		assertThat(resolved.size()).isEqualTo(3);
-		assertThat(resolved.get(0)).isSameAs(lbf.getBean("highPriorityTestBean"));
-		assertThat(resolved.get(1)).isSameAs(lbf.getBean("lowPriorityTestBean"));
-		assertThat(resolved.get(2)).isSameAs(lbf.getBean("plainTestBean"));
+		assertThat(resolved).element(0).isSameAs(lbf.getBean("highPriorityTestBean"));
+		assertThat(resolved).element(1).isSameAs(lbf.getBean("lowPriorityTestBean"));
+		assertThat(resolved).element(2).isSameAs(lbf.getBean("plainTestBean"));
 	}
 
 	@Test

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

@@ -569,14 +569,14 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
 		assertThat(bean.getNestedTestBeans()).hasSize(2);
-		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb1);
-		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb2);
+		assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb1);
+		assertThat(bean.getNestedTestBeans()).element(1).isSameAs(ntb2);
 		assertThat(bean.nestedTestBeansSetter).hasSize(2);
-		assertThat(bean.nestedTestBeansSetter.get(0)).isSameAs(ntb1);
-		assertThat(bean.nestedTestBeansSetter.get(1)).isSameAs(ntb2);
+		assertThat(bean.nestedTestBeansSetter).element(0).isSameAs(ntb1);
+		assertThat(bean.nestedTestBeansSetter).element(1).isSameAs(ntb2);
 		assertThat(bean.nestedTestBeansField).hasSize(2);
-		assertThat(bean.nestedTestBeansField.get(0)).isSameAs(ntb1);
-		assertThat(bean.nestedTestBeansField.get(1)).isSameAs(ntb2);
+		assertThat(bean.nestedTestBeansField).element(0).isSameAs(ntb1);
+		assertThat(bean.nestedTestBeansField).element(1).isSameAs(ntb2);
 	}
 
 	@Test
@@ -600,11 +600,11 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
 		assertThat(bean.getNestedTestBeans()).hasSize(1);
-		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb1);
+		assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansSetter).hasSize(1);
-		assertThat(bean.nestedTestBeansSetter.get(0)).isSameAs(ntb1);
+		assertThat(bean.nestedTestBeansSetter).element(0).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansField).hasSize(1);
-		assertThat(bean.nestedTestBeansField.get(0)).isSameAs(ntb1);
+		assertThat(bean.nestedTestBeansField).element(0).isSameAs(ntb1);
 	}
 
 	@Test
@@ -712,14 +712,14 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
 		assertThat(bean.getNestedTestBeans()).hasSize(2);
-		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb2);
-		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb1);
+		assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb2);
+		assertThat(bean.getNestedTestBeans()).element(1).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansSetter).hasSize(2);
-		assertThat(bean.nestedTestBeansSetter.get(0)).isSameAs(ntb2);
-		assertThat(bean.nestedTestBeansSetter.get(1)).isSameAs(ntb1);
+		assertThat(bean.nestedTestBeansSetter).element(0).isSameAs(ntb2);
+		assertThat(bean.nestedTestBeansSetter).element(1).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansField).hasSize(2);
-		assertThat(bean.nestedTestBeansField.get(0)).isSameAs(ntb2);
-		assertThat(bean.nestedTestBeansField.get(1)).isSameAs(ntb1);
+		assertThat(bean.nestedTestBeansField).element(0).isSameAs(ntb2);
+		assertThat(bean.nestedTestBeansField).element(1).isSameAs(ntb1);
 	}
 
 	@Test
@@ -745,14 +745,14 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getIndexedTestBean()).isSameAs(itb);
 		assertThat(bean.getNestedTestBeans()).hasSize(2);
-		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb2);
-		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb1);
+		assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb2);
+		assertThat(bean.getNestedTestBeans()).element(1).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansSetter).hasSize(2);
-		assertThat(bean.nestedTestBeansSetter.get(0)).isSameAs(ntb2);
-		assertThat(bean.nestedTestBeansSetter.get(1)).isSameAs(ntb1);
+		assertThat(bean.nestedTestBeansSetter).element(0).isSameAs(ntb2);
+		assertThat(bean.nestedTestBeansSetter).element(1).isSameAs(ntb1);
 		assertThat(bean.nestedTestBeansField).hasSize(2);
-		assertThat(bean.nestedTestBeansField.get(0)).isSameAs(ntb2);
-		assertThat(bean.nestedTestBeansField.get(1)).isSameAs(ntb1);
+		assertThat(bean.nestedTestBeansField).element(0).isSameAs(ntb2);
+		assertThat(bean.nestedTestBeansField).element(1).isSameAs(ntb1);
 	}
 
 	@Test
@@ -1055,7 +1055,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isNull();
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getNestedTestBeans()).hasSize(1);
-		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb2);
+		assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb2);
 
 		Map<String, NestedTestBean> map = bf.getBeansOfType(NestedTestBean.class);
 		assertThat(map.get("nestedTestBean1")).isNull();
@@ -1077,8 +1077,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isNull();
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getNestedTestBeans()).hasSize(2);
-		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb1);
-		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb2);
+		assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb1);
+		assertThat(bean.getNestedTestBeans()).element(1).isSameAs(ntb2);
 	}
 
 	@Test
@@ -1113,8 +1113,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isNull();
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getNestedTestBeans()).hasSize(2);
-		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb2);
-		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb1);
+		assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb2);
+		assertThat(bean.getNestedTestBeans()).element(1).isSameAs(ntb1);
 	}
 
 	@Test
@@ -1130,8 +1130,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		SingleConstructorVarargBean bean = bf.getBean("annotatedBean", SingleConstructorVarargBean.class);
 		assertThat(bean.getTestBean()).isSameAs(tb);
 		assertThat(bean.getNestedTestBeans()).hasSize(2);
-		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb2);
-		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb1);
+		assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb2);
+		assertThat(bean.getNestedTestBeans()).element(1).isSameAs(ntb1);
 	}
 
 	@Test
@@ -1159,8 +1159,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		SingleConstructorRequiredCollectionBean bean = bf.getBean("annotatedBean", SingleConstructorRequiredCollectionBean.class);
 		assertThat(bean.getTestBean()).isSameAs(tb);
 		assertThat(bean.getNestedTestBeans()).hasSize(2);
-		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb2);
-		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb1);
+		assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb2);
+		assertThat(bean.getNestedTestBeans()).element(1).isSameAs(ntb1);
 	}
 
 	@Test
@@ -1188,8 +1188,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		SingleConstructorOptionalCollectionBean bean = bf.getBean("annotatedBean", SingleConstructorOptionalCollectionBean.class);
 		assertThat(bean.getTestBean()).isSameAs(tb);
 		assertThat(bean.getNestedTestBeans()).hasSize(2);
-		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb2);
-		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb1);
+		assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb2);
+		assertThat(bean.getNestedTestBeans()).element(1).isSameAs(ntb1);
 	}
 
 	@Test
@@ -1501,7 +1501,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		SelfInjectionBean bean2 = bf.getBean("annotatedBean2", SelfInjectionBean.class);
 		assertThat(bean.reference).isSameAs(bean2);
 		assertThat(bean.referenceCollection).hasSize(1);
-		assertThat(bean.referenceCollection.get(0)).isSameAs(bean2);
+		assertThat(bean.referenceCollection).element(0).isSameAs(bean2);
 	}
 
 	@Test
@@ -1522,7 +1522,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		SelfInjectionCollectionBean bean2 = bf.getBean("annotatedBean2", SelfInjectionCollectionBean.class);
 		assertThat(bean.reference).isSameAs(bean2);
 		assertThat(bean2.referenceCollection).hasSize(1);
-		assertThat(bean.referenceCollection.get(0)).isSameAs(bean2);
+		assertThat(bean.referenceCollection).element(0).isSameAs(bean2);
 	}
 
 	@Test
@@ -1690,20 +1690,20 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 
 		List<?> testBeans = bean.iterateTestBeans();
 		assertThat(testBeans).hasSize(2);
-		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean1"));
-		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean2"));
+		assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean1"));
+		assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean2"));
 		testBeans = bean.forEachTestBeans();
 		assertThat(testBeans).hasSize(2);
-		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean1"));
-		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean2"));
+		assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean1"));
+		assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean2"));
 		testBeans = bean.streamTestBeans();
 		assertThat(testBeans).hasSize(2);
-		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean1"));
-		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean2"));
+		assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean1"));
+		assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean2"));
 		testBeans = bean.sortedTestBeans();
 		assertThat(testBeans).hasSize(2);
-		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean1"));
-		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean2"));
+		assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean1"));
+		assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean2"));
 	}
 
 	@Test
@@ -1728,20 +1728,20 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 
 		List<?> testBeans = bean.iterateTestBeans();
 		assertThat(testBeans).hasSize(2);
-		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean1"));
-		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean2"));
+		assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean1"));
+		assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean2"));
 		testBeans = bean.forEachTestBeans();
 		assertThat(testBeans).hasSize(2);
-		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean1"));
-		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean2"));
+		assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean1"));
+		assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean2"));
 		testBeans = bean.streamTestBeans();
 		assertThat(testBeans).hasSize(2);
-		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean1"));
-		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean2"));
+		assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean1"));
+		assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean2"));
 		testBeans = bean.sortedTestBeans();
 		assertThat(testBeans).hasSize(2);
-		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean2"));
-		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean1"));
+		assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean2"));
+		assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean1"));
 	}
 
 	@Test
@@ -1759,8 +1759,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		ObjectProviderInjectionBean bean = bf.getBean("annotatedBean", ObjectProviderInjectionBean.class);
 		List<?> testBeans = bean.sortedTestBeans();
 		assertThat(testBeans).hasSize(2);
-		assertThat(testBeans.get(0)).isSameAs(bf.getBean("testBean2"));
-		assertThat(testBeans.get(1)).isSameAs(bf.getBean("testBean1"));
+		assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean2"));
+		assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean1"));
 	}
 
 	@Test
@@ -1988,8 +1988,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerArray[0]).isSameAs(iv);
 		assertThat(bean.stringList).hasSize(1);
 		assertThat(bean.integerList).hasSize(1);
-		assertThat(bean.stringList.get(0)).isSameAs(sv);
-		assertThat(bean.integerList.get(0)).isSameAs(iv);
+		assertThat(bean.stringList).element(0).isSameAs(sv);
+		assertThat(bean.integerList).element(0).isSameAs(iv);
 		assertThat(bean.stringMap).hasSize(1);
 		assertThat(bean.integerMap).hasSize(1);
 		assertThat(bean.stringMap.get("stringValue")).isSameAs(sv);
@@ -2002,8 +2002,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerRepositoryArray[0]).isSameAs(ir);
 		assertThat(bean.stringRepositoryList).hasSize(1);
 		assertThat(bean.integerRepositoryList).hasSize(1);
-		assertThat(bean.stringRepositoryList.get(0)).isSameAs(sr);
-		assertThat(bean.integerRepositoryList.get(0)).isSameAs(ir);
+		assertThat(bean.stringRepositoryList).element(0).isSameAs(sr);
+		assertThat(bean.integerRepositoryList).element(0).isSameAs(ir);
 		assertThat(bean.stringRepositoryMap).hasSize(1);
 		assertThat(bean.integerRepositoryMap).hasSize(1);
 		assertThat(bean.stringRepositoryMap.get("stringRepo")).isSameAs(sr);
@@ -2034,8 +2034,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerArray[0]).isSameAs(iv);
 		assertThat(bean.stringList).hasSize(1);
 		assertThat(bean.integerList).hasSize(1);
-		assertThat(bean.stringList.get(0)).isSameAs(sv);
-		assertThat(bean.integerList.get(0)).isSameAs(iv);
+		assertThat(bean.stringList).element(0).isSameAs(sv);
+		assertThat(bean.integerList).element(0).isSameAs(iv);
 		assertThat(bean.stringMap).hasSize(1);
 		assertThat(bean.integerMap).hasSize(1);
 		assertThat(bean.stringMap.get("stringValue")).isSameAs(sv);
@@ -2048,8 +2048,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerRepositoryArray[0]).isSameAs(ir);
 		assertThat(bean.stringRepositoryList).hasSize(1);
 		assertThat(bean.integerRepositoryList).hasSize(1);
-		assertThat(bean.stringRepositoryList.get(0)).isSameAs(sr);
-		assertThat(bean.integerRepositoryList.get(0)).isSameAs(ir);
+		assertThat(bean.stringRepositoryList).element(0).isSameAs(sr);
+		assertThat(bean.integerRepositoryList).element(0).isSameAs(ir);
 		assertThat(bean.stringRepositoryMap).hasSize(1);
 		assertThat(bean.integerRepositoryMap).hasSize(1);
 		assertThat(bean.stringRepositoryMap.get("stringRepo")).isSameAs(sr);
@@ -2076,8 +2076,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerRepositoryArray[0]).isSameAs(ir);
 		assertThat(bean.stringRepositoryList).hasSize(1);
 		assertThat(bean.integerRepositoryList).hasSize(1);
-		assertThat(bean.stringRepositoryList.get(0)).isSameAs(sr);
-		assertThat(bean.integerRepositoryList.get(0)).isSameAs(ir);
+		assertThat(bean.stringRepositoryList).element(0).isSameAs(sr);
+		assertThat(bean.integerRepositoryList).element(0).isSameAs(ir);
 		assertThat(bean.stringRepositoryMap).hasSize(1);
 		assertThat(bean.integerRepositoryMap).hasSize(1);
 		assertThat(bean.stringRepositoryMap.get("stringRepo")).isSameAs(sr);
@@ -2116,8 +2116,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerRepositoryArray[0]).isSameAs(ir);
 		assertThat(bean.stringRepositoryList).hasSize(1);
 		assertThat(bean.integerRepositoryList).hasSize(1);
-		assertThat(bean.stringRepositoryList.get(0)).isSameAs(sr);
-		assertThat(bean.integerRepositoryList.get(0)).isSameAs(ir);
+		assertThat(bean.stringRepositoryList).element(0).isSameAs(sr);
+		assertThat(bean.integerRepositoryList).element(0).isSameAs(ir);
 		assertThat(bean.stringRepositoryMap).hasSize(1);
 		assertThat(bean.integerRepositoryMap).hasSize(1);
 		assertThat(bean.stringRepositoryMap.get("stringRepo")).isSameAs(sr);
@@ -2143,8 +2143,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.stringRepositoryArray[0]).isSameAs(repo);
 		assertThat(bean.repositoryList).hasSize(1);
 		assertThat(bean.stringRepositoryList).hasSize(1);
-		assertThat(bean.repositoryList.get(0)).isSameAs(repo);
-		assertThat(bean.stringRepositoryList.get(0)).isSameAs(repo);
+		assertThat(bean.repositoryList).element(0).isSameAs(repo);
+		assertThat(bean.stringRepositoryList).element(0).isSameAs(repo);
 		assertThat(bean.repositoryMap).hasSize(1);
 		assertThat(bean.stringRepositoryMap).hasSize(1);
 		assertThat(bean.repositoryMap.get("repo")).isSameAs(repo);
@@ -2201,8 +2201,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.stringRepositoryArray[0]).isSameAs(repo);
 		assertThat(bean.repositoryList).hasSize(1);
 		assertThat(bean.stringRepositoryList).hasSize(1);
-		assertThat(bean.repositoryList.get(0)).isSameAs(repo);
-		assertThat(bean.stringRepositoryList.get(0)).isSameAs(repo);
+		assertThat(bean.repositoryList).element(0).isSameAs(repo);
+		assertThat(bean.stringRepositoryList).element(0).isSameAs(repo);
 		assertThat(bean.repositoryMap).hasSize(1);
 		assertThat(bean.stringRepositoryMap).hasSize(1);
 		assertThat(bean.repositoryMap.get("repo")).isSameAs(repo);
@@ -2232,8 +2232,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.stringRepositoryArray[0]).isSameAs(repo);
 		assertThat(bean.repositoryList).hasSize(1);
 		assertThat(bean.stringRepositoryList).hasSize(1);
-		assertThat(bean.repositoryList.get(0)).isSameAs(repo);
-		assertThat(bean.stringRepositoryList.get(0)).isSameAs(repo);
+		assertThat(bean.repositoryList).element(0).isSameAs(repo);
+		assertThat(bean.stringRepositoryList).element(0).isSameAs(repo);
 		assertThat(bean.repositoryMap).hasSize(1);
 		assertThat(bean.stringRepositoryMap).hasSize(1);
 		assertThat(bean.repositoryMap.get("repo")).isSameAs(repo);
@@ -2272,8 +2272,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerArray[0]).isSameAs(iv);
 		assertThat(bean.stringList).hasSize(1);
 		assertThat(bean.integerList).hasSize(1);
-		assertThat(bean.stringList.get(0)).isSameAs(sv);
-		assertThat(bean.integerList.get(0)).isSameAs(iv);
+		assertThat(bean.stringList).element(0).isSameAs(sv);
+		assertThat(bean.integerList).element(0).isSameAs(iv);
 		assertThat(bean.stringMap).hasSize(1);
 		assertThat(bean.integerMap).hasSize(1);
 		assertThat(bean.stringMap.get("stringValue")).isSameAs(sv);
@@ -2286,8 +2286,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerRepositoryArray[0]).isSameAs(ir);
 		assertThat(bean.stringRepositoryList).hasSize(1);
 		assertThat(bean.integerRepositoryList).hasSize(1);
-		assertThat(bean.stringRepositoryList.get(0)).isSameAs(sr);
-		assertThat(bean.integerRepositoryList.get(0)).isSameAs(ir);
+		assertThat(bean.stringRepositoryList).element(0).isSameAs(sr);
+		assertThat(bean.integerRepositoryList).element(0).isSameAs(ir);
 		assertThat(bean.stringRepositoryMap).hasSize(1);
 		assertThat(bean.integerRepositoryMap).hasSize(1);
 		assertThat(bean.stringRepositoryMap.get("stringRepo")).isSameAs(sr);
@@ -2318,8 +2318,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerArray[0]).isSameAs(iv);
 		assertThat(bean.stringList).hasSize(1);
 		assertThat(bean.integerList).hasSize(1);
-		assertThat(bean.stringList.get(0)).isSameAs(sv);
-		assertThat(bean.integerList.get(0)).isSameAs(iv);
+		assertThat(bean.stringList).element(0).isSameAs(sv);
+		assertThat(bean.integerList).element(0).isSameAs(iv);
 		assertThat(bean.stringMap).hasSize(1);
 		assertThat(bean.integerMap).hasSize(1);
 		assertThat(bean.stringMap.get("stringValue")).isSameAs(sv);
@@ -2332,8 +2332,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerRepositoryArray[0]).isSameAs(ir);
 		assertThat(bean.stringRepositoryList).hasSize(1);
 		assertThat(bean.integerRepositoryList).hasSize(1);
-		assertThat(bean.stringRepositoryList.get(0)).isSameAs(sr);
-		assertThat(bean.integerRepositoryList.get(0)).isSameAs(ir);
+		assertThat(bean.stringRepositoryList).element(0).isSameAs(sr);
+		assertThat(bean.integerRepositoryList).element(0).isSameAs(ir);
 		assertThat(bean.stringRepositoryMap).hasSize(1);
 		assertThat(bean.integerRepositoryMap).hasSize(1);
 		assertThat(bean.stringRepositoryMap.get("stringRepo")).isSameAs(sr);
@@ -2359,8 +2359,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerRepositoryArray[0]).isSameAs(ir);
 		assertThat(bean.stringRepositoryList).hasSize(1);
 		assertThat(bean.integerRepositoryList).hasSize(1);
-		assertThat(bean.stringRepositoryList.get(0)).isSameAs(sr);
-		assertThat(bean.integerRepositoryList.get(0)).isSameAs(ir);
+		assertThat(bean.stringRepositoryList).element(0).isSameAs(sr);
+		assertThat(bean.integerRepositoryList).element(0).isSameAs(ir);
 		assertThat(bean.stringRepositoryMap).hasSize(1);
 		assertThat(bean.integerRepositoryMap).hasSize(1);
 		assertThat(bean.stringRepositoryMap.get("stringRepo")).isSameAs(sr);
@@ -2385,8 +2385,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerRepositoryArray[0]).isSameAs(gr);
 		assertThat(bean.stringRepositoryList).hasSize(1);
 		assertThat(bean.integerRepositoryList).hasSize(1);
-		assertThat(bean.stringRepositoryList.get(0)).isSameAs(gr);
-		assertThat(bean.integerRepositoryList.get(0)).isSameAs(gr);
+		assertThat(bean.stringRepositoryList).element(0).isSameAs(gr);
+		assertThat(bean.integerRepositoryList).element(0).isSameAs(gr);
 		assertThat(bean.stringRepositoryMap).hasSize(1);
 		assertThat(bean.integerRepositoryMap).hasSize(1);
 		assertThat(bean.stringRepositoryMap.get("genericRepo")).isSameAs(gr);
@@ -2410,8 +2410,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerRepositoryArray[0]).isSameAs(ngr);
 		assertThat(bean.stringRepositoryList).hasSize(1);
 		assertThat(bean.integerRepositoryList).hasSize(1);
-		assertThat(bean.stringRepositoryList.get(0)).isSameAs(ngr);
-		assertThat(bean.integerRepositoryList.get(0)).isSameAs(ngr);
+		assertThat(bean.stringRepositoryList).element(0).isSameAs(ngr);
+		assertThat(bean.integerRepositoryList).element(0).isSameAs(ngr);
 		assertThat(bean.stringRepositoryMap).hasSize(1);
 		assertThat(bean.integerRepositoryMap).hasSize(1);
 		assertThat(bean.stringRepositoryMap.get("simpleRepo")).isSameAs(ngr);
@@ -2438,8 +2438,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerRepositoryArray[0]).isSameAs(gr);
 		assertThat(bean.stringRepositoryList).hasSize(1);
 		assertThat(bean.integerRepositoryList).hasSize(1);
-		assertThat(bean.stringRepositoryList.get(0)).isSameAs(sr);
-		assertThat(bean.integerRepositoryList.get(0)).isSameAs(gr);
+		assertThat(bean.stringRepositoryList).element(0).isSameAs(sr);
+		assertThat(bean.integerRepositoryList).element(0).isSameAs(gr);
 		assertThat(bean.stringRepositoryMap).hasSize(1);
 		assertThat(bean.integerRepositoryMap).hasSize(1);
 		assertThat(bean.stringRepositoryMap.get("stringRepo")).isSameAs(sr);
@@ -2465,8 +2465,8 @@ public class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.integerRepositoryArray[0]).isSameAs(ngr);
 		assertThat(bean.stringRepositoryList).hasSize(1);
 		assertThat(bean.integerRepositoryList).hasSize(1);
-		assertThat(bean.stringRepositoryList.get(0)).isSameAs(sr);
-		assertThat(bean.integerRepositoryList.get(0)).isSameAs(ngr);
+		assertThat(bean.stringRepositoryList).element(0).isSameAs(sr);
+		assertThat(bean.integerRepositoryList).element(0).isSameAs(ngr);
 		assertThat(bean.stringRepositoryMap).hasSize(1);
 		assertThat(bean.integerRepositoryMap).hasSize(1);
 		assertThat(bean.stringRepositoryMap.get("stringRepo")).isSameAs(sr);

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

@@ -195,8 +195,8 @@ public class InjectAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean3()).isNull();
 		assertThat(bean.getTestBean4()).isSameAs(tb);
 		assertThat(bean.getNestedTestBeans()).hasSize(2);
-		assertThat(bean.getNestedTestBeans().get(0)).isSameAs(ntb1);
-		assertThat(bean.getNestedTestBeans().get(1)).isSameAs(ntb2);
+		assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb1);
+		assertThat(bean.getNestedTestBeans()).element(1).isSameAs(ntb2);
 	}
 
 	@Test
@@ -530,7 +530,7 @@ public class InjectAnnotationBeanPostProcessorTests {
 
 		OptionalListFieldInjectionBean bean = (OptionalListFieldInjectionBean) bf.getBean("annotatedBean");
 		assertThat(bean.getTestBean()).isPresent();
-		assertThat(bean.getTestBean().get().get(0)).isSameAs(bf.getBean("testBean"));
+		assertThat(bean.getTestBean().get()).element(0).isSameAs(bf.getBean("testBean"));
 	}
 
 	@Test
@@ -548,7 +548,7 @@ public class InjectAnnotationBeanPostProcessorTests {
 
 		OptionalListMethodInjectionBean bean = (OptionalListMethodInjectionBean) bf.getBean("annotatedBean");
 		assertThat(bean.getTestBean()).isPresent();
-		assertThat(bean.getTestBean().get().get(0)).isSameAs(bf.getBean("testBean"));
+		assertThat(bean.getTestBean().get()).element(0).isSameAs(bf.getBean("testBean"));
 	}
 
 	@Test

spring-beans/src/test/java/org/springframework/beans/factory/aot/BeanDefinitionPropertiesCodeGeneratorTests.java

@@ -258,10 +258,10 @@ class BeanDefinitionPropertiesCodeGeneratorTests {
 		compile((actual, compiled) -> {
 			ConstructorArgumentValues argumentValues = actual.getConstructorArgumentValues();
 			List<ValueHolder> values = argumentValues.getGenericArgumentValues();
-			assertThat(values.get(0)).satisfies(assertValueHolder(String.class, null, null));
-			assertThat(values.get(1)).satisfies(assertValueHolder(2, Long.class, null));
-			assertThat(values.get(2)).satisfies(assertValueHolder("value", null, "param1"));
-			assertThat(values.get(3)).satisfies(assertValueHolder("another", CharSequence.class, "param2"));
+			assertThat(values).element(0).satisfies(assertValueHolder(String.class, null, null));
+			assertThat(values).element(1).satisfies(assertValueHolder(2, Long.class, null));
+			assertThat(values).element(2).satisfies(assertValueHolder("value", null, "param1"));
+			assertThat(values).element(3).satisfies(assertValueHolder("another", CharSequence.class, "param2"));
 			assertThat(values).hasSize(4);
 			assertThat(argumentValues.getIndexedArgumentValues()).isEmpty();
 		});
@@ -323,7 +323,7 @@ class BeanDefinitionPropertiesCodeGeneratorTests {
 		compile((actual, compiled) -> {
 			Object value = actual.getPropertyValues().get("value");
 			assertThat(value).isInstanceOf(ManagedList.class);
-			assertThat(((List<?>) value).get(0)).isInstanceOf(BeanReference.class);
+			assertThat(((List<?>) value)).element(0).isInstanceOf(BeanReference.class);
 		});
 	}
 
@@ -412,8 +412,8 @@ class BeanDefinitionPropertiesCodeGeneratorTests {
 		this.beanDefinition.addQualifier(new AutowireCandidateQualifier("com.example.Another", ChronoUnit.SECONDS));
 		compile((actual, compiled) -> {
 			List<AutowireCandidateQualifier> qualifiers = new ArrayList<>(actual.getQualifiers());
-			assertThat(qualifiers.get(0)).satisfies(isQualifierFor("com.example.Qualifier", "id"));
-			assertThat(qualifiers.get(1)).satisfies(isQualifierFor("com.example.Another", ChronoUnit.SECONDS));
+			assertThat(qualifiers).element(0).satisfies(isQualifierFor("com.example.Qualifier", "id"));
+			assertThat(qualifiers).element(1).satisfies(isQualifierFor("com.example.Another", ChronoUnit.SECONDS));
 			assertThat(qualifiers).hasSize(2);
 		});
 	}

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

@@ -564,8 +564,8 @@ class BeanFactoryGenericsTests {
 				new ClassPathResource("genericBeanTests.xml", getClass()));
 		GenericIntegerBean gb = (GenericIntegerBean) bf.getBean("integerBean");
 		assertThat(gb.getGenericProperty()).isEqualTo(10);
-		assertThat(gb.getGenericListProperty().get(0)).isEqualTo(20);
-		assertThat(gb.getGenericListProperty().get(1)).isEqualTo(30);
+		assertThat(gb.getGenericListProperty()).element(0).isEqualTo(20);
+		assertThat(gb.getGenericListProperty()).element(1).isEqualTo(30);
 	}
 
 	@Test
@@ -811,18 +811,18 @@ class BeanFactoryGenericsTests {
 			resolved.add(instance);
 		}
 		assertThat(resolved).hasSize(2);
-		assertThat(resolved.get(0)).isSameAs(bf.getBean("store1"));
-		assertThat(resolved.get(1)).isSameAs(bf.getBean("store2"));
+		assertThat(resolved).element(0).isSameAs(bf.getBean("store1"));
+		assertThat(resolved).element(1).isSameAs(bf.getBean("store2"));
 
 		resolved = numberStoreProvider.stream().toList();
 		assertThat(resolved).hasSize(2);
-		assertThat(resolved.get(0)).isSameAs(bf.getBean("store1"));
-		assertThat(resolved.get(1)).isSameAs(bf.getBean("store2"));
+		assertThat(resolved).element(0).isSameAs(bf.getBean("store1"));
+		assertThat(resolved).element(1).isSameAs(bf.getBean("store2"));
 
 		resolved = numberStoreProvider.orderedStream().toList();
 		assertThat(resolved).hasSize(2);
-		assertThat(resolved.get(0)).isSameAs(bf.getBean("store2"));
-		assertThat(resolved.get(1)).isSameAs(bf.getBean("store1"));
+		assertThat(resolved).element(0).isSameAs(bf.getBean("store2"));
+		assertThat(resolved).element(1).isSameAs(bf.getBean("store1"));
 
 		resolved = new ArrayList<>();
 		for (NumberStore<Double> instance : doubleStoreProvider) {
@@ -865,8 +865,8 @@ class BeanFactoryGenericsTests {
 		ObjectProvider<NumberStore<?>> numberStoreProvider = bf.getBeanProvider(ResolvableType.forClass(NumberStore.class));
 		List<NumberStore<?>> resolved = numberStoreProvider.orderedStream().toList();
 		assertThat(resolved).hasSize(2);
-		assertThat(resolved.get(0)).isSameAs(bf.getBean("store2"));
-		assertThat(resolved.get(1)).isSameAs(bf.getBean("store1"));
+		assertThat(resolved).element(0).isSameAs(bf.getBean("store2"));
+		assertThat(resolved).element(1).isSameAs(bf.getBean("store1"));
 	}
 
 

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

@@ -55,9 +55,9 @@ public class CollectionMergingTests {
 		TestBean bean = (TestBean) this.beanFactory.getBean("childWithList");
 		List<?> list = bean.getSomeList();
 		assertThat(list).as("Incorrect size").hasSize(3);
-		assertThat(list.get(0)).isEqualTo("Rob Harrop");
-		assertThat(list.get(1)).isEqualTo("Rod Johnson");
-		assertThat(list.get(2)).isEqualTo("Juergen Hoeller");
+		assertThat(list).element(0).isEqualTo("Rob Harrop");
+		assertThat(list).element(1).isEqualTo("Rod Johnson");
+		assertThat(list).element(2).isEqualTo("Juergen Hoeller");
 	}
 
 	@Test
@@ -127,9 +127,9 @@ public class CollectionMergingTests {
 		TestBean bean = (TestBean) this.beanFactory.getBean("childWithListInConstructor");
 		List<?> list = bean.getSomeList();
 		assertThat(list).as("Incorrect size").hasSize(3);
-		assertThat(list.get(0)).isEqualTo("Rob Harrop");
-		assertThat(list.get(1)).isEqualTo("Rod Johnson");
-		assertThat(list.get(2)).isEqualTo("Juergen Hoeller");
+		assertThat(list).element(0).isEqualTo("Rob Harrop");
+		assertThat(list).element(1).isEqualTo("Rod Johnson");
+		assertThat(list).element(2).isEqualTo("Juergen Hoeller");
 	}
 
 	@Test
@@ -138,7 +138,7 @@ public class CollectionMergingTests {
 		List<?> list = bean.getSomeList();
 		assertThat(list).isNotNull();
 		assertThat(list).hasSize(3);
-		assertThat(list.get(2)).isNotNull();
+		assertThat(list).element(2).isNotNull();
 		assertThat(list.get(2) instanceof TestBean).isTrue();
 	}
 

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

@@ -61,7 +61,7 @@ class EventPublicationTests {
 	void defaultsEventReceived() throws Exception {
 		List<DefaultsDefinition> defaultsList = this.eventListener.getDefaults();
 		assertThat(defaultsList).isNotEmpty();
-		assertThat(defaultsList.get(0)).isInstanceOf(DocumentDefaultsDefinition.class);
+		assertThat(defaultsList).element(0).isInstanceOf(DocumentDefaultsDefinition.class);
 		DocumentDefaultsDefinition defaults = (DocumentDefaultsDefinition) defaultsList.get(0);
 		assertThat(defaults.getLazyInit()).isEqualTo("true");
 		assertThat(defaults.getAutowire()).isEqualTo("constructor");

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

@@ -126,7 +126,7 @@ public class UtilNamespaceHandlerTests {
 	@Test
 	void testSimpleList() {
 		List<?> list = (List) this.beanFactory.getBean("simpleList");
-		assertThat(list.get(0)).isEqualTo("Rob Harrop");
+		assertThat(list).element(0).isEqualTo("Rob Harrop");
 		List<?> list2 = (List) this.beanFactory.getBean("simpleList");
 		assertThat(list).isSameAs(list2);
 	}
@@ -134,9 +134,9 @@ public class UtilNamespaceHandlerTests {
 	@Test
 	void testScopedList() {
 		List<?> list = (List) this.beanFactory.getBean("scopedList");
-		assertThat(list.get(0)).isEqualTo("Rob Harrop");
+		assertThat(list).element(0).isEqualTo("Rob Harrop");
 		List<?> list2 = (List) this.beanFactory.getBean("scopedList");
-		assertThat(list2.get(0)).isEqualTo("Rob Harrop");
+		assertThat(list2).element(0).isEqualTo("Rob Harrop");
 		assertThat(list).isNotSameAs(list2);
 	}
 
@@ -177,7 +177,7 @@ public class UtilNamespaceHandlerTests {
 
 		List<?> list = bean.getSomeList();
 		assertThat(list).hasSize(1);
-		assertThat(list.get(0)).isEqualTo("foo");
+		assertThat(list).element(0).isEqualTo("foo");
 
 		Set<?> set = bean.getSomeSet();
 		assertThat(set).hasSize(1);
@@ -208,7 +208,7 @@ public class UtilNamespaceHandlerTests {
 
 		List<?> list = bean.getSomeList();
 		assertThat(list).hasSize(1);
-		assertThat(list.get(0)).isEqualTo("foo");
+		assertThat(list).element(0).isEqualTo("foo");
 
 		Set<?> set = bean.getSomeSet();
 		assertThat(set).hasSize(1);
@@ -229,7 +229,7 @@ public class UtilNamespaceHandlerTests {
 
 		List<?> list = bean.getSomeList();
 		assertThat(list).hasSize(1);
-		assertThat(list.get(0)).isEqualTo(Integer.MIN_VALUE);
+		assertThat(list).element(0).isEqualTo(Integer.MIN_VALUE);
 
 		Set<?> set = bean.getSomeSet();
 		assertThat(set).hasSize(2);
@@ -255,7 +255,7 @@ public class UtilNamespaceHandlerTests {
 
 		List<?> list = bean.getSomeList();
 		assertThat(list).hasSize(1);
-		assertThat(list.get(0)).isEqualTo(bean);
+		assertThat(list).element(0).isEqualTo(bean);
 
 		Set<?> set = bean.getSomeSet();
 		assertThat(set).hasSize(1);
@@ -274,7 +274,7 @@ public class UtilNamespaceHandlerTests {
 		List<?> list = bean.getSomeList();
 		assertThat(Proxy.isProxyClass(list.getClass())).isTrue();
 		assertThat(list).hasSize(1);
-		assertThat(list.get(0)).isEqualTo(bean);
+		assertThat(list).element(0).isEqualTo(bean);
 
 		Set<?> set = bean.getSomeSet();
 		assertThat(Proxy.isProxyClass(set.getClass())).isFalse();
@@ -295,7 +295,7 @@ public class UtilNamespaceHandlerTests {
 		List<?> list = bean.getSomeList();
 		assertThat(Proxy.isProxyClass(list.getClass())).isFalse();
 		assertThat(list).hasSize(1);
-		assertThat(list.get(0)).isEqualTo(bean);
+		assertThat(list).element(0).isEqualTo(bean);
 
 		Set<?> set = bean.getSomeSet();
 		assertThat(Proxy.isProxyClass(set.getClass())).isTrue();
@@ -316,7 +316,7 @@ public class UtilNamespaceHandlerTests {
 		List<?> list = bean.getSomeList();
 		assertThat(Proxy.isProxyClass(list.getClass())).isFalse();
 		assertThat(list).hasSize(1);
-		assertThat(list.get(0)).isEqualTo(bean);
+		assertThat(list).element(0).isEqualTo(bean);
 
 		Set<?> set = bean.getSomeSet();
 		assertThat(Proxy.isProxyClass(set.getClass())).isFalse();

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

@@ -237,7 +237,7 @@ public class XmlBeanCollectionTests {
 		assertThat(l).isNotNull();
 		assertThat(l.size()).isEqualTo(4);
 		assertThat(l.get(0).equals("zero")).isTrue();
-		assertThat(l.get(3)).isNull();
+		assertThat(l).element(3).isNull();
 
 		// Check nested map in list
 		Map m = (Map) l.get(1);
@@ -366,8 +366,8 @@ public class XmlBeanCollectionTests {
 		List list = (List) this.beanFactory.getBean("listFactory");
 		assertThat(list instanceof LinkedList).isTrue();
 		assertThat(list.size()).isEqualTo(2);
-		assertThat(list.get(0)).isEqualTo("bar");
-		assertThat(list.get(1)).isEqualTo("jenny");
+		assertThat(list).element(0).isEqualTo("bar");
+		assertThat(list).element(1).isEqualTo("jenny");
 	}
 
 	@Test
@@ -375,8 +375,8 @@ public class XmlBeanCollectionTests {
 		List list = (List) this.beanFactory.getBean("pListFactory");
 		assertThat(list instanceof LinkedList).isTrue();
 		assertThat(list.size()).isEqualTo(2);
-		assertThat(list.get(0)).isEqualTo("bar");
-		assertThat(list.get(1)).isEqualTo("jenny");
+		assertThat(list).element(0).isEqualTo("bar");
+		assertThat(list).element(1).isEqualTo("jenny");
 	}
 
 	@Test

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

@@ -62,9 +62,9 @@ public class CustomCollectionEditorTests {
 		assertThat(value instanceof ArrayList).isTrue();
 		List<?> list = (List<?>) value;
 		assertThat(list).as("There must be 3 elements in the converted collection").hasSize(3);
-		assertThat(list.get(0)).isEqualTo(0);
-		assertThat(list.get(1)).isEqualTo(1);
-		assertThat(list.get(2)).isEqualTo(2);
+		assertThat(list).element(0).isEqualTo(0);
+		assertThat(list).element(1).isEqualTo(1);
+		assertThat(list).element(2).isEqualTo(2);
 	}
 
 	@Test
@@ -86,7 +86,7 @@ public class CustomCollectionEditorTests {
 		assertThat(value instanceof ArrayList).isTrue();
 		List<?> list = (List<?>) value;
 		assertThat(list).as("There must be 1 element in the converted collection").hasSize(1);
-		assertThat(list.get(0)).isEqualTo("0, 1, 2");
+		assertThat(list).element(0).isEqualTo("0, 1, 2");
 	}
 
 

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

@@ -1333,7 +1333,7 @@ class CustomEditorTests {
 		bw.setPropertyValue("list", "1");
 		assertThat(((TestBean) bean.getList().get(0)).getName()).isEqualTo("list1");
 		bw.setPropertyValue("list[0]", "test");
-		assertThat(bean.getList().get(0)).isEqualTo("test");
+		assertThat(bean.getList()).element(0).isEqualTo("test");
 	}
 
 	@Test
@@ -1345,8 +1345,8 @@ class CustomEditorTests {
 
 		bw.setPropertyValue("vector", new String[] {"a", "b"});
 		assertThat(tb.getVector()).hasSize(2);
-		assertThat(tb.getVector().get(0)).isEqualTo("a");
-		assertThat(tb.getVector().get(1)).isEqualTo("b");
+		assertThat(tb.getVector()).element(0).isEqualTo("a");
+		assertThat(tb.getVector()).element(1).isEqualTo("b");
 
 		bw.setPropertyValue("hashtable", Collections.singletonMap("foo", "bar"));
 		assertThat(tb.getHashtable()).hasSize(1);
@@ -1362,7 +1362,7 @@ class CustomEditorTests {
 		TestBean tb = new TestBean();
 		bw.setPropertyValue("list", new ArrayList<>());
 		bw.setPropertyValue("list[0]", tb);
-		assertThat(bean.getList().get(0)).isEqualTo(tb);
+		assertThat(bean.getList()).element(0).isEqualTo(tb);
 		assertThat(bw.findCustomEditor(int.class, "list.age")).isEqualTo(pe);
 		assertThat(bw.findCustomEditor(null, "list.age")).isEqualTo(pe);
 		assertThat(bw.findCustomEditor(int.class, "list[0].age")).isEqualTo(pe);

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

@@ -1086,8 +1086,8 @@ public abstract class AbstractAopProxyTests {
 		// NameReverter saved it back
 		assertThat(it.getName()).isEqualTo(name1);
 		assertThat(saver.names).hasSize(2);
-		assertThat(saver.names.get(0)).isEqualTo(name2);
-		assertThat(saver.names.get(1)).isEqualTo(name1);
+		assertThat(saver.names).element(0).isEqualTo(name2);
+		assertThat(saver.names).element(1).isEqualTo(name1);
 	}
 
 	@SuppressWarnings("serial")

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

@@ -426,8 +426,8 @@ public class ProxyFactoryBeanTests {
 		tb.setName("Tristan");
 		tb.toString();
 		assertThat(PointcutForVoid.methodNames).as("Recorded wrong number of invocations").hasSize(2);
-		assertThat(PointcutForVoid.methodNames.get(0)).isEqualTo("setAge");
-		assertThat(PointcutForVoid.methodNames.get(1)).isEqualTo("setName");
+		assertThat(PointcutForVoid.methodNames).element(0).isEqualTo("setAge");
+		assertThat(PointcutForVoid.methodNames).element(1).isEqualTo("setName");
 	}
 
 	@Test

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

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

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

@@ -491,8 +491,8 @@ public class ClassPathBeanDefinitionScannerTests {
 		assertThat(fooService.lookupFoo(123)).isEqualTo("bar");
 		assertThat(fooService.beanFactory).isSameAs(context.getDefaultListableBeanFactory());
 		assertThat(fooService.listableBeanFactory).hasSize(2);
-		assertThat(fooService.listableBeanFactory.get(0)).isSameAs(context.getDefaultListableBeanFactory());
-		assertThat(fooService.listableBeanFactory.get(1)).isSameAs(myBf);
+		assertThat(fooService.listableBeanFactory).element(0).isSameAs(context.getDefaultListableBeanFactory());
+		assertThat(fooService.listableBeanFactory).element(1).isSameAs(myBf);
 		assertThat(fooService.resourceLoader).isSameAs(context);
 		assertThat(fooService.resourcePatternResolver).isSameAs(context);
 		assertThat(fooService.eventPublisher).isSameAs(context);

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

@@ -119,8 +119,8 @@ class ConfigurationClassPostProcessorAotContributionTests {
 				freshContext.refresh();
 				TestAwareCallbackBean bean = freshContext.getBean(TestAwareCallbackBean.class);
 				assertThat(bean.instances).hasSize(2);
-				assertThat(bean.instances.get(0)).isEqualTo(freshContext);
-				assertThat(bean.instances.get(1)).isInstanceOfSatisfying(AnnotationMetadata.class, metadata ->
+				assertThat(bean.instances).element(0).isEqualTo(freshContext);
+				assertThat(bean.instances).element(1).isInstanceOfSatisfying(AnnotationMetadata.class, metadata ->
 						assertThat(metadata.getClassName()).isEqualTo(TestAwareCallbackConfiguration.class.getName()));
 				freshContext.close();
 			});

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

@@ -1050,7 +1050,7 @@ class ConfigurationClassPostProcessorTests {
 		CollectionArgumentConfiguration bean = ctx.getBean(CollectionArgumentConfiguration.class);
 		assertThat(bean.testBeans).isNotNull();
 		assertThat(bean.testBeans).hasSize(1);
-		assertThat(bean.testBeans.get(0)).isSameAs(ctx.getBean(TestBean.class));
+		assertThat(bean.testBeans).element(0).isSameAs(ctx.getBean(TestBean.class));
 		ctx.close();
 	}
 
@@ -1088,7 +1088,7 @@ class ConfigurationClassPostProcessorTests {
 		CollectionInjectionConfiguration bean = ctx.getBean(CollectionInjectionConfiguration.class);
 		assertThat(bean.testBeans).isNotNull();
 		assertThat(bean.testBeans).hasSize(1);
-		assertThat(bean.testBeans.get(0)).isSameAs(ctx.getBean(TestBean.class));
+		assertThat(bean.testBeans).element(0).isSameAs(ctx.getBean(TestBean.class));
 		ctx.close();
 	}
 

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

@@ -50,8 +50,8 @@ public class Spr12636Tests {
 		this.context = new AnnotationConfigApplicationContext(
 				UserServiceTwo.class, UserServiceOne.class, UserServiceCollector.class);
 		UserServiceCollector bean = this.context.getBean(UserServiceCollector.class);
-		assertThat(bean.userServices.get(0)).isSameAs(context.getBean("serviceOne", UserService.class));
-		assertThat(bean.userServices.get(1)).isSameAs(context.getBean("serviceTwo", UserService.class));
+		assertThat(bean.userServices).element(0).isSameAs(context.getBean("serviceOne", UserService.class));
+		assertThat(bean.userServices).element(1).isSameAs(context.getBean("serviceTwo", UserService.class));
 
 	}
 
@@ -67,8 +67,8 @@ public class Spr12636Tests {
 		assertThat(AopUtils.isAopProxy(serviceTwo)).isTrue();
 
 		UserServiceCollector bean = this.context.getBean(UserServiceCollector.class);
-		assertThat(bean.userServices.get(0)).isSameAs(serviceOne);
-		assertThat(bean.userServices.get(1)).isSameAs(serviceTwo);
+		assertThat(bean.userServices).element(0).isSameAs(serviceOne);
+		assertThat(bean.userServices).element(1).isSameAs(serviceTwo);
 	}
 
 	@Configuration

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

@@ -376,7 +376,7 @@ class DefaultLifecycleProcessorTests {
 		context.stop();
 		assertThat(stoppedBeans).hasSize(1);
 		assertThat(bean.isRunning()).isFalse();
-		assertThat(stoppedBeans.get(0)).isEqualTo(bean);
+		assertThat(stoppedBeans).element(0).isEqualTo(bean);
 		context.close();
 	}
 
@@ -393,7 +393,7 @@ class DefaultLifecycleProcessorTests {
 		context.stop();
 		assertThat(stoppedBeans).hasSize(1);
 		assertThat(bean.isRunning()).isFalse();
-		assertThat(stoppedBeans.get(0)).isEqualTo(bean);
+		assertThat(stoppedBeans).element(0).isEqualTo(bean);
 		context.close();
 	}
 
@@ -467,9 +467,9 @@ class DefaultLifecycleProcessorTests {
 		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);
+		assertThat(startedBeans).element(1).isEqualTo(bean99);
 		assertThat(getPhase(startedBeans.get(2))).isEqualTo(2);
-		assertThat(startedBeans.get(2)).isEqualTo(bean2);
+		assertThat(startedBeans).element(2).isEqualTo(bean2);
 		assertThat(getPhase(startedBeans.get(3))).isEqualTo(Integer.MAX_VALUE);
 		context.stop();
 		context.close();
@@ -510,9 +510,9 @@ class DefaultLifecycleProcessorTests {
 		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);
+		assertThat(stoppedBeans).element(1).isEqualTo(bean2);
 		assertThat(getPhase(stoppedBeans.get(2))).isEqualTo(99);
-		assertThat(stoppedBeans.get(2)).isEqualTo(bean99);
+		assertThat(stoppedBeans).element(2).isEqualTo(bean99);
 		assertThat(getPhase(stoppedBeans.get(3))).isEqualTo(7);
 		assertThat(getPhase(stoppedBeans.get(4))).isEqualTo(1);
 		assertThat(getPhase(stoppedBeans.get(5))).isEqualTo(Integer.MIN_VALUE);

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

@@ -402,28 +402,28 @@ class ResourceBundleMessageSourceTests {
 
 		List<String> filenames = ms.calculateFilenamesForLocale("messages", Locale.ENGLISH);
 		assertThat(filenames).hasSize(1);
-		assertThat(filenames.get(0)).isEqualTo("messages_en");
+		assertThat(filenames).element(0).isEqualTo("messages_en");
 
 		filenames = ms.calculateFilenamesForLocale("messages", Locale.UK);
 		assertThat(filenames).hasSize(2);
-		assertThat(filenames.get(1)).isEqualTo("messages_en");
-		assertThat(filenames.get(0)).isEqualTo("messages_en_GB");
+		assertThat(filenames).element(1).isEqualTo("messages_en");
+		assertThat(filenames).element(0).isEqualTo("messages_en_GB");
 
 		filenames = ms.calculateFilenamesForLocale("messages", new Locale("en", "GB", "POSIX"));
 		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");
+		assertThat(filenames).element(2).isEqualTo("messages_en");
+		assertThat(filenames).element(1).isEqualTo("messages_en_GB");
+		assertThat(filenames).element(0).isEqualTo("messages_en_GB_POSIX");
 
 		filenames = ms.calculateFilenamesForLocale("messages", new Locale("en", "", "POSIX"));
 		assertThat(filenames).hasSize(2);
-		assertThat(filenames.get(1)).isEqualTo("messages_en");
-		assertThat(filenames.get(0)).isEqualTo("messages_en__POSIX");
+		assertThat(filenames).element(1).isEqualTo("messages_en");
+		assertThat(filenames).element(0).isEqualTo("messages_en__POSIX");
 
 		filenames = ms.calculateFilenamesForLocale("messages", new Locale("", "UK", "POSIX"));
 		assertThat(filenames).hasSize(2);
-		assertThat(filenames.get(1)).isEqualTo("messages__UK");
-		assertThat(filenames.get(0)).isEqualTo("messages__UK_POSIX");
+		assertThat(filenames).element(1).isEqualTo("messages__UK");
+		assertThat(filenames).element(0).isEqualTo("messages__UK_POSIX");
 
 		filenames = ms.calculateFilenamesForLocale("messages", new Locale("", "", "POSIX"));
 		assertThat(filenames).isEmpty();

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

@@ -33,8 +33,8 @@ class Spr7283Tests {
 		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spr7283.xml", getClass());
 		List<?> list = ctx.getBean("list", List.class);
 		assertThat(list).hasSize(2);
-		assertThat(list.get(0)).isInstanceOf(A.class);
-		assertThat(list.get(1)).isInstanceOf(B.class);
+		assertThat(list).element(0).isInstanceOf(A.class);
+		assertThat(list).element(1).isInstanceOf(B.class);
 		ctx.close();
 	}
 

spring-context/src/test/java/org/springframework/jmx/export/MBeanExporterTests.java

@@ -699,8 +699,8 @@ public class MBeanExporterTests extends AbstractMBeanServerTests {
 		ObjectName desired = ObjectNameManager.getInstance(OBJECT_NAME);
 		assertThat(listener.getRegistered()).as("Incorrect number of registrations").hasSize(1);
 		assertThat(listener.getUnregistered()).as("Incorrect number of unregistrations").hasSize(1);
-		assertThat(listener.getRegistered().get(0)).as("Incorrect ObjectName in register").isEqualTo(desired);
-		assertThat(listener.getUnregistered().get(0)).as("Incorrect ObjectName in unregister").isEqualTo(desired);
+		assertThat(listener.getRegistered()).element(0).as("Incorrect ObjectName in register").isEqualTo(desired);
+		assertThat(listener.getUnregistered()).element(0).as("Incorrect ObjectName in unregister").isEqualTo(desired);
 	}
 
 

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

@@ -480,7 +480,7 @@ class DataBinderTests {
 		LocaleContextHolder.setLocale(Locale.GERMAN);
 		try {
 			binder.bind(pvs);
-			assertThat(tb.getIntegerList().get(0)).isEqualTo(1);
+			assertThat(tb.getIntegerList()).element(0).isEqualTo(1);
 			assertThat(binder.getBindingResult().getFieldValue("integerList[0]")).isEqualTo("1");
 		}
 		finally {
@@ -2007,8 +2007,8 @@ class DataBinderTests {
 		assertThat(binder.getBindingResult().hasErrors()).isFalse();
 		@SuppressWarnings("unchecked")
 		List<Object> list = (List<Object>) form.getF().get("list");
-		assertThat(list.get(0)).isEqualTo("firstValue");
-		assertThat(list.get(1)).isEqualTo("secondValue");
+		assertThat(list).element(0).isEqualTo("firstValue");
+		assertThat(list).element(1).isEqualTo("secondValue");
 		assertThat(list).hasSize(2);
 	}
 
@@ -2043,7 +2043,7 @@ class DataBinderTests {
 
 		binder.bind(pvs);
 		assertThat(tb.getIntegerList()).hasSize(257);
-		assertThat(tb.getIntegerList().get(256)).isEqualTo(Integer.valueOf(1));
+		assertThat(tb.getIntegerList()).element(256).isEqualTo(Integer.valueOf(1));
 		assertThat(binder.getBindingResult().getFieldValue("integerList[256]")).isEqualTo(1);
 	}
 

spring-core-test/src/test/java/org/springframework/core/test/io/support/MockSpringFactoriesLoaderTests.java

@@ -62,8 +62,8 @@ class MockSpringFactoriesLoaderTests {
 	private void assertThatLoaderHasTestFactories(MockSpringFactoriesLoader loader) {
 		List<TestFactoryType> factories = loader.load(TestFactoryType.class);
 		assertThat(factories).hasSize(2);
-		assertThat(factories.get(0)).isInstanceOf(TestFactoryOne.class);
-		assertThat(factories.get(1)).isInstanceOf(TestFactoryTwo.class);
+		assertThat(factories).element(0).isInstanceOf(TestFactoryOne.class);
+		assertThat(factories).element(1).isInstanceOf(TestFactoryTwo.class);
 	}
 
 	interface TestFactoryType {

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

@@ -41,8 +41,8 @@ class AnnotationAwareOrderComparatorTests {
 		list.add(new B());
 		list.add(new A());
 		AnnotationAwareOrderComparator.sort(list);
-		assertThat(list.get(0)).isInstanceOf(A.class);
-		assertThat(list.get(1)).isInstanceOf(B.class);
+		assertThat(list).element(0).isInstanceOf(A.class);
+		assertThat(list).element(1).isInstanceOf(B.class);
 	}
 
 	@Test
@@ -51,8 +51,8 @@ class AnnotationAwareOrderComparatorTests {
 		list.add(new B2());
 		list.add(new A2());
 		AnnotationAwareOrderComparator.sort(list);
-		assertThat(list.get(0)).isInstanceOf(A2.class);
-		assertThat(list.get(1)).isInstanceOf(B2.class);
+		assertThat(list).element(0).isInstanceOf(A2.class);
+		assertThat(list).element(1).isInstanceOf(B2.class);
 	}
 
 	@Test
@@ -61,8 +61,8 @@ class AnnotationAwareOrderComparatorTests {
 		list.add(new B());
 		list.add(new A2());
 		AnnotationAwareOrderComparator.sort(list);
-		assertThat(list.get(0)).isInstanceOf(A2.class);
-		assertThat(list.get(1)).isInstanceOf(B.class);
+		assertThat(list).element(0).isInstanceOf(A2.class);
+		assertThat(list).element(1).isInstanceOf(B.class);
 	}
 
 	@Test
@@ -71,8 +71,8 @@ class AnnotationAwareOrderComparatorTests {
 		list.add(new B());
 		list.add(new C());
 		AnnotationAwareOrderComparator.sort(list);
-		assertThat(list.get(0)).isInstanceOf(C.class);
-		assertThat(list.get(1)).isInstanceOf(B.class);
+		assertThat(list).element(0).isInstanceOf(C.class);
+		assertThat(list).element(1).isInstanceOf(B.class);
 	}
 
 	@Test
@@ -81,8 +81,8 @@ class AnnotationAwareOrderComparatorTests {
 		list.add(B.class);
 		list.add(A.class);
 		AnnotationAwareOrderComparator.sort(list);
-		assertThat(list.get(0)).isEqualTo(A.class);
-		assertThat(list.get(1)).isEqualTo(B.class);
+		assertThat(list).element(0).isEqualTo(A.class);
+		assertThat(list).element(1).isEqualTo(B.class);
 	}
 
 	@Test
@@ -91,8 +91,8 @@ class AnnotationAwareOrderComparatorTests {
 		list.add(B.class);
 		list.add(C.class);
 		AnnotationAwareOrderComparator.sort(list);
-		assertThat(list.get(0)).isEqualTo(C.class);
-		assertThat(list.get(1)).isEqualTo(B.class);
+		assertThat(list).element(0).isEqualTo(C.class);
+		assertThat(list).element(1).isEqualTo(B.class);
 	}
 
 	@Test
@@ -103,10 +103,10 @@ class AnnotationAwareOrderComparatorTests {
 		list.add(null);
 		list.add(A.class);
 		AnnotationAwareOrderComparator.sort(list);
-		assertThat(list.get(0)).isEqualTo(A.class);
-		assertThat(list.get(1)).isEqualTo(B.class);
-		assertThat(list.get(2)).isNull();
-		assertThat(list.get(3)).isNull();
+		assertThat(list).element(0).isEqualTo(A.class);
+		assertThat(list).element(1).isEqualTo(B.class);
+		assertThat(list).element(2).isNull();
+		assertThat(list).element(3).isNull();
 	}
 
 

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

@@ -134,10 +134,10 @@ class CollectionToCollectionConverterTests {
 		TypeDescriptor targetType = new TypeDescriptor(getClass().getField("objectToCollection"));
 		assertThat(conversionService.canConvert(sourceType, targetType)).isTrue();
 		List<List<List<Integer>>> result = (List<List<List<Integer>>>) conversionService.convert(list, sourceType, targetType);
-		assertThat(result.get(0).get(0).get(0)).isEqualTo((Integer) 9);
-		assertThat(result.get(0).get(1).get(0)).isEqualTo((Integer) 12);
-		assertThat(result.get(1).get(0).get(0)).isEqualTo((Integer) 37);
-		assertThat(result.get(1).get(1).get(0)).isEqualTo((Integer) 23);
+		assertThat(result.get(0).get(0)).element(0).isEqualTo((Integer) 9);
+		assertThat(result.get(0).get(1)).element(0).isEqualTo((Integer) 12);
+		assertThat(result.get(1).get(0)).element(0).isEqualTo((Integer) 37);
+		assertThat(result.get(1).get(1)).element(0).isEqualTo((Integer) 23);
 	}
 
 	@Test
@@ -154,10 +154,10 @@ class CollectionToCollectionConverterTests {
 		TypeDescriptor targetType = new TypeDescriptor(getClass().getField("objectToCollection"));
 		assertThat(conversionService.canConvert(sourceType, targetType)).isTrue();
 		List<List<List<Integer>>> result = (List<List<List<Integer>>>) conversionService.convert(list, sourceType, targetType);
-		assertThat(result.get(0).get(0).get(0)).isEqualTo((Integer) 9);
-		assertThat(result.get(0).get(0).get(1)).isEqualTo((Integer) 12);
-		assertThat(result.get(1).get(0).get(0)).isEqualTo((Integer) 37);
-		assertThat(result.get(1).get(0).get(1)).isEqualTo((Integer) 23);
+		assertThat(result.get(0).get(0)).element(0).isEqualTo((Integer) 9);
+		assertThat(result.get(0).get(0)).element(1).isEqualTo((Integer) 12);
+		assertThat(result.get(1).get(0)).element(0).isEqualTo((Integer) 37);
+		assertThat(result.get(1).get(0)).element(1).isEqualTo((Integer) 23);
 	}
 
 	@Test

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

@@ -122,8 +122,8 @@ class SimpleCommandLinePropertySourceTests {
 
 		@SuppressWarnings("unchecked")
 		List<String> nonOptionArgsList = env.getProperty("nonOptionArgs", List.class);
-		assertThat(nonOptionArgsList.get(0)).isEqualTo("noa1");
-		assertThat(nonOptionArgsList.get(1)).isEqualTo("noa2");
+		assertThat(nonOptionArgsList).element(0).isEqualTo("noa1");
+		assertThat(nonOptionArgsList).element(1).isEqualTo("noa2");
 	}
 
 }

spring-core/src/test/java/org/springframework/core/io/support/SpringFactoriesLoaderTests.java

@@ -85,8 +85,8 @@ class SpringFactoriesLoaderTests {
 	void loadWhenDuplicateRegistrationsPresentReturnsListInCorrectOrder() {
 		List<DummyFactory> factories = SpringFactoriesLoader.forDefaultResourceLocation().load(DummyFactory.class);
 		assertThat(factories).hasSize(2);
-		assertThat(factories.get(0)).isInstanceOf(MyDummyFactory1.class);
-		assertThat(factories.get(1)).isInstanceOf(MyDummyFactory2.class);
+		assertThat(factories).element(0).isInstanceOf(MyDummyFactory1.class);
+		assertThat(factories).element(1).isInstanceOf(MyDummyFactory2.class);
 	}
 
 	@Test
@@ -119,9 +119,9 @@ class SpringFactoriesLoaderTests {
 		List<DummyFactory> factories = SpringFactoriesLoader.forDefaultResourceLocation(LimitedClassLoader.constructorArgumentFactories)
 					.load(DummyFactory.class, resolver);
 		assertThat(factories).hasSize(3);
-		assertThat(factories.get(0)).isInstanceOf(MyDummyFactory1.class);
-		assertThat(factories.get(1)).isInstanceOf(MyDummyFactory2.class);
-		assertThat(factories.get(2)).isInstanceOf(ConstructorArgsDummyFactory.class);
+		assertThat(factories).element(0).isInstanceOf(MyDummyFactory1.class);
+		assertThat(factories).element(1).isInstanceOf(MyDummyFactory2.class);
+		assertThat(factories).element(2).isInstanceOf(ConstructorArgsDummyFactory.class);
 		assertThat(factories).extracting(DummyFactory::getString).containsExactly("Foo", "Bar", "injected");
 	}
 
@@ -143,8 +143,8 @@ class SpringFactoriesLoaderTests {
 		List<DummyFactory> factories = SpringFactoriesLoader.forDefaultResourceLocation(LimitedClassLoader.multipleArgumentFactories)
 					.load(DummyFactory.class, failureHandler);
 		assertThat(factories).hasSize(2);
-		assertThat(factories.get(0)).isInstanceOf(MyDummyFactory1.class);
-		assertThat(factories.get(1)).isInstanceOf(MyDummyFactory2.class);
+		assertThat(factories).element(0).isInstanceOf(MyDummyFactory1.class);
+		assertThat(factories).element(1).isInstanceOf(MyDummyFactory2.class);
 	}
 
 	@Test
@@ -152,8 +152,8 @@ class SpringFactoriesLoaderTests {
 		List<DummyFactory> factories = SpringFactoriesLoader.loadFactories(
 				DummyFactory.class, null);
 		assertThat(factories).hasSize(2);
-		assertThat(factories.get(0)).isInstanceOf(MyDummyFactory1.class);
-		assertThat(factories.get(1)).isInstanceOf(MyDummyFactory2.class);
+		assertThat(factories).element(0).isInstanceOf(MyDummyFactory1.class);
+		assertThat(factories).element(1).isInstanceOf(MyDummyFactory2.class);
 	}
 
 	@Test
@@ -168,7 +168,7 @@ class SpringFactoriesLoaderTests {
 		List<DummyFactory> factories = SpringFactoriesLoader.forResourceLocation(
 				"META-INF/custom/custom-spring.factories").load(DummyFactory.class);
 		assertThat(factories).hasSize(1);
-		assertThat(factories.get(0)).isInstanceOf(MyDummyFactory1.class);
+		assertThat(factories).element(0).isInstanceOf(MyDummyFactory1.class);
 	}
 
 	@Test
@@ -221,7 +221,7 @@ class SpringFactoriesLoaderTests {
 			handler.handleFailure(DummyFactory.class, MyDummyFactory1.class.getName(), cause);
 			assertThat(failures).containsExactly(cause);
 			assertThat(messages).hasSize(1);
-			assertThat(messages.get(0)).startsWith("Unable to instantiate factory class");
+			assertThat(messages).element(0).asString().startsWith("Unable to instantiate factory class");
 		}
 	}
 

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

@@ -513,74 +513,74 @@ class AntPathMatcherTests {
 		paths.add(null);
 		paths.add("/hotels/new");
 		paths.sort(comparator);
-		assertThat(paths.get(0)).isEqualTo("/hotels/new");
-		assertThat(paths.get(1)).isNull();
+		assertThat(paths).element(0).isEqualTo("/hotels/new");
+		assertThat(paths).element(1).isNull();
 		paths.clear();
 
 		paths.add("/hotels/new");
 		paths.add(null);
 		paths.sort(comparator);
-		assertThat(paths.get(0)).isEqualTo("/hotels/new");
-		assertThat(paths.get(1)).isNull();
+		assertThat(paths).element(0).isEqualTo("/hotels/new");
+		assertThat(paths).element(1).isNull();
 		paths.clear();
 
 		paths.add("/hotels/*");
 		paths.add("/hotels/new");
 		paths.sort(comparator);
-		assertThat(paths.get(0)).isEqualTo("/hotels/new");
-		assertThat(paths.get(1)).isEqualTo("/hotels/*");
+		assertThat(paths).element(0).isEqualTo("/hotels/new");
+		assertThat(paths).element(1).isEqualTo("/hotels/*");
 		paths.clear();
 
 		paths.add("/hotels/new");
 		paths.add("/hotels/*");
 		paths.sort(comparator);
-		assertThat(paths.get(0)).isEqualTo("/hotels/new");
-		assertThat(paths.get(1)).isEqualTo("/hotels/*");
+		assertThat(paths).element(0).isEqualTo("/hotels/new");
+		assertThat(paths).element(1).isEqualTo("/hotels/*");
 		paths.clear();
 
 		paths.add("/hotels/**");
 		paths.add("/hotels/*");
 		paths.sort(comparator);
-		assertThat(paths.get(0)).isEqualTo("/hotels/*");
-		assertThat(paths.get(1)).isEqualTo("/hotels/**");
+		assertThat(paths).element(0).isEqualTo("/hotels/*");
+		assertThat(paths).element(1).isEqualTo("/hotels/**");
 		paths.clear();
 
 		paths.add("/hotels/*");
 		paths.add("/hotels/**");
 		paths.sort(comparator);
-		assertThat(paths.get(0)).isEqualTo("/hotels/*");
-		assertThat(paths.get(1)).isEqualTo("/hotels/**");
+		assertThat(paths).element(0).isEqualTo("/hotels/*");
+		assertThat(paths).element(1).isEqualTo("/hotels/**");
 		paths.clear();
 
 		paths.add("/hotels/{hotel}");
 		paths.add("/hotels/new");
 		paths.sort(comparator);
-		assertThat(paths.get(0)).isEqualTo("/hotels/new");
-		assertThat(paths.get(1)).isEqualTo("/hotels/{hotel}");
+		assertThat(paths).element(0).isEqualTo("/hotels/new");
+		assertThat(paths).element(1).isEqualTo("/hotels/{hotel}");
 		paths.clear();
 
 		paths.add("/hotels/new");
 		paths.add("/hotels/{hotel}");
 		paths.sort(comparator);
-		assertThat(paths.get(0)).isEqualTo("/hotels/new");
-		assertThat(paths.get(1)).isEqualTo("/hotels/{hotel}");
+		assertThat(paths).element(0).isEqualTo("/hotels/new");
+		assertThat(paths).element(1).isEqualTo("/hotels/{hotel}");
 		paths.clear();
 
 		paths.add("/hotels/*");
 		paths.add("/hotels/{hotel}");
 		paths.add("/hotels/new");
 		paths.sort(comparator);
-		assertThat(paths.get(0)).isEqualTo("/hotels/new");
-		assertThat(paths.get(1)).isEqualTo("/hotels/{hotel}");
-		assertThat(paths.get(2)).isEqualTo("/hotels/*");
+		assertThat(paths).element(0).isEqualTo("/hotels/new");
+		assertThat(paths).element(1).isEqualTo("/hotels/{hotel}");
+		assertThat(paths).element(2).isEqualTo("/hotels/*");
 		paths.clear();
 
 		paths.add("/hotels/ne*");
 		paths.add("/hotels/n*");
 		Collections.shuffle(paths);
 		paths.sort(comparator);
-		assertThat(paths.get(0)).isEqualTo("/hotels/ne*");
-		assertThat(paths.get(1)).isEqualTo("/hotels/n*");
+		assertThat(paths).element(0).isEqualTo("/hotels/ne*");
+		assertThat(paths).element(1).isEqualTo("/hotels/n*");
 		paths.clear();
 
 		comparator = pathMatcher.getPatternComparator("/hotels/new.html");
@@ -588,16 +588,16 @@ class AntPathMatcherTests {
 		paths.add("/hotels/{hotel}");
 		Collections.shuffle(paths);
 		paths.sort(comparator);
-		assertThat(paths.get(0)).isEqualTo("/hotels/new.*");
-		assertThat(paths.get(1)).isEqualTo("/hotels/{hotel}");
+		assertThat(paths).element(0).isEqualTo("/hotels/new.*");
+		assertThat(paths).element(1).isEqualTo("/hotels/{hotel}");
 		paths.clear();
 
 		comparator = pathMatcher.getPatternComparator("/web/endUser/action/login.html");
 		paths.add("/**/login.*");
 		paths.add("/**/endUser/action/login.*");
 		paths.sort(comparator);
-		assertThat(paths.get(0)).isEqualTo("/**/endUser/action/login.*");
-		assertThat(paths.get(1)).isEqualTo("/**/login.*");
+		assertThat(paths).element(0).isEqualTo("/**/endUser/action/login.*");
+		assertThat(paths).element(1).isEqualTo("/**/login.*");
 		paths.clear();
 	}
 

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

@@ -65,7 +65,7 @@ class AutoPopulatingListTests {
 		String helloWorld = "Hello World!";
 		list.add(10, null);
 		list.add(11, helloWorld);
-		assertThat(list.get(11)).isEqualTo(helloWorld);
+		assertThat(list).element(11).isEqualTo(helloWorld);
 
 		boolean condition3 = list.get(10) instanceof TestObject;
 		assertThat(condition3).isTrue();

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

@@ -66,9 +66,9 @@ class CollectionUtilsTests {
 		list.add("value3");
 
 		CollectionUtils.mergeArrayIntoCollection(arr, list);
-		assertThat(list.get(0)).isEqualTo("value3");
-		assertThat(list.get(1)).isEqualTo("value1");
-		assertThat(list.get(2)).isEqualTo("value2");
+		assertThat(list).element(0).isEqualTo("value3");
+		assertThat(list).element(1).isEqualTo("value1");
+		assertThat(list).element(2).isEqualTo("value2");
 	}
 
 	@Test
@@ -78,9 +78,9 @@ class CollectionUtilsTests {
 		list.add(3);
 
 		CollectionUtils.mergeArrayIntoCollection(arr, list);
-		assertThat(list.get(0)).isEqualTo(3);
-		assertThat(list.get(1)).isEqualTo(1);
-		assertThat(list.get(2)).isEqualTo(2);
+		assertThat(list).element(0).isEqualTo(3);
+		assertThat(list).element(1).isEqualTo(1);
+		assertThat(list).element(2).isEqualTo(2);
 	}
 
 	@Test

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

@@ -303,12 +303,12 @@ class EvaluationTests extends AbstractExpressionTests {
 
 			e = parser.parseExpression("address.crossStreets[0]");
 			e.setValue(context, "Blah");
-			assertThat(person.getAddress().getCrossStreets().get(0)).isEqualTo("Blah");
+			assertThat(person.getAddress().getCrossStreets()).element(0).isEqualTo("Blah");
 
 			e = parser.parseExpression("address.crossStreets[3]");
 			e.setValue(context, "Wibble");
-			assertThat(person.getAddress().getCrossStreets().get(0)).isEqualTo("Blah");
-			assertThat(person.getAddress().getCrossStreets().get(3)).isEqualTo("Wibble");
+			assertThat(person.getAddress().getCrossStreets()).element(0).isEqualTo("Blah");
+			assertThat(person.getAddress().getCrossStreets()).element(3).isEqualTo("Wibble");
 		}
 
 		/**
@@ -362,7 +362,7 @@ class EvaluationTests extends AbstractExpressionTests {
 			Expression e = parser.parseExpression("listOfStrings[++index3]='def'");
 			e.getValue(ctx);
 			assertThat(instance.listOfStrings).hasSize(2);
-			assertThat(instance.listOfStrings.get(1)).isEqualTo("def");
+			assertThat(instance.listOfStrings).element(1).isEqualTo("def");
 
 			// Check reference beyond end of collection
 			ctx = new StandardEvaluationContext(instance);

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

@@ -1376,8 +1376,8 @@ class SpelReproTests extends AbstractExpressionTests {
 		assertThat(value).isInstanceOf(ArrayList.class);
 		@SuppressWarnings("rawtypes")
 		ArrayList list = (ArrayList) value;
-		assertThat(list.get(0)).isEqualTo("one");
-		assertThat(list.get(1)).isEqualTo("two");
+		assertThat(list).element(0).isEqualTo("one");
+		assertThat(list).element(1).isEqualTo("two");
 	}
 
 	@Test

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

@@ -125,7 +125,7 @@ public class JdbcTemplateQueryTests {
 		given(this.resultSet.getInt(1)).willReturn(11);
 		List<Integer> li = this.template.queryForList(sql, Integer.class);
 		assertThat(li).as("All rows returned").hasSize(1);
-		assertThat(li.get(0)).as("Element is Integer").isEqualTo(11);
+		assertThat(li).element(0).as("Element is Integer").isEqualTo(11);
 		verify(this.resultSet).close();
 		verify(this.statement).close();
 		verify(this.connection).close();
@@ -345,7 +345,7 @@ public class JdbcTemplateQueryTests {
 		given(this.resultSet.getInt(1)).willReturn(11);
 		List<Integer> li = this.template.queryForList(sql, Integer.class, 3);
 		assertThat(li).as("All rows returned").hasSize(1);
-		assertThat(li.get(0)).as("First row is Integer").isEqualTo(11);
+		assertThat(li).element(0).as("First row is Integer").isEqualTo(11);
 		verify(this.preparedStatement).setObject(1, 3);
 		verify(this.resultSet).close();
 		verify(this.preparedStatement).close();

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

@@ -138,7 +138,7 @@ public class NamedParameterQueryTests {
 				params, Integer.class);
 
 		assertThat(li.size()).as("All rows returned").isEqualTo(1);
-		assertThat(li.get(0)).as("First row is Integer").isEqualTo(11);
+		assertThat(li).element(0).as("First row is Integer").isEqualTo(11);
 		verify(connection).prepareStatement("SELECT AGE FROM CUSTMR WHERE ID < ?");
 		verify(preparedStatement).setObject(1, 3);
 	}

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

@@ -42,24 +42,24 @@ public class NamedParameterUtilsTests {
 		String sql = "xxx :a yyyy :b :c :a zzzzz";
 		ParsedSql psql = NamedParameterUtils.parseSqlStatement(sql);
 		assertThat(NamedParameterUtils.substituteNamedParameters(psql, null)).isEqualTo("xxx ? yyyy ? ? ? zzzzz");
-		assertThat(psql.getParameterNames().get(0)).isEqualTo("a");
-		assertThat(psql.getParameterNames().get(2)).isEqualTo("c");
-		assertThat(psql.getParameterNames().get(3)).isEqualTo("a");
+		assertThat(psql.getParameterNames()).element(0).isEqualTo("a");
+		assertThat(psql.getParameterNames()).element(2).isEqualTo("c");
+		assertThat(psql.getParameterNames()).element(3).isEqualTo("a");
 		assertThat(psql.getTotalParameterCount()).isEqualTo(4);
 		assertThat(psql.getNamedParameterCount()).isEqualTo(3);
 
 		String sql2 = "xxx &a yyyy ? zzzzz";
 		ParsedSql psql2 = NamedParameterUtils.parseSqlStatement(sql2);
 		assertThat(NamedParameterUtils.substituteNamedParameters(psql2, null)).isEqualTo("xxx ? yyyy ? zzzzz");
-		assertThat(psql2.getParameterNames().get(0)).isEqualTo("a");
+		assertThat(psql2.getParameterNames()).element(0).isEqualTo("a");
 		assertThat(psql2.getTotalParameterCount()).isEqualTo(2);
 		assertThat(psql2.getNamedParameterCount()).isEqualTo(1);
 
 		String sql3 = "xxx &ä+:ö" + '\t' + ":ü%10 yyyy ? zzzzz";
 		ParsedSql psql3 = NamedParameterUtils.parseSqlStatement(sql3);
-		assertThat(psql3.getParameterNames().get(0)).isEqualTo("ä");
-		assertThat(psql3.getParameterNames().get(1)).isEqualTo("ö");
-		assertThat(psql3.getParameterNames().get(2)).isEqualTo("ü");
+		assertThat(psql3.getParameterNames()).element(0).isEqualTo("ä");
+		assertThat(psql3.getParameterNames()).element(1).isEqualTo("ö");
+		assertThat(psql3.getParameterNames()).element(2).isEqualTo("ü");
 	}
 
 	@Test
@@ -225,8 +225,8 @@ public class NamedParameterUtilsTests {
 
 		ParsedSql parsedSql = NamedParameterUtils.parseSqlStatement(sql);
 		assertThat(parsedSql.getParameterNames()).hasSize(2);
-		assertThat(parsedSql.getParameterNames().get(0)).isEqualTo("p1");
-		assertThat(parsedSql.getParameterNames().get(1)).isEqualTo("p2");
+		assertThat(parsedSql.getParameterNames()).element(0).isEqualTo("p1");
+		assertThat(parsedSql.getParameterNames()).element(1).isEqualTo("p2");
 		String finalSql = NamedParameterUtils.substituteNamedParameters(parsedSql, null);
 		assertThat(finalSql).isEqualTo(expectedSql);
 	}
@@ -238,8 +238,8 @@ public class NamedParameterUtilsTests {
 
 		ParsedSql parsedSql = NamedParameterUtils.parseSqlStatement(sql);
 		assertThat(parsedSql.getParameterNames()).hasSize(2);
-		assertThat(parsedSql.getParameterNames().get(0)).isEqualTo("p1");
-		assertThat(parsedSql.getParameterNames().get(1)).isEqualTo("p2");
+		assertThat(parsedSql.getParameterNames()).element(0).isEqualTo("p1");
+		assertThat(parsedSql.getParameterNames()).element(1).isEqualTo("p2");
 		String finalSql = NamedParameterUtils.substituteNamedParameters(parsedSql, null);
 		assertThat(finalSql).isEqualTo(expectedSql);
 	}
@@ -269,7 +269,7 @@ public class NamedParameterUtilsTests {
 
 		ParsedSql parsedSql = NamedParameterUtils.parseSqlStatement(sql);
 		assertThat(parsedSql.getParameterNames()).hasSize(1);
-		assertThat(parsedSql.getParameterNames().get(0)).isEqualTo("p");
+		assertThat(parsedSql.getParameterNames()).element(0).isEqualTo("p");
 		String finalSql = NamedParameterUtils.substituteNamedParameters(parsedSql, null);
 		assertThat(finalSql).isEqualTo(expectedSql);
 	}
@@ -300,7 +300,7 @@ public class NamedParameterUtilsTests {
 		String sql = "SELECT ':foo'':doo', :xxx FROM DUAL";
 		ParsedSql psql = NamedParameterUtils.parseSqlStatement(sql);
 		assertThat(psql.getTotalParameterCount()).isEqualTo(1);
-		assertThat(psql.getParameterNames().get(0)).isEqualTo("xxx");
+		assertThat(psql.getParameterNames()).element(0).isEqualTo("xxx");
 	}
 
 	@Test
@@ -308,7 +308,7 @@ public class NamedParameterUtilsTests {
 		String sql = "SELECT /*:doo*/':foo', :xxx FROM DUAL";
 		ParsedSql psql = NamedParameterUtils.parseSqlStatement(sql);
 		assertThat(psql.getTotalParameterCount()).isEqualTo(1);
-		assertThat(psql.getParameterNames().get(0)).isEqualTo("xxx");
+		assertThat(psql.getParameterNames()).element(0).isEqualTo("xxx");
 	}
 
 	@Test
@@ -316,7 +316,7 @@ public class NamedParameterUtilsTests {
 		String sql2 = "SELECT ':foo'/*:doo*/, :xxx FROM DUAL";
 		ParsedSql psql2 = NamedParameterUtils.parseSqlStatement(sql2);
 		assertThat(psql2.getTotalParameterCount()).isEqualTo(1);
-		assertThat(psql2.getParameterNames().get(0)).isEqualTo("xxx");
+		assertThat(psql2.getParameterNames()).element(0).isEqualTo("xxx");
 	}
 
 	@Test  // gh-27716

spring-jdbc/src/test/java/org/springframework/jdbc/core/simple/JdbcClientQueryTests.java

@@ -150,7 +150,7 @@ public class JdbcClientQueryTests {
 				.query().singleColumn();
 
 		assertThat(li.size()).as("All rows returned").isEqualTo(1);
-		assertThat(li.get(0)).as("First row is Integer").isEqualTo(11);
+		assertThat(li).element(0).as("First row is Integer").isEqualTo(11);
 		verify(connection).prepareStatement("SELECT AGE FROM CUSTMR WHERE ID < ?");
 		verify(preparedStatement).setObject(1, 3);
 		verify(resultSet).close();
@@ -335,7 +335,7 @@ public class JdbcClientQueryTests {
 				.query().singleColumn();
 
 		assertThat(li.size()).as("All rows returned").isEqualTo(1);
-		assertThat(li.get(0)).as("First row is Integer").isEqualTo(11);
+		assertThat(li).element(0).as("First row is Integer").isEqualTo(11);
 		verify(connection).prepareStatement("SELECT AGE FROM CUSTMR WHERE ID < ?");
 		verify(preparedStatement).setObject(1, 3);
 		verify(resultSet).close();

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

@@ -363,8 +363,8 @@ public class StoredProcedureTests {
 		assertThat(res.size()).as("incorrect number of returns").isEqualTo(1);
 		List<String> rs1 = (List<String>) res.get("rs");
 		assertThat(rs1).hasSize(2);
-		assertThat(rs1.get(0)).isEqualTo("Foo");
-		assertThat(rs1.get(1)).isEqualTo("Bar");
+		assertThat(rs1).element(0).isEqualTo("Foo");
+		assertThat(rs1).element(1).isEqualTo("Bar");
 		verify(resultSet).close();
 	}
 

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

@@ -288,10 +288,10 @@ public class MessageBrokerConfigurationTests {
 
 		List<MessageConverter> converters = compositeConverter.getConverters();
 		assertThat(converters).hasSize(4);
-		assertThat(converters.get(0)).isInstanceOf(StringMessageConverter.class);
-		assertThat(converters.get(1)).isInstanceOf(ByteArrayMessageConverter.class);
-		assertThat(converters.get(2)).isInstanceOf(KotlinSerializationJsonMessageConverter.class);
-		assertThat(converters.get(3)).isInstanceOf(MappingJackson2MessageConverter.class);
+		assertThat(converters).element(0).isInstanceOf(StringMessageConverter.class);
+		assertThat(converters).element(1).isInstanceOf(ByteArrayMessageConverter.class);
+		assertThat(converters).element(2).isInstanceOf(KotlinSerializationJsonMessageConverter.class);
+		assertThat(converters).element(3).isInstanceOf(MappingJackson2MessageConverter.class);
 
 		ContentTypeResolver resolver = ((MappingJackson2MessageConverter) converters.get(3)).getContentTypeResolver();
 		assertThat(((DefaultContentTypeResolver) resolver).getDefaultMimeType()).isEqualTo(MimeTypeUtils.APPLICATION_JSON);

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

@@ -598,7 +598,7 @@ public class DefaultStompSessionTests {
 		assertThat(received.get()).isTrue();
 		assertThat(receivedHeaders.get()).isNotNull();
 		assertThat(receivedHeaders.get().get("foo")).hasSize(1);
-		assertThat(receivedHeaders.get().get("foo").get(0)).isEqualTo("bar");
+		assertThat(receivedHeaders.get().get("foo")).element(0).isEqualTo("bar");
 	}
 
 	@Test
@@ -629,7 +629,7 @@ public class DefaultStompSessionTests {
 		assertThat(received.get()).isTrue();
 		assertThat(receivedHeaders.get()).isNotNull();
 		assertThat(receivedHeaders.get().get("foo")).hasSize(1);
-		assertThat(receivedHeaders.get().get("foo").get(0)).isEqualTo("bar");
+		assertThat(receivedHeaders.get().get("foo")).element(0).isEqualTo("bar");
 	}
 
 	@Test
@@ -689,7 +689,7 @@ public class DefaultStompSessionTests {
 		headers = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
 		assertThat(headers).as(headers.toString()).hasSize(1);
 		assertThat(headers.get("foo")).hasSize(1);
-		assertThat(headers.get("foo").get(0)).isEqualTo("bar");
+		assertThat(headers.get("foo")).element(0).isEqualTo("bar");
 
 		assertThat(this.session.isConnected()).isFalse();
 		verifyNoMoreInteractions(this.sessionHandler);

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

@@ -111,8 +111,8 @@ public class StompHeaderAccessorTests {
 		assertThat(headerAccessor.toString()).contains("passcode=[PROTECTED]");
 
 		Map<String, List<String>> output = headerAccessor.toNativeHeaderMap();
-		assertThat(output.get(StompHeaderAccessor.STOMP_LOGIN_HEADER).get(0)).isEqualTo("joe");
-		assertThat(output.get(StompHeaderAccessor.STOMP_PASSCODE_HEADER).get(0)).isEqualTo("PROTECTED");
+		assertThat(output.get(StompHeaderAccessor.STOMP_LOGIN_HEADER)).element(0).isEqualTo("joe");
+		assertThat(output.get(StompHeaderAccessor.STOMP_PASSCODE_HEADER)).element(0).isEqualTo("PROTECTED");
 	}
 
 	@Test
@@ -124,8 +124,8 @@ public class StompHeaderAccessorTests {
 		Map<String, List<String>> actual = headers.toNativeHeaderMap();
 
 		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");
+		assertThat(actual.get(StompHeaderAccessor.STOMP_ID_HEADER)).element(0).isEqualTo("s1");
+		assertThat(actual.get(StompHeaderAccessor.STOMP_DESTINATION_HEADER)).element(0).isEqualTo("/d");
 	}
 
 	@Test
@@ -136,7 +136,7 @@ public class StompHeaderAccessorTests {
 		Map<String, List<String>> actual = headers.toNativeHeaderMap();
 
 		assertThat(actual).hasSize(1);
-		assertThat(actual.get(StompHeaderAccessor.STOMP_ID_HEADER).get(0)).isEqualTo("s1");
+		assertThat(actual.get(StompHeaderAccessor.STOMP_ID_HEADER)).element(0).isEqualTo("s1");
 	}
 
 	@Test
@@ -150,10 +150,10 @@ public class StompHeaderAccessorTests {
 		Map<String, List<String>> actual = headers.toNativeHeaderMap();
 
 		assertThat(actual.size()).as(actual.toString()).isEqualTo(4);
-		assertThat(actual.get(StompHeaderAccessor.STOMP_SUBSCRIPTION_HEADER).get(0)).isEqualTo("s1");
-		assertThat(actual.get(StompHeaderAccessor.STOMP_DESTINATION_HEADER).get(0)).isEqualTo("/d");
-		assertThat(actual.get(StompHeaderAccessor.STOMP_CONTENT_TYPE_HEADER).get(0)).isEqualTo("application/json");
-		assertThat(actual.get(StompHeaderAccessor.STOMP_MESSAGE_ID_HEADER).get(0)).as("message-id was not created").isNotNull();
+		assertThat(actual.get(StompHeaderAccessor.STOMP_SUBSCRIPTION_HEADER)).element(0).isEqualTo("s1");
+		assertThat(actual.get(StompHeaderAccessor.STOMP_DESTINATION_HEADER)).element(0).isEqualTo("/d");
+		assertThat(actual.get(StompHeaderAccessor.STOMP_CONTENT_TYPE_HEADER)).element(0).isEqualTo("application/json");
+		assertThat(actual.get(StompHeaderAccessor.STOMP_MESSAGE_ID_HEADER)).element(0).as("message-id was not created").isNotNull();
 	}
 
 	@Test
@@ -165,7 +165,7 @@ public class StompHeaderAccessorTests {
 		StompHeaderAccessor stompHeaderAccessor = StompHeaderAccessor.wrap(message);
 		Map<String, List<String>> map = stompHeaderAccessor.toNativeHeaderMap();
 
-		assertThat(map.get(StompHeaderAccessor.STOMP_CONTENT_TYPE_HEADER).get(0)).isEqualTo("application/atom+xml");
+		assertThat(map.get(StompHeaderAccessor.STOMP_CONTENT_TYPE_HEADER)).element(0).isEqualTo("application/atom+xml");
 	}
 
 	@Test
@@ -195,9 +195,9 @@ public class StompHeaderAccessorTests {
 		Map<String, List<String>> actual = headers.toNativeHeaderMap();
 		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");
-		assertThat(actual.get("accountId").get(0)).as("abc123").isNotNull();
+		assertThat(actual.get(StompHeaderAccessor.STOMP_ID_HEADER)).element(0).isEqualTo("s1");
+		assertThat(actual.get(StompHeaderAccessor.STOMP_DESTINATION_HEADER)).element(0).isEqualTo("/d");
+		assertThat(actual.get("accountId")).element(0).as("abc123").isNotNull();
 	}
 
 	@Test

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

@@ -61,8 +61,8 @@ public class PersistenceXmlParsingTests {
 		assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement");
 
 		assertThat(info[0].getJarFileUrls()).hasSize(2);
-		assertThat(info[0].getJarFileUrls().get(0)).isEqualTo(new ClassPathResource("order.jar").getURL());
-		assertThat(info[0].getJarFileUrls().get(1)).isEqualTo(new ClassPathResource("order-supplemental.jar").getURL());
+		assertThat(info[0].getJarFileUrls()).element(0).isEqualTo(new ClassPathResource("order.jar").getURL());
+		assertThat(info[0].getJarFileUrls()).element(1).isEqualTo(new ClassPathResource("order-supplemental.jar").getURL());
 
 		assertThat(info[0].excludeUnlistedClasses()).as("Exclude unlisted should default false in 1.0.").isFalse();
 	}
@@ -94,7 +94,7 @@ public class PersistenceXmlParsingTests {
 		assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement2");
 
 		assertThat(info[0].getMappingFileNames()).hasSize(1);
-		assertThat(info[0].getMappingFileNames().get(0)).isEqualTo("mappings.xml");
+		assertThat(info[0].getMappingFileNames()).element(0).isEqualTo("mappings.xml");
 		assertThat(info[0].getProperties()).isEmpty();
 
 		assertThat(info[0].excludeUnlistedClasses()).as("Exclude unlisted should default false in 1.0.").isFalse();
@@ -112,8 +112,8 @@ public class PersistenceXmlParsingTests {
 		assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement3");
 
 		assertThat(info[0].getJarFileUrls()).hasSize(2);
-		assertThat(info[0].getJarFileUrls().get(0)).isEqualTo(new ClassPathResource("order.jar").getURL());
-		assertThat(info[0].getJarFileUrls().get(1)).isEqualTo(new ClassPathResource("order-supplemental.jar").getURL());
+		assertThat(info[0].getJarFileUrls()).element(0).isEqualTo(new ClassPathResource("order.jar").getURL());
+		assertThat(info[0].getJarFileUrls()).element(1).isEqualTo(new ClassPathResource("order-supplemental.jar").getURL());
 
 		assertThat(info[0].getProperties()).isEmpty();
 		assertThat(info[0].getJtaDataSource()).isNull();
@@ -138,12 +138,12 @@ public class PersistenceXmlParsingTests {
 		assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement4");
 
 		assertThat(info[0].getMappingFileNames()).hasSize(1);
-		assertThat(info[0].getMappingFileNames().get(0)).isEqualTo("order-mappings.xml");
+		assertThat(info[0].getMappingFileNames()).element(0).isEqualTo("order-mappings.xml");
 
 		assertThat(info[0].getManagedClassNames()).hasSize(3);
-		assertThat(info[0].getManagedClassNames().get(0)).isEqualTo("com.acme.Order");
-		assertThat(info[0].getManagedClassNames().get(1)).isEqualTo("com.acme.Customer");
-		assertThat(info[0].getManagedClassNames().get(2)).isEqualTo("com.acme.Item");
+		assertThat(info[0].getManagedClassNames()).element(0).isEqualTo("com.acme.Order");
+		assertThat(info[0].getManagedClassNames()).element(1).isEqualTo("com.acme.Customer");
+		assertThat(info[0].getManagedClassNames()).element(2).isEqualTo("com.acme.Item");
 
 		assertThat(info[0].excludeUnlistedClasses()).as("Exclude unlisted should be true when no value.").isTrue();
 
@@ -165,12 +165,12 @@ public class PersistenceXmlParsingTests {
 		assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement5");
 
 		assertThat(info[0].getMappingFileNames()).hasSize(2);
-		assertThat(info[0].getMappingFileNames().get(0)).isEqualTo("order1.xml");
-		assertThat(info[0].getMappingFileNames().get(1)).isEqualTo("order2.xml");
+		assertThat(info[0].getMappingFileNames()).element(0).isEqualTo("order1.xml");
+		assertThat(info[0].getMappingFileNames()).element(1).isEqualTo("order2.xml");
 
 		assertThat(info[0].getJarFileUrls()).hasSize(2);
-		assertThat(info[0].getJarFileUrls().get(0)).isEqualTo(new ClassPathResource("order.jar").getURL());
-		assertThat(info[0].getJarFileUrls().get(1)).isEqualTo(new ClassPathResource("order-supplemental.jar").getURL());
+		assertThat(info[0].getJarFileUrls()).element(0).isEqualTo(new ClassPathResource("order.jar").getURL());
+		assertThat(info[0].getJarFileUrls()).element(1).isEqualTo(new ClassPathResource("order-supplemental.jar").getURL());
 
 		assertThat(info[0].getPersistenceProviderClassName()).isEqualTo("com.acme.AcmePersistence");
 		assertThat(info[0].getProperties()).isEmpty();
@@ -201,10 +201,10 @@ public class PersistenceXmlParsingTests {
 		assertThat(pu1.getPersistenceProviderClassName()).isEqualTo("com.acme.AcmePersistence");
 
 		assertThat(pu1.getMappingFileNames()).hasSize(1);
-		assertThat(pu1.getMappingFileNames().get(0)).isEqualTo("ormap2.xml");
+		assertThat(pu1.getMappingFileNames()).element(0).isEqualTo("ormap2.xml");
 
 		assertThat(pu1.getJarFileUrls()).hasSize(1);
-		assertThat(pu1.getJarFileUrls().get(0)).isEqualTo(new ClassPathResource("order.jar").getURL());
+		assertThat(pu1.getJarFileUrls()).element(0).isEqualTo(new ClassPathResource("order.jar").getURL());
 
 		assertThat(pu1.excludeUnlistedClasses()).isFalse();
 
@@ -225,7 +225,7 @@ public class PersistenceXmlParsingTests {
 		assertThat(pu2.getPersistenceProviderClassName()).isEqualTo("com.acme.AcmePersistence");
 
 		assertThat(pu2.getMappingFileNames()).hasSize(1);
-		assertThat(pu2.getMappingFileNames().get(0)).isEqualTo("order2.xml");
+		assertThat(pu2.getMappingFileNames()).element(0).isEqualTo("order2.xml");
 
 		// the following assertions fail only during coverage runs
 		// assertEquals(1, pu2.getJarFileUrls().size());

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

@@ -400,8 +400,8 @@ class MockHttpServletResponseTests {
 	void addDateHeader() {
 		response.addDateHeader(LAST_MODIFIED, 1437472800000L);
 		response.addDateHeader(LAST_MODIFIED, 1437472801000L);
-		assertThat(response.getHeaders(LAST_MODIFIED).get(0)).isEqualTo("Tue, 21 Jul 2015 10:00:00 GMT");
-		assertThat(response.getHeaders(LAST_MODIFIED).get(1)).isEqualTo("Tue, 21 Jul 2015 10:00:01 GMT");
+		assertThat(response.getHeaders(LAST_MODIFIED)).element(0).isEqualTo("Tue, 21 Jul 2015 10:00:00 GMT");
+		assertThat(response.getHeaders(LAST_MODIFIED)).element(1).isEqualTo("Tue, 21 Jul 2015 10:00:01 GMT");
 	}
 
 	@Test

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

@@ -367,7 +367,7 @@ class MockHttpServletRequestBuilderTests {
 
 		assertThat(contentType).isEqualTo("text/html");
 		assertThat(contentTypes).hasSize(1);
-		assertThat(contentTypes.get(0)).isEqualTo("text/html");
+		assertThat(contentTypes).element(0).isEqualTo("text/html");
 	}
 
 	@Test
@@ -380,7 +380,7 @@ class MockHttpServletRequestBuilderTests {
 
 		assertThat(contentType).isEqualTo("text/html");
 		assertThat(contentTypes).hasSize(1);
-		assertThat(contentTypes.get(0)).isEqualTo("text/html");
+		assertThat(contentTypes).element(0).isEqualTo("text/html");
 	}
 
 	@Test // gh-2079
@@ -434,8 +434,8 @@ class MockHttpServletRequestBuilderTests {
 		List<String> headers = Collections.list(request.getHeaders("foo"));
 
 		assertThat(headers).hasSize(2);
-		assertThat(headers.get(0)).isEqualTo("bar");
-		assertThat(headers.get(1)).isEqualTo("baz");
+		assertThat(headers).element(0).isEqualTo("bar");
+		assertThat(headers).element(1).isEqualTo("baz");
 	}
 
 	@Test
@@ -449,8 +449,8 @@ class MockHttpServletRequestBuilderTests {
 		List<String> headers = Collections.list(request.getHeaders("foo"));
 
 		assertThat(headers).hasSize(2);
-		assertThat(headers.get(0)).isEqualTo("bar");
-		assertThat(headers.get(1)).isEqualTo("baz");
+		assertThat(headers).element(0).isEqualTo("bar");
+		assertThat(headers).element(1).isEqualTo("baz");
 		assertThat(request.getHeader("Content-Type")).isEqualTo(MediaType.APPLICATION_JSON.toString());
 	}
 

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

@@ -168,8 +168,8 @@ class PrintingResultHandlerTests {
 		// Manually validate cookie values since maxAge changes...
 		List<String> cookieValues = this.response.getHeaders("Set-Cookie");
 		assertThat(cookieValues).hasSize(2);
-		assertThat(cookieValues.get(0)).isEqualTo("cookie=cookieValue");
-		assertThat(cookieValues.get(1)).as("Actual: " + cookieValues.get(1))
+		assertThat(cookieValues).element(0).isEqualTo("cookie=cookieValue");
+		assertThat(cookieValues).element(1).asString().as("Actual: " + cookieValues.get(1))
 				.startsWith("enigma=42; Path=/crumbs; Domain=.example.com; Max-Age=1234; Expires=");
 
 		HttpHeaders headers = new HttpHeaders();

spring-web/src/test/java/org/springframework/http/HttpHeadersTests.java

@@ -201,7 +201,7 @@ public class HttpHeadersTests {
 	void ifMatch() {
 		String ifMatch = "\"v2.6\"";
 		headers.setIfMatch(ifMatch);
-		assertThat(headers.getIfMatch().get(0)).as("Invalid If-Match header").isEqualTo(ifMatch);
+		assertThat(headers.getIfMatch()).element(0).as("Invalid If-Match header").isEqualTo(ifMatch);
 		assertThat(headers.getFirst("If-Match")).as("Invalid If-Match header").isEqualTo("\"v2.6\"");
 	}
 
@@ -215,8 +215,8 @@ public class HttpHeadersTests {
 	void ifMatchMultipleHeaders() {
 		headers.add(HttpHeaders.IF_MATCH, "\"v2,0\"");
 		headers.add(HttpHeaders.IF_MATCH, "W/\"v2,1\", \"v2,2\"");
-		assertThat(headers.get(HttpHeaders.IF_MATCH).get(0)).as("Invalid If-Match header").isEqualTo("\"v2,0\"");
-		assertThat(headers.get(HttpHeaders.IF_MATCH).get(1)).as("Invalid If-Match header").isEqualTo("W/\"v2,1\", \"v2,2\"");
+		assertThat(headers.get(HttpHeaders.IF_MATCH)).element(0).as("Invalid If-Match header").isEqualTo("\"v2,0\"");
+		assertThat(headers.get(HttpHeaders.IF_MATCH)).element(1).as("Invalid If-Match header").isEqualTo("W/\"v2,1\", \"v2,2\"");
 		assertThat(headers.getIfMatch()).contains("\"v2,0\"", "W/\"v2,1\"", "\"v2,2\"");
 	}
 
@@ -224,7 +224,7 @@ public class HttpHeadersTests {
 	void ifNoneMatch() {
 		String ifNoneMatch = "\"v2.6\"";
 		headers.setIfNoneMatch(ifNoneMatch);
-		assertThat(headers.getIfNoneMatch().get(0)).as("Invalid If-None-Match header").isEqualTo(ifNoneMatch);
+		assertThat(headers.getIfNoneMatch()).element(0).as("Invalid If-None-Match header").isEqualTo(ifNoneMatch);
 		assertThat(headers.getFirst("If-None-Match")).as("Invalid If-None-Match header").isEqualTo("\"v2.6\"");
 	}
 
@@ -232,7 +232,7 @@ public class HttpHeadersTests {
 	void ifNoneMatchWildCard() {
 		String ifNoneMatch = "*";
 		headers.setIfNoneMatch(ifNoneMatch);
-		assertThat(headers.getIfNoneMatch().get(0)).as("Invalid If-None-Match header").isEqualTo(ifNoneMatch);
+		assertThat(headers.getIfNoneMatch()).element(0).as("Invalid If-None-Match header").isEqualTo(ifNoneMatch);
 		assertThat(headers.getFirst("If-None-Match")).as("Invalid If-None-Match header").isEqualTo("*");
 	}
 
@@ -485,10 +485,10 @@ public class HttpHeadersTests {
 				new Locale.LanguageRange("*", 0.5)
 		);
 		assertThat(headers.getAcceptLanguage()).isEqualTo(expectedRanges);
-		assertThat(headers.getAcceptLanguageAsLocales().get(0)).isEqualTo(Locale.forLanguageTag("fr-ch"));
+		assertThat(headers.getAcceptLanguageAsLocales()).element(0).isEqualTo(Locale.forLanguageTag("fr-ch"));
 
 		headers.setAcceptLanguageAsLocales(Collections.singletonList(Locale.FRANCE));
-		assertThat(headers.getAcceptLanguageAsLocales().get(0)).isEqualTo(Locale.FRANCE);
+		assertThat(headers.getAcceptLanguageAsLocales()).element(0).isEqualTo(Locale.FRANCE);
 	}
 
 	@Test // SPR-15603
@@ -671,7 +671,7 @@ public class HttpHeadersTests {
 		headers.keySet().removeIf(key -> key.equals(headerName));
 		assertThat(headers.isEmpty()).isTrue();
 		headers.add(headerName, headerValue);
-		assertThat(headers.get(headerName).get(0)).isEqualTo(headerValue);
+		assertThat(headers.get(headerName)).element(0).isEqualTo(headerValue);
 	}
 
 	@Test
@@ -685,7 +685,7 @@ public class HttpHeadersTests {
 		headers.entrySet().removeIf(entry -> entry.getKey().equals(headerName));
 		assertThat(headers.isEmpty()).isTrue();
 		headers.add(headerName, headerValue);
-		assertThat(headers.get(headerName).get(0)).isEqualTo(headerValue);
+		assertThat(headers.get(headerName)).element(0).isEqualTo(headerValue);
 	}
 
 	@Test

spring-web/src/test/java/org/springframework/http/client/InterceptingClientHttpRequestFactoryTests.java

@@ -104,8 +104,8 @@ class InterceptingClientHttpRequestFactoryTests {
 			protected ClientHttpResponse executeInternal() throws IOException {
 				List<String> headerValues = getHeaders().get(headerName);
 				assertThat(headerValues).hasSize(2);
-				assertThat(headerValues.get(0)).isEqualTo(headerValue);
-				assertThat(headerValues.get(1)).isEqualTo(otherValue);
+				assertThat(headerValues).element(0).isEqualTo(headerValue);
+				assertThat(headerValues).element(1).isEqualTo(otherValue);
 				return responseMock;
 			}
 		};

spring-web/src/test/java/org/springframework/http/client/support/InterceptingHttpAccessorTests.java

@@ -49,9 +49,9 @@ public class InterceptingHttpAccessorTests {
 		);
 		accessor.setInterceptors(interceptors);
 
-		assertThat(accessor.getInterceptors().get(0)).isInstanceOf(FirstClientHttpRequestInterceptor.class);
-		assertThat(accessor.getInterceptors().get(1)).isInstanceOf(SecondClientHttpRequestInterceptor.class);
-		assertThat(accessor.getInterceptors().get(2)).isInstanceOf(ThirdClientHttpRequestInterceptor.class);
+		assertThat(accessor.getInterceptors()).element(0).isInstanceOf(FirstClientHttpRequestInterceptor.class);
+		assertThat(accessor.getInterceptors()).element(1).isInstanceOf(SecondClientHttpRequestInterceptor.class);
+		assertThat(accessor.getInterceptors()).element(2).isInstanceOf(ThirdClientHttpRequestInterceptor.class);
 	}
 
 

spring-web/src/test/java/org/springframework/http/codec/FormHttpMessageReaderTests.java

@@ -83,8 +83,8 @@ public class FormHttpMessageReaderTests extends AbstractLeakCheckingTests {
 		assertThat(result.getFirst("name 1")).as("Invalid result").isEqualTo("value 1");
 		List<String> values = result.get("name 2");
 		assertThat(values).as("Invalid result").hasSize(2);
-		assertThat(values.get(0)).as("Invalid result").isEqualTo("value 2+1");
-		assertThat(values.get(1)).as("Invalid result").isEqualTo("value 2+2");
+		assertThat(values).element(0).as("Invalid result").isEqualTo("value 2+1");
+		assertThat(values).element(1).as("Invalid result").isEqualTo("value 2+2");
 		assertThat(result.getFirst("name 3")).as("Invalid result").isNull();
 	}
 
@@ -98,8 +98,8 @@ public class FormHttpMessageReaderTests extends AbstractLeakCheckingTests {
 		assertThat(result.getFirst("name 1")).as("Invalid result").isEqualTo("value 1");
 		List<String> values = result.get("name 2");
 		assertThat(values).as("Invalid result").hasSize(2);
-		assertThat(values.get(0)).as("Invalid result").isEqualTo("value 2+1");
-		assertThat(values.get(1)).as("Invalid result").isEqualTo("value 2+2");
+		assertThat(values).element(0).as("Invalid result").isEqualTo("value 2+1");
+		assertThat(values).element(1).as("Invalid result").isEqualTo("value 2+2");
 		assertThat(result.getFirst("name 3")).as("Invalid result").isNull();
 	}
 

spring-web/src/test/java/org/springframework/http/converter/FormHttpMessageConverterTests.java

@@ -128,8 +128,8 @@ public class FormHttpMessageConverterTests {
 		assertThat(result.getFirst("name 1")).as("Invalid result").isEqualTo("value 1");
 		List<String> values = result.get("name 2");
 		assertThat(values).as("Invalid result").hasSize(2);
-		assertThat(values.get(0)).as("Invalid result").isEqualTo("value 2+1");
-		assertThat(values.get(1)).as("Invalid result").isEqualTo("value 2+2");
+		assertThat(values).element(0).as("Invalid result").isEqualTo("value 2+1");
+		assertThat(values).element(1).as("Invalid result").isEqualTo("value 2+2");
 		assertThat(result.getFirst("name 3")).as("Invalid result").isNull();
 	}
 

spring-web/src/test/java/org/springframework/http/converter/ResourceRegionHttpMessageConverterTests.java

@@ -86,7 +86,7 @@ public class ResourceRegionHttpMessageConverterTests {
 		assertThat(headers.getContentType()).isEqualTo(MediaType.TEXT_PLAIN);
 		assertThat(headers.getContentLength()).isEqualTo(6L);
 		assertThat(headers.get(HttpHeaders.CONTENT_RANGE)).hasSize(1);
-		assertThat(headers.get(HttpHeaders.CONTENT_RANGE).get(0)).isEqualTo("bytes 0-5/39");
+		assertThat(headers.get(HttpHeaders.CONTENT_RANGE)).element(0).isEqualTo("bytes 0-5/39");
 		assertThat(outputMessage.getBodyAsString(StandardCharsets.UTF_8)).isEqualTo("Spring");
 	}
 
@@ -101,7 +101,7 @@ public class ResourceRegionHttpMessageConverterTests {
 		assertThat(headers.getContentType()).isEqualTo(MediaType.TEXT_PLAIN);
 		assertThat(headers.getContentLength()).isEqualTo(32L);
 		assertThat(headers.get(HttpHeaders.CONTENT_RANGE)).hasSize(1);
-		assertThat(headers.get(HttpHeaders.CONTENT_RANGE).get(0)).isEqualTo("bytes 7-38/39");
+		assertThat(headers.get(HttpHeaders.CONTENT_RANGE)).element(0).isEqualTo("bytes 7-38/39");
 		assertThat(outputMessage.getBodyAsString(StandardCharsets.UTF_8)).isEqualTo("Framework test resource content.");
 	}
 

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

@@ -79,7 +79,7 @@ class ChannelSendOperatorTests {
 		assertThat(signal.isOnComplete()).as("Unexpected signal: " + signal).isTrue();
 
 		assertThat(this.writer.items).hasSize(1);
-		assertThat(this.writer.items.get(0)).isEqualTo("one");
+		assertThat(this.writer.items).element(0).isEqualTo("one");
 		assertThat(this.writer.completed).isTrue();
 	}
 
@@ -94,9 +94,9 @@ class ChannelSendOperatorTests {
 		assertThat(signal.isOnComplete()).as("Unexpected signal: " + signal).isTrue();
 
 		assertThat(this.writer.items).hasSize(3);
-		assertThat(this.writer.items.get(0)).isEqualTo("one");
-		assertThat(this.writer.items.get(1)).isEqualTo("two");
-		assertThat(this.writer.items.get(2)).isEqualTo("three");
+		assertThat(this.writer.items).element(0).isEqualTo("one");
+		assertThat(this.writer.items).element(1).isEqualTo("two");
+		assertThat(this.writer.items).element(2).isEqualTo("three");
 		assertThat(this.writer.completed).isTrue();
 	}
 
@@ -118,9 +118,9 @@ class ChannelSendOperatorTests {
 		assertThat(signal.getThrowable()).as("Unexpected signal: " + signal).isSameAs(error);
 
 		assertThat(this.writer.items).hasSize(3);
-		assertThat(this.writer.items.get(0)).isEqualTo("1");
-		assertThat(this.writer.items.get(1)).isEqualTo("2");
-		assertThat(this.writer.items.get(2)).isEqualTo("3");
+		assertThat(this.writer.items).element(0).isEqualTo("1");
+		assertThat(this.writer.items).element(1).isEqualTo("2");
+		assertThat(this.writer.items).element(2).isEqualTo("3");
 		assertThat(this.writer.error).isSameAs(error);
 	}
 

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

@@ -89,7 +89,7 @@ class HeadersAdaptersTests {
 		headers.add("TestHeader", "first");
 		headers.add("TestHeader", "second");
 		assertThat(headers.getFirst("TestHeader")).isEqualTo("first");
-		assertThat(headers.get("TestHeader").get(0)).isEqualTo("first");
+		assertThat(headers.get("TestHeader")).element(0).isEqualTo("first");
 	}
 
 	@ParameterizedHeadersTest

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

@@ -65,7 +65,7 @@ public class ListenerWriteProcessorTests {
 
 		assertThat(this.resultSubscriber.getError()).as("Error should flow to result publisher").isNotNull();
 		assertThat(this.processor.getDiscardedBuffers()).hasSize(1);
-		assertThat(this.processor.getDiscardedBuffers().get(0)).isSameAs(buffer);
+		assertThat(this.processor.getDiscardedBuffers()).element(0).isSameAs(buffer);
 	}
 
 	@Test // SPR-17410
@@ -81,7 +81,7 @@ public class ListenerWriteProcessorTests {
 
 		assertThat(this.resultSubscriber.getError()).as("Error should flow to result publisher").isNotNull();
 		assertThat(this.processor.getDiscardedBuffers()).hasSize(1);
-		assertThat(this.processor.getDiscardedBuffers().get(0)).isSameAs(buffer);
+		assertThat(this.processor.getDiscardedBuffers()).element(0).isSameAs(buffer);
 	}
 
 	@Test // SPR-17410
@@ -98,8 +98,8 @@ public class ListenerWriteProcessorTests {
 
 		assertThat(this.resultSubscriber.getError()).as("Error should flow to result publisher").isNotNull();
 		assertThat(this.processor.getDiscardedBuffers()).hasSize(2);
-		assertThat(this.processor.getDiscardedBuffers().get(0)).isSameAs(buffer2);
-		assertThat(this.processor.getDiscardedBuffers().get(1)).isSameAs(buffer1);
+		assertThat(this.processor.getDiscardedBuffers()).element(0).isSameAs(buffer2);
+		assertThat(this.processor.getDiscardedBuffers()).element(1).isSameAs(buffer1);
 	}
 
 

spring-web/src/test/java/org/springframework/web/accept/ContentNegotiationManagerFactoryBeanTests.java

@@ -243,11 +243,11 @@ class ContentNegotiationManagerFactoryBeanTests {
 		this.factoryBean.afterPropertiesSet();
 		ContentNegotiationManager manager = this.factoryBean.getObject();
 
-		assertThat(manager.resolveMediaTypes(this.webRequest).get(0)).isEqualTo(MediaType.APPLICATION_JSON);
+		assertThat(manager.resolveMediaTypes(this.webRequest)).element(0).isEqualTo(MediaType.APPLICATION_JSON);
 
 		// SPR-10513
 		this.servletRequest.addHeader("Accept", MediaType.ALL_VALUE);
-		assertThat(manager.resolveMediaTypes(this.webRequest).get(0)).isEqualTo(MediaType.APPLICATION_JSON);
+		assertThat(manager.resolveMediaTypes(this.webRequest)).element(0).isEqualTo(MediaType.APPLICATION_JSON);
 	}
 
 	@Test // SPR-15367

spring-web/src/test/java/org/springframework/web/accept/MappingMediaTypeFileExtensionResolverTests.java

@@ -45,7 +45,7 @@ public class MappingMediaTypeFileExtensionResolverTests {
 				.resolveFileExtensions(MediaType.APPLICATION_JSON);
 
 		assertThat(extensions).hasSize(1);
-		assertThat(extensions.get(0)).isEqualTo("json");
+		assertThat(extensions).element(0).isEqualTo("json");
 	}
 
 	@Test

spring-web/src/test/java/org/springframework/web/client/RestTemplateTests.java

@@ -525,8 +525,8 @@ class RestTemplateTests {
 					.toList();
 
 			assertThat(accepts).hasSize(1);
-			assertThat(accepts.get(0)).hasSize(1);
-			assertThat(accepts.get(0).get(0)).isEqualTo("application/json");
+			assertThat(accepts).element(0).asList().hasSize(1);
+			assertThat(accepts.get(0)).element(0).isEqualTo("application/json");
 		}
 	}
 

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

@@ -69,7 +69,7 @@ public class StandardServletAsyncWebRequestTests {
 		assertThat(context).isNotNull();
 		assertThat(context.getTimeout()).as("Timeout value not set").isEqualTo((44 * 1000));
 		assertThat(context.getListeners()).hasSize(1);
-		assertThat(context.getListeners().get(0)).isSameAs(this.asyncRequest);
+		assertThat(context.getListeners()).element(0).isSameAs(this.asyncRequest);
 	}
 
 	@Test

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

@@ -147,10 +147,10 @@ public class RequestParamMapMethodArgumentResolverTests {
 		MultiValueMap<String, MultipartFile> resultMap = (MultiValueMap<String, MultipartFile>) result;
 		assertThat(resultMap).hasSize(2);
 		assertThat(resultMap.get("mfilelist")).hasSize(2);
-		assertThat(resultMap.get("mfilelist").get(0)).isEqualTo(expected1);
-		assertThat(resultMap.get("mfilelist").get(1)).isEqualTo(expected2);
+		assertThat(resultMap.get("mfilelist")).element(0).isEqualTo(expected1);
+		assertThat(resultMap.get("mfilelist")).element(1).isEqualTo(expected2);
 		assertThat(resultMap.get("other")).hasSize(1);
-		assertThat(resultMap.get("other").get(0)).isEqualTo(expected3);
+		assertThat(resultMap.get("other")).element(0).isEqualTo(expected3);
 	}
 
 	@Test
@@ -196,10 +196,10 @@ public class RequestParamMapMethodArgumentResolverTests {
 		MultiValueMap<String, Part> resultMap = (MultiValueMap<String, Part>) result;
 		assertThat(resultMap).hasSize(2);
 		assertThat(resultMap.get("mfilelist")).hasSize(2);
-		assertThat(resultMap.get("mfilelist").get(0)).isEqualTo(expected1);
-		assertThat(resultMap.get("mfilelist").get(1)).isEqualTo(expected2);
+		assertThat(resultMap.get("mfilelist")).element(0).isEqualTo(expected1);
+		assertThat(resultMap.get("mfilelist")).element(1).isEqualTo(expected2);
 		assertThat(resultMap.get("other")).hasSize(1);
-		assertThat(resultMap.get("other").get(0)).isEqualTo(expected3);
+		assertThat(resultMap.get("other")).element(0).isEqualTo(expected3);
 	}
 
 

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

@@ -380,7 +380,7 @@ public class RequestParamMethodArgumentResolverTests {
 		Object actual = resolver.resolveArgument(param, null, webRequest, null);
 		boolean condition = actual instanceof List;
 		assertThat(condition).isTrue();
-		assertThat(((List<?>) actual).get(0)).isEqualTo(expected);
+		assertThat(((List<?>) actual)).element(0).isEqualTo(expected);
 	}
 
 	@Test

spring-web/src/test/java/org/springframework/web/service/invoker/HttpServiceMethodTests.java

@@ -91,7 +91,7 @@ class HttpServiceMethodTests {
 		assertThat(voidEntity.getBody()).isNull();
 
 		List<String> list = service.getList();
-		assertThat(list.get(0)).isEqualTo("exchangeForBody");
+		assertThat(list).element(0).isEqualTo("exchangeForBody");
 	}
 
 	@Test

spring-web/src/test/java/org/springframework/web/util/UriComponentsBuilderTests.java

@@ -599,14 +599,14 @@ class UriComponentsBuilderTests {
 	void queryParamWithValueWithEquals() {
 		UriComponents uriComponents = UriComponentsBuilder.fromUriString("https://example.com/foo?bar=baz").build();
 		assertThat(uriComponents.toUriString()).isEqualTo("https://example.com/foo?bar=baz");
-		assertThat(uriComponents.getQueryParams().get("bar").get(0)).isEqualTo("baz");
+		assertThat(uriComponents.getQueryParams().get("bar")).element(0).isEqualTo("baz");
 	}
 
 	@Test
 	void queryParamWithoutValueWithEquals() {
 		UriComponents uriComponents = UriComponentsBuilder.fromUriString("https://example.com/foo?bar=").build();
 		assertThat(uriComponents.toUriString()).isEqualTo("https://example.com/foo?bar=");
-		assertThat(uriComponents.getQueryParams().get("bar").get(0)).isEmpty();
+		assertThat(uriComponents.getQueryParams().get("bar")).element(0).asString().isEmpty();
 	}
 
 	@Test
@@ -615,7 +615,7 @@ class UriComponentsBuilderTests {
 		assertThat(uriComponents.toUriString()).isEqualTo("https://example.com/foo?bar");
 
 		// TODO [SPR-13537] Change equalTo(null) to equalTo("").
-		assertThat(uriComponents.getQueryParams().get("bar").get(0)).isNull();
+		assertThat(uriComponents.getQueryParams().get("bar")).element(0).isNull();
 	}
 
 	@Test  // gh-24444

spring-web/src/test/java/org/springframework/web/util/pattern/PathPatternParserTests.java

@@ -365,7 +365,7 @@ public class PathPatternParserTests {
 		patterns.add(p3);
 		patterns.add(p1);
 		Collections.sort(patterns);
-		assertThat(patterns.get(0)).isEqualTo(p1);
+		assertThat(patterns).element(0).isEqualTo(p1);
 
 		// Based purely on length
 		p1 = parse("/a/b/c");
@@ -377,7 +377,7 @@ public class PathPatternParserTests {
 		patterns.add(p3);
 		patterns.add(p1);
 		Collections.sort(patterns);
-		assertThat(patterns.get(0)).isEqualTo(p3);
+		assertThat(patterns).element(0).isEqualTo(p3);
 
 		// Based purely on 'wildness'
 		p1 = parse("/*");
@@ -389,7 +389,7 @@ public class PathPatternParserTests {
 		patterns.add(p3);
 		patterns.add(p1);
 		Collections.sort(patterns);
-		assertThat(patterns.get(0)).isEqualTo(p1);
+		assertThat(patterns).element(0).isEqualTo(p1);
 
 		// Based purely on catchAll
 		p1 = parse("{*foobar}");
@@ -410,8 +410,8 @@ public class PathPatternParserTests {
 		patterns.add(p3);
 		patterns.add(p1);
 		Collections.sort(patterns);
-		assertThat(patterns.get(0)).isEqualTo(p3);
-		assertThat(patterns.get(1)).isEqualTo(p2);
+		assertThat(patterns).element(0).isEqualTo(p3);
+		assertThat(patterns).element(1).isEqualTo(p2);
 	}
 
 	@Test

spring-web/src/test/java/org/springframework/web/util/pattern/PathPatternTests.java

@@ -1043,15 +1043,15 @@ public class PathPatternTests {
 		paths.add(null);
 		paths.add(null);
 		paths.sort(comparator);
-		assertThat(paths.get(0)).isNull();
-		assertThat(paths.get(1)).isNull();
+		assertThat(paths).element(0).isNull();
+		assertThat(paths).element(1).isNull();
 		paths.clear();
 
 		paths.add(null);
 		paths.add(pp.parse("/hotels/new"));
 		paths.sort(comparator);
 		assertThat(paths.get(0).getPatternString()).isEqualTo("/hotels/new");
-		assertThat(paths.get(1)).isNull();
+		assertThat(paths).element(1).isNull();
 		paths.clear();
 
 		paths.add(pp.parse("/hotels/*"));

spring-webflux/src/test/java/org/springframework/web/reactive/config/ResourceHandlerRegistryTests.java

@@ -140,17 +140,17 @@ class ResourceHandlerRegistryTests {
 		ResourceWebHandler handler = getHandler("/resources/**");
 		List<ResourceResolver> resolvers = handler.getResourceResolvers();
 		assertThat(resolvers).hasSize(4);
-		assertThat(resolvers.get(0)).isInstanceOf(CachingResourceResolver.class);
+		assertThat(resolvers).element(0).isInstanceOf(CachingResourceResolver.class);
 		CachingResourceResolver cachingResolver = (CachingResourceResolver) resolvers.get(0);
 		assertThat(cachingResolver.getCache()).isInstanceOf(ConcurrentMapCache.class);
-		assertThat(resolvers.get(1)).isEqualTo(mockResolver);
-		assertThat(resolvers.get(2)).isInstanceOf(WebJarsResourceResolver.class);
-		assertThat(resolvers.get(3)).isInstanceOf(PathResourceResolver.class);
+		assertThat(resolvers).element(1).isEqualTo(mockResolver);
+		assertThat(resolvers).element(2).isInstanceOf(WebJarsResourceResolver.class);
+		assertThat(resolvers).element(3).isInstanceOf(PathResourceResolver.class);
 
 		List<ResourceTransformer> transformers = handler.getResourceTransformers();
 		assertThat(transformers).hasSize(2);
-		assertThat(transformers.get(0)).isInstanceOf(CachingResourceTransformer.class);
-		assertThat(transformers.get(1)).isEqualTo(mockTransformer);
+		assertThat(transformers).element(0).isInstanceOf(CachingResourceTransformer.class);
+		assertThat(transformers).element(1).isEqualTo(mockTransformer);
 		Mockito.verify(mockTransformer).setResourceUrlProvider(resourceUrlProvider);
 	}
 
@@ -161,8 +161,8 @@ class ResourceHandlerRegistryTests {
 		ResourceWebHandler handler = getHandler("/resources/**");
 		List<ResourceResolver> resolvers = handler.getResourceResolvers();
 		assertThat(resolvers).hasSize(2);
-		assertThat(resolvers.get(0)).isInstanceOf(WebJarsResourceResolver.class);
-		assertThat(resolvers.get(1)).isInstanceOf(PathResourceResolver.class);
+		assertThat(resolvers).element(0).isInstanceOf(WebJarsResourceResolver.class);
+		assertThat(resolvers).element(1).isInstanceOf(PathResourceResolver.class);
 
 		List<ResourceTransformer> transformers = handler.getResourceTransformers();
 		assertThat(transformers).isEmpty();
@@ -179,15 +179,15 @@ class ResourceHandlerRegistryTests {
 		ResourceWebHandler handler = getHandler("/resources/**");
 		List<ResourceResolver> resolvers = handler.getResourceResolvers();
 		assertThat(resolvers).hasSize(4);
-		assertThat(resolvers.get(0)).isInstanceOf(CachingResourceResolver.class);
-		assertThat(resolvers.get(1)).isSameAs(versionResolver);
-		assertThat(resolvers.get(2)).isInstanceOf(WebJarsResourceResolver.class);
-		assertThat(resolvers.get(3)).isInstanceOf(PathResourceResolver.class);
+		assertThat(resolvers).element(0).isInstanceOf(CachingResourceResolver.class);
+		assertThat(resolvers).element(1).isSameAs(versionResolver);
+		assertThat(resolvers).element(2).isInstanceOf(WebJarsResourceResolver.class);
+		assertThat(resolvers).element(3).isInstanceOf(PathResourceResolver.class);
 
 		List<ResourceTransformer> transformers = handler.getResourceTransformers();
 		assertThat(transformers).hasSize(2);
-		assertThat(transformers.get(0)).isInstanceOf(CachingResourceTransformer.class);
-		assertThat(transformers.get(1)).isInstanceOf(CssLinkResourceTransformer.class);
+		assertThat(transformers).element(0).isInstanceOf(CachingResourceTransformer.class);
+		assertThat(transformers).element(1).isInstanceOf(CssLinkResourceTransformer.class);
 	}
 
 	@Test
@@ -212,15 +212,15 @@ class ResourceHandlerRegistryTests {
 		ResourceWebHandler handler = getHandler("/resources/**");
 		List<ResourceResolver> resolvers = handler.getResourceResolvers();
 		assertThat(resolvers).hasSize(4);
-		assertThat(resolvers.get(0)).isSameAs(cachingResolver);
-		assertThat(resolvers.get(1)).isSameAs(versionResolver);
-		assertThat(resolvers.get(2)).isSameAs(webjarsResolver);
-		assertThat(resolvers.get(3)).isSameAs(pathResourceResolver);
+		assertThat(resolvers).element(0).isSameAs(cachingResolver);
+		assertThat(resolvers).element(1).isSameAs(versionResolver);
+		assertThat(resolvers).element(2).isSameAs(webjarsResolver);
+		assertThat(resolvers).element(3).isSameAs(pathResourceResolver);
 
 		List<ResourceTransformer> transformers = handler.getResourceTransformers();
 		assertThat(transformers).hasSize(2);
-		assertThat(transformers.get(0)).isSameAs(cachingTransformer);
-		assertThat(transformers.get(1)).isSameAs(cssLinkTransformer);
+		assertThat(transformers).element(0).isSameAs(cachingTransformer);
+		assertThat(transformers).element(1).isSameAs(cssLinkTransformer);
 	}
 
 	@Test

spring-webflux/src/test/java/org/springframework/web/reactive/config/ViewResolverRegistryTests.java

@@ -80,7 +80,7 @@ public class ViewResolverRegistryTests {
 		UrlBasedViewResolver viewResolver = new UrlBasedViewResolver();
 		this.registry.viewResolver(viewResolver);
 
-		assertThat(this.registry.getViewResolvers().get(0)).isSameAs(viewResolver);
+		assertThat(this.registry.getViewResolvers()).element(0).isSameAs(viewResolver);
 		assertThat(this.registry.getViewResolvers()).hasSize(1);
 	}
 
@@ -90,7 +90,7 @@ public class ViewResolverRegistryTests {
 		this.registry.defaultViews(view);
 
 		assertThat(this.registry.getDefaultViews()).hasSize(1);
-		assertThat(this.registry.getDefaultViews().get(0)).isSameAs(view);
+		assertThat(this.registry.getDefaultViews()).element(0).isSameAs(view);
 	}
 
 	@Test  // SPR-16431

spring-webflux/src/test/java/org/springframework/web/reactive/config/WebFluxConfigurationSupportTests.java

@@ -263,7 +263,7 @@ public class WebFluxConfigurationSupportTests {
 		assertThat(views).hasSize(1);
 
 		MimeType type = MimeTypeUtils.parseMimeType("application/json");
-		assertThat(views.get(0).getSupportedMediaTypes().get(0)).isEqualTo(type);
+		assertThat(views.get(0).getSupportedMediaTypes()).element(0).isEqualTo(type);
 	}
 
 	@Test

spring-webflux/src/test/java/org/springframework/web/reactive/function/BodyExtractorsTests.java

@@ -326,8 +326,8 @@ class BodyExtractorsTests {
 					assertThat(form.getFirst("name 1")).as("Invalid result").isEqualTo("value 1");
 					List<String> values = form.get("name 2");
 					assertThat(values).as("Invalid result").hasSize(2);
-					assertThat(values.get(0)).as("Invalid result").isEqualTo("value 2+1");
-					assertThat(values.get(1)).as("Invalid result").isEqualTo("value 2+2");
+					assertThat(values).element(0).as("Invalid result").isEqualTo("value 2+1");
+					assertThat(values).element(1).as("Invalid result").isEqualTo("value 2+2");
 					assertThat(form.getFirst("name 3")).as("Invalid result").isNull();
 				})
 				.expectComplete()

spring-webflux/src/test/java/org/springframework/web/reactive/function/MultipartRouterFunctionIntegrationTests.java

@@ -258,7 +258,7 @@ class MultipartRouterFunctionIntegrationTests extends AbstractRouterFunctionInte
 
 						List<PartEvent> fileData = data.get(0);
 						assertThat(fileData).hasSize(1);
-						assertThat(fileData.get(0)).isInstanceOf(FilePartEvent.class);
+						assertThat(fileData).element(0).isInstanceOf(FilePartEvent.class);
 						FilePartEvent filePartEvent = (FilePartEvent) fileData.get(0);
 						assertThat(filePartEvent.name()).isEqualTo("fooPart");
 						assertThat(filePartEvent.filename()).isEqualTo("foo.txt");
@@ -266,7 +266,7 @@ class MultipartRouterFunctionIntegrationTests extends AbstractRouterFunctionInte
 
 						List<PartEvent> fieldData = data.get(1);
 						assertThat(fieldData).hasSize(1);
-						assertThat(fieldData.get(0)).isInstanceOf(FormPartEvent.class);
+						assertThat(fieldData).element(0).isInstanceOf(FormPartEvent.class);
 						FormPartEvent formPartEvent = (FormPartEvent) fieldData.get(0);
 						assertThat(formPartEvent.name()).isEqualTo("barPart");
 						assertThat(formPartEvent.content().toString(StandardCharsets.UTF_8)).isEqualTo("bar");

spring-webflux/src/test/java/org/springframework/web/reactive/result/condition/RequestMappingInfoTests.java

@@ -205,9 +205,9 @@ public class RequestMappingInfoTests {
 		Collections.shuffle(list);
 		list.sort(comparator);
 
-		assertThat(list.get(0)).isEqualTo(oneMethodOneParam);
-		assertThat(list.get(1)).isEqualTo(oneMethod);
-		assertThat(list.get(2)).isEqualTo(none);
+		assertThat(list).element(0).isEqualTo(oneMethodOneParam);
+		assertThat(list).element(1).isEqualTo(oneMethod);
+		assertThat(list).element(2).isEqualTo(none);
 	}
 
 	@Test

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

@@ -113,8 +113,8 @@ class ProtobufIntegrationTests extends AbstractRequestMappingIntegrationTests {
 				.uri("/message-stream")
 				.exchangeToFlux(response -> {
 					assertThat(response.headers().contentType().get().getParameters().get("delimited")).isEqualTo("true");
-					assertThat(response.headers().header("X-Protobuf-Schema").get(0)).isEqualTo("sample.proto");
-					assertThat(response.headers().header("X-Protobuf-Message").get(0)).isEqualTo("Msg");
+					assertThat(response.headers().header("X-Protobuf-Schema")).element(0).isEqualTo("sample.proto");
+					assertThat(response.headers().header("X-Protobuf-Message")).element(0).isEqualTo("Msg");
 					return response.bodyToFlux(Msg.class);
 				});
 

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

@@ -124,10 +124,10 @@ public class AnnotationDrivenBeanDefinitionParserTests {
 		@SuppressWarnings("unchecked")
 		List<HandlerMethodArgumentResolver> resolvers = (List<HandlerMethodArgumentResolver>) value;
 		assertThat(resolvers).hasSize(3);
-		assertThat(resolvers.get(0)).isInstanceOf(ServletWebArgumentResolverAdapter.class);
-		assertThat(resolvers.get(1)).isInstanceOf(TestHandlerMethodArgumentResolver.class);
-		assertThat(resolvers.get(2)).isInstanceOf(TestHandlerMethodArgumentResolver.class);
-		assertThat(resolvers.get(2)).isNotSameAs(resolvers.get(1));
+		assertThat(resolvers).element(0).isInstanceOf(ServletWebArgumentResolverAdapter.class);
+		assertThat(resolvers).element(1).isInstanceOf(TestHandlerMethodArgumentResolver.class);
+		assertThat(resolvers).element(2).isInstanceOf(TestHandlerMethodArgumentResolver.class);
+		assertThat(resolvers).element(2).isNotSameAs(resolvers.get(1));
 	}
 
 	@Test
@@ -147,7 +147,7 @@ public class AnnotationDrivenBeanDefinitionParserTests {
 		assertThat(handlers).hasSize(2);
 		assertThat(handlers.get(0).getClass()).isEqualTo(TestHandlerMethodReturnValueHandler.class);
 		assertThat(handlers.get(1).getClass()).isEqualTo(TestHandlerMethodReturnValueHandler.class);
-		assertThat(handlers.get(1)).isNotSameAs(handlers.get(0));
+		assertThat(handlers).element(1).isNotSameAs(handlers.get(0));
 	}
 
 	@Test
@@ -178,8 +178,8 @@ public class AnnotationDrivenBeanDefinitionParserTests {
 		else {
 			assertThat(converters.size()).as("Only custom converters expected").isEqualTo(2);
 		}
-		assertThat(converters.get(0)).isInstanceOf(StringHttpMessageConverter.class);
-		assertThat(converters.get(1)).isInstanceOf(ResourceHttpMessageConverter.class);
+		assertThat(converters).element(0).isInstanceOf(StringHttpMessageConverter.class);
+		assertThat(converters).element(1).isInstanceOf(ResourceHttpMessageConverter.class);
 	}
 
 	@SuppressWarnings("unchecked")
@@ -189,7 +189,7 @@ public class AnnotationDrivenBeanDefinitionParserTests {
 		assertThat(value).isNotNull();
 		assertThat(value).isInstanceOf(List.class);
 		List<ResponseBodyAdvice<?>> converters = (List<ResponseBodyAdvice<?>>) value;
-		assertThat(converters.get(0)).isInstanceOf(JsonViewResponseBodyAdvice.class);
+		assertThat(converters).element(0).isInstanceOf(JsonViewResponseBodyAdvice.class);
 	}
 
 	@SuppressWarnings("unchecked")

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

@@ -247,7 +247,7 @@ public class MvcNamespaceTests {
 
 		HandlerExecutionChain chain = mapping.getHandler(request);
 		assertThat(chain.getInterceptorList()).hasSize(1);
-		assertThat(chain.getInterceptorList().get(0)).isInstanceOf(ConversionServiceExposingInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(0).isInstanceOf(ConversionServiceExposingInterceptor.class);
 		ConversionServiceExposingInterceptor interceptor = (ConversionServiceExposingInterceptor) chain.getInterceptorList().get(0);
 		interceptor.preHandle(request, response, handlerMethod);
 		assertThat(request.getAttribute(ConversionService.class.getName())).isSameAs(appContext.getBean(ConversionService.class));
@@ -267,7 +267,7 @@ public class MvcNamespaceTests {
 		HandlerMappingIntrospector introspector = this.appContext.getBean(name, HandlerMappingIntrospector.class);
 		assertThat(introspector).isNotNull();
 		assertThat(introspector.getHandlerMappings()).hasSize(2);
-		assertThat(introspector.getHandlerMappings().get(0)).isSameAs(mapping);
+		assertThat(introspector.getHandlerMappings()).element(0).isSameAs(mapping);
 		assertThat(introspector.getHandlerMappings().get(1).getClass()).isEqualTo(BeanNameUrlHandlerMapping.class);
 	}
 
@@ -304,7 +304,7 @@ public class MvcNamespaceTests {
 
 		HandlerExecutionChain chain = mapping.getHandler(request);
 		assertThat(chain.getInterceptorList()).hasSize(1);
-		assertThat(chain.getInterceptorList().get(0)).isInstanceOf(ConversionServiceExposingInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(0).isInstanceOf(ConversionServiceExposingInterceptor.class);
 		ConversionServiceExposingInterceptor interceptor = (ConversionServiceExposingInterceptor) chain.getInterceptorList().get(0);
 		interceptor.preHandle(request, response, handler);
 		assertThat(request.getAttribute(ConversionService.class.getName())).isSameAs(appContext.getBean("conversionService"));
@@ -356,10 +356,10 @@ public class MvcNamespaceTests {
 
 		HandlerExecutionChain chain = mapping.getHandler(request);
 		assertThat(chain.getInterceptorList()).hasSize(4);
-		assertThat(chain.getInterceptorList().get(0)).isInstanceOf(ConversionServiceExposingInterceptor.class);
-		assertThat(chain.getInterceptorList().get(1)).isInstanceOf(LocaleChangeInterceptor.class);
-		assertThat(chain.getInterceptorList().get(2)).isInstanceOf(ThemeChangeInterceptor.class);
-		assertThat(chain.getInterceptorList().get(3)).isInstanceOf(UserRoleAuthorizationInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(0).isInstanceOf(ConversionServiceExposingInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(1).isInstanceOf(LocaleChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(2).isInstanceOf(ThemeChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(3).isInstanceOf(UserRoleAuthorizationInterceptor.class);
 
 		request.setRequestURI("/admin/users");
 		chain = mapping.getHandler(request);
@@ -454,10 +454,10 @@ public class MvcNamespaceTests {
 
 		List<ResourceResolver> resolvers = handler.getResourceResolvers();
 		assertThat(resolvers).hasSize(4);
-		assertThat(resolvers.get(0)).isInstanceOf(CachingResourceResolver.class);
-		assertThat(resolvers.get(1)).isInstanceOf(VersionResourceResolver.class);
-		assertThat(resolvers.get(2)).isInstanceOf(WebJarsResourceResolver.class);
-		assertThat(resolvers.get(3)).isInstanceOf(PathResourceResolver.class);
+		assertThat(resolvers).element(0).isInstanceOf(CachingResourceResolver.class);
+		assertThat(resolvers).element(1).isInstanceOf(VersionResourceResolver.class);
+		assertThat(resolvers).element(2).isInstanceOf(WebJarsResourceResolver.class);
+		assertThat(resolvers).element(3).isInstanceOf(PathResourceResolver.class);
 
 		CachingResourceResolver cachingResolver = (CachingResourceResolver) resolvers.get(0);
 		assertThat(cachingResolver.getCache()).isInstanceOf(ConcurrentMapCache.class);
@@ -476,8 +476,8 @@ public class MvcNamespaceTests {
 
 		List<ResourceTransformer> transformers = handler.getResourceTransformers();
 		assertThat(transformers).hasSize(2);
-		assertThat(transformers.get(0)).isInstanceOf(CachingResourceTransformer.class);
-		assertThat(transformers.get(1)).isInstanceOf(CssLinkResourceTransformer.class);
+		assertThat(transformers).element(0).isInstanceOf(CachingResourceTransformer.class);
+		assertThat(transformers).element(1).isInstanceOf(CssLinkResourceTransformer.class);
 
 		CachingResourceTransformer cachingTransformer = (CachingResourceTransformer) transformers.get(0);
 		assertThat(cachingTransformer.getCache()).isInstanceOf(ConcurrentMapCache.class);
@@ -502,9 +502,9 @@ public class MvcNamespaceTests {
 
 		List<ResourceResolver> resolvers = handler.getResourceResolvers();
 		assertThat(resolvers).hasSize(3);
-		assertThat(resolvers.get(0)).isInstanceOf(VersionResourceResolver.class);
-		assertThat(resolvers.get(1)).isInstanceOf(EncodedResourceResolver.class);
-		assertThat(resolvers.get(2)).isInstanceOf(PathResourceResolver.class);
+		assertThat(resolvers).element(0).isInstanceOf(VersionResourceResolver.class);
+		assertThat(resolvers).element(1).isInstanceOf(EncodedResourceResolver.class);
+		assertThat(resolvers).element(2).isInstanceOf(PathResourceResolver.class);
 
 		VersionResourceResolver versionResolver = (VersionResourceResolver) resolvers.get(0);
 		assertThat(versionResolver.getStrategyMap().get("/**/*.js"))
@@ -514,7 +514,7 @@ public class MvcNamespaceTests {
 
 		List<ResourceTransformer> transformers = handler.getResourceTransformers();
 		assertThat(transformers).hasSize(1);
-		assertThat(transformers.get(0)).isInstanceOf(CachingResourceTransformer.class);
+		assertThat(transformers).element(0).isInstanceOf(CachingResourceTransformer.class);
 	}
 
 	@Test
@@ -581,9 +581,9 @@ public class MvcNamespaceTests {
 
 		HandlerExecutionChain chain = mapping.getHandler(request);
 		assertThat(chain.getInterceptorList()).hasSize(3);
-		assertThat(chain.getInterceptorList().get(0)).isInstanceOf(ConversionServiceExposingInterceptor.class);
-		assertThat(chain.getInterceptorList().get(1)).isInstanceOf(LocaleChangeInterceptor.class);
-		assertThat(chain.getInterceptorList().get(2)).isInstanceOf(ThemeChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(0).isInstanceOf(ConversionServiceExposingInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(1).isInstanceOf(LocaleChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(2).isInstanceOf(ThemeChangeInterceptor.class);
 		LocaleChangeInterceptor interceptor = (LocaleChangeInterceptor) chain.getInterceptorList().get(1);
 		assertThat(interceptor.getParamName()).isEqualTo("lang");
 		ThemeChangeInterceptor interceptor2 = (ThemeChangeInterceptor) chain.getInterceptorList().get(2);
@@ -607,9 +607,9 @@ public class MvcNamespaceTests {
 
 		HandlerExecutionChain chain = mapping.getHandler(request);
 		assertThat(chain.getInterceptorList()).hasSize(3);
-		assertThat(chain.getInterceptorList().get(0)).isInstanceOf(ConversionServiceExposingInterceptor.class);
-		assertThat(chain.getInterceptorList().get(1)).isInstanceOf(LocaleChangeInterceptor.class);
-		assertThat(chain.getInterceptorList().get(2)).isInstanceOf(ThemeChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(0).isInstanceOf(ConversionServiceExposingInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(1).isInstanceOf(LocaleChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(2).isInstanceOf(ThemeChangeInterceptor.class);
 
 		SimpleUrlHandlerMapping mapping2 = appContext.getBean(SimpleUrlHandlerMapping.class);
 		assertThat(mapping2).isNotNull();
@@ -620,9 +620,9 @@ public class MvcNamespaceTests {
 		request = new MockHttpServletRequest("GET", "/foo");
 		chain = mapping2.getHandler(request);
 		assertThat(chain.getInterceptorList()).hasSize(4);
-		assertThat(chain.getInterceptorList().get(1)).isInstanceOf(ConversionServiceExposingInterceptor.class);
-		assertThat(chain.getInterceptorList().get(2)).isInstanceOf(LocaleChangeInterceptor.class);
-		assertThat(chain.getInterceptorList().get(3)).isInstanceOf(ThemeChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(1).isInstanceOf(ConversionServiceExposingInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(2).isInstanceOf(LocaleChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(3).isInstanceOf(ThemeChangeInterceptor.class);
 		ModelAndView mv = adapter.handle(request, new MockHttpServletResponse(), chain.getHandler());
 		assertThat(mv.getViewName()).isNull();
 
@@ -631,9 +631,9 @@ public class MvcNamespaceTests {
 		request.setServletPath("/app");
 		chain = mapping2.getHandler(request);
 		assertThat(chain.getInterceptorList()).hasSize(4);
-		assertThat(chain.getInterceptorList().get(1)).isInstanceOf(ConversionServiceExposingInterceptor.class);
-		assertThat(chain.getInterceptorList().get(2)).isInstanceOf(LocaleChangeInterceptor.class);
-		assertThat(chain.getInterceptorList().get(3)).isInstanceOf(ThemeChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(1).isInstanceOf(ConversionServiceExposingInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(2).isInstanceOf(LocaleChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(3).isInstanceOf(ThemeChangeInterceptor.class);
 		mv = adapter.handle(request, new MockHttpServletResponse(), chain.getHandler());
 		assertThat(mv.getViewName()).isEqualTo("baz");
 
@@ -642,9 +642,9 @@ public class MvcNamespaceTests {
 		request.setServletPath("/app");
 		chain = mapping2.getHandler(request);
 		assertThat(chain.getInterceptorList()).hasSize(4);
-		assertThat(chain.getInterceptorList().get(1)).isInstanceOf(ConversionServiceExposingInterceptor.class);
-		assertThat(chain.getInterceptorList().get(2)).isInstanceOf(LocaleChangeInterceptor.class);
-		assertThat(chain.getInterceptorList().get(3)).isInstanceOf(ThemeChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(1).isInstanceOf(ConversionServiceExposingInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(2).isInstanceOf(LocaleChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(3).isInstanceOf(ThemeChangeInterceptor.class);
 		mv = adapter.handle(request, new MockHttpServletResponse(), chain.getHandler());
 		assertThat(mv.getViewName()).isEqualTo("root");
 
@@ -686,9 +686,9 @@ public class MvcNamespaceTests {
 		request.setAttribute("com.ibm.websphere.servlet.uri_non_decoded", "/myapp/app/bar");
 		HandlerExecutionChain chain = mapping2.getHandler(request);
 		assertThat(chain.getInterceptorList()).hasSize(4);
-		assertThat(chain.getInterceptorList().get(1)).isInstanceOf(ConversionServiceExposingInterceptor.class);
-		assertThat(chain.getInterceptorList().get(2)).isInstanceOf(LocaleChangeInterceptor.class);
-		assertThat(chain.getInterceptorList().get(3)).isInstanceOf(ThemeChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(1).isInstanceOf(ConversionServiceExposingInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(2).isInstanceOf(LocaleChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(3).isInstanceOf(ThemeChangeInterceptor.class);
 		ModelAndView mv2 = adapter.handle(request, new MockHttpServletResponse(), chain.getHandler());
 		assertThat(mv2.getViewName()).isEqualTo("baz");
 
@@ -698,9 +698,9 @@ public class MvcNamespaceTests {
 		request.setHttpServletMapping(new MockHttpServletMapping("", "", "", MappingMatch.PATH));
 		chain = mapping2.getHandler(request);
 		assertThat(chain.getInterceptorList()).hasSize(4);
-		assertThat(chain.getInterceptorList().get(1)).isInstanceOf(ConversionServiceExposingInterceptor.class);
-		assertThat(chain.getInterceptorList().get(2)).isInstanceOf(LocaleChangeInterceptor.class);
-		assertThat(chain.getInterceptorList().get(3)).isInstanceOf(ThemeChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(1).isInstanceOf(ConversionServiceExposingInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(2).isInstanceOf(LocaleChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(3).isInstanceOf(ThemeChangeInterceptor.class);
 		ModelAndView mv3 = adapter.handle(request, new MockHttpServletResponse(), chain.getHandler());
 		assertThat(mv3.getViewName()).isEqualTo("root");
 
@@ -709,9 +709,9 @@ public class MvcNamespaceTests {
 		request.setServletPath("/");
 		chain = mapping2.getHandler(request);
 		assertThat(chain.getInterceptorList()).hasSize(4);
-		assertThat(chain.getInterceptorList().get(1)).isInstanceOf(ConversionServiceExposingInterceptor.class);
-		assertThat(chain.getInterceptorList().get(2)).isInstanceOf(LocaleChangeInterceptor.class);
-		assertThat(chain.getInterceptorList().get(3)).isInstanceOf(ThemeChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(1).isInstanceOf(ConversionServiceExposingInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(2).isInstanceOf(LocaleChangeInterceptor.class);
+		assertThat(chain.getInterceptorList()).element(3).isInstanceOf(ThemeChangeInterceptor.class);
 		mv3 = adapter.handle(request, new MockHttpServletResponse(), chain.getHandler());
 		assertThat(mv3.getViewName()).isEqualTo("root");
 	}

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

@@ -99,7 +99,7 @@ public class ContentNegotiationConfigurerTests {
 		this.servletRequest.setRequestURI("/flower");
 		this.servletRequest.addParameter("f", "json");
 
-		assertThat(manager.resolveMediaTypes(this.webRequest).get(0)).isEqualTo(MediaType.APPLICATION_JSON);
+		assertThat(manager.resolveMediaTypes(this.webRequest)).element(0).isEqualTo(MediaType.APPLICATION_JSON);
 	}
 
 	@Test
@@ -119,7 +119,7 @@ public class ContentNegotiationConfigurerTests {
 		this.configurer.defaultContentType(MediaType.APPLICATION_JSON);
 		ContentNegotiationManager manager = this.configurer.buildContentNegotiationManager();
 
-		assertThat(manager.resolveMediaTypes(this.webRequest).get(0)).isEqualTo(MediaType.APPLICATION_JSON);
+		assertThat(manager.resolveMediaTypes(this.webRequest)).element(0).isEqualTo(MediaType.APPLICATION_JSON);
 	}
 
 	@Test
@@ -135,7 +135,7 @@ public class ContentNegotiationConfigurerTests {
 		this.configurer.defaultContentTypeStrategy(new FixedContentNegotiationStrategy(MediaType.APPLICATION_JSON));
 		ContentNegotiationManager manager = this.configurer.buildContentNegotiationManager();
 
-		assertThat(manager.resolveMediaTypes(this.webRequest).get(0)).isEqualTo(MediaType.APPLICATION_JSON);
+		assertThat(manager.resolveMediaTypes(this.webRequest)).element(0).isEqualTo(MediaType.APPLICATION_JSON);
 	}
 
 }

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

@@ -141,8 +141,8 @@ public class DelegatingWebMvcConfigurationTests {
 				this.webMvcConfig.mvcValidator());
 
 		assertThat(adapter.getMessageConverters()).as("One custom converter expected").hasSize(2);
-		assertThat(adapter.getMessageConverters().get(0)).isSameAs(customConverter);
-		assertThat(adapter.getMessageConverters().get(1)).isSameAs(stringConverter);
+		assertThat(adapter.getMessageConverters()).element(0).isSameAs(customConverter);
+		assertThat(adapter.getMessageConverters()).element(1).isSameAs(stringConverter);
 	}
 
 	@Test

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

@@ -161,8 +161,8 @@ public class InterceptorRegistryTests {
 		List<Object> interceptors = this.registry.getInterceptors();
 		assertThat(interceptors).hasSize(2);
 
-		assertThat(interceptors.get(0)).isSameAs(this.interceptor2);
-		assertThat(interceptors.get(1)).isSameAs(this.interceptor1);
+		assertThat(interceptors).element(0).isSameAs(this.interceptor2);
+		assertThat(interceptors).element(1).isSameAs(this.interceptor1);
 	}
 
 	@Test
@@ -173,8 +173,8 @@ public class InterceptorRegistryTests {
 		List<Object> interceptors = this.registry.getInterceptors();
 		assertThat(interceptors).hasSize(2);
 
-		assertThat(interceptors.get(0)).isSameAs(this.interceptor1);
-		assertThat(interceptors.get(1)).isSameAs(this.interceptor2);
+		assertThat(interceptors).element(0).isSameAs(this.interceptor1);
+		assertThat(interceptors).element(1).isSameAs(this.interceptor2);
 	}
 
 

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

@@ -139,17 +139,17 @@ public class ResourceHandlerRegistryTests {
 		ResourceHttpRequestHandler handler = getHandler("/resources/**");
 		List<ResourceResolver> resolvers = handler.getResourceResolvers();
 		assertThat(resolvers).hasSize(4);
-		assertThat(resolvers.get(0)).isInstanceOf(CachingResourceResolver.class);
+		assertThat(resolvers).element(0).isInstanceOf(CachingResourceResolver.class);
 		CachingResourceResolver cachingResolver = (CachingResourceResolver) resolvers.get(0);
 		assertThat(cachingResolver.getCache()).isInstanceOf(ConcurrentMapCache.class);
-		assertThat(resolvers.get(1)).isEqualTo(mockResolver);
-		assertThat(resolvers.get(2)).isInstanceOf(WebJarsResourceResolver.class);
-		assertThat(resolvers.get(3)).isInstanceOf(PathResourceResolver.class);
+		assertThat(resolvers).element(1).isEqualTo(mockResolver);
+		assertThat(resolvers).element(2).isInstanceOf(WebJarsResourceResolver.class);
+		assertThat(resolvers).element(3).isInstanceOf(PathResourceResolver.class);
 
 		List<ResourceTransformer> transformers = handler.getResourceTransformers();
 		assertThat(transformers).hasSize(2);
-		assertThat(transformers.get(0)).isInstanceOf(CachingResourceTransformer.class);
-		assertThat(transformers.get(1)).isEqualTo(mockTransformer);
+		assertThat(transformers).element(0).isInstanceOf(CachingResourceTransformer.class);
+		assertThat(transformers).element(1).isEqualTo(mockTransformer);
 	}
 
 	@Test
@@ -159,8 +159,8 @@ public class ResourceHandlerRegistryTests {
 		ResourceHttpRequestHandler handler = getHandler("/resources/**");
 		List<ResourceResolver> resolvers = handler.getResourceResolvers();
 		assertThat(resolvers).hasSize(2);
-		assertThat(resolvers.get(0)).isInstanceOf(WebJarsResourceResolver.class);
-		assertThat(resolvers.get(1)).isInstanceOf(PathResourceResolver.class);
+		assertThat(resolvers).element(0).isInstanceOf(WebJarsResourceResolver.class);
+		assertThat(resolvers).element(1).isInstanceOf(PathResourceResolver.class);
 
 		List<ResourceTransformer> transformers = handler.getResourceTransformers();
 		assertThat(transformers).isEmpty();
@@ -177,15 +177,15 @@ public class ResourceHandlerRegistryTests {
 		ResourceHttpRequestHandler handler = getHandler("/resources/**");
 		List<ResourceResolver> resolvers = handler.getResourceResolvers();
 		assertThat(resolvers).hasSize(4);
-		assertThat(resolvers.get(0)).isInstanceOf(CachingResourceResolver.class);
-		assertThat(resolvers.get(1)).isSameAs(versionResolver);
-		assertThat(resolvers.get(2)).isInstanceOf(WebJarsResourceResolver.class);
-		assertThat(resolvers.get(3)).isInstanceOf(PathResourceResolver.class);
+		assertThat(resolvers).element(0).isInstanceOf(CachingResourceResolver.class);
+		assertThat(resolvers).element(1).isSameAs(versionResolver);
+		assertThat(resolvers).element(2).isInstanceOf(WebJarsResourceResolver.class);
+		assertThat(resolvers).element(3).isInstanceOf(PathResourceResolver.class);
 
 		List<ResourceTransformer> transformers = handler.getResourceTransformers();
 		assertThat(transformers).hasSize(2);
-		assertThat(transformers.get(0)).isInstanceOf(CachingResourceTransformer.class);
-		assertThat(transformers.get(1)).isInstanceOf(CssLinkResourceTransformer.class);
+		assertThat(transformers).element(0).isInstanceOf(CachingResourceTransformer.class);
+		assertThat(transformers).element(1).isInstanceOf(CssLinkResourceTransformer.class);
 	}
 
 	@Test
@@ -209,15 +209,15 @@ public class ResourceHandlerRegistryTests {
 		ResourceHttpRequestHandler handler = getHandler("/resources/**");
 		List<ResourceResolver> resolvers = handler.getResourceResolvers();
 		assertThat(resolvers).hasSize(4);
-		assertThat(resolvers.get(0)).isSameAs(cachingResolver);
-		assertThat(resolvers.get(1)).isSameAs(versionResolver);
-		assertThat(resolvers.get(2)).isSameAs(webjarsResolver);
-		assertThat(resolvers.get(3)).isSameAs(pathResourceResolver);
+		assertThat(resolvers).element(0).isSameAs(cachingResolver);
+		assertThat(resolvers).element(1).isSameAs(versionResolver);
+		assertThat(resolvers).element(2).isSameAs(webjarsResolver);
+		assertThat(resolvers).element(3).isSameAs(pathResourceResolver);
 
 		List<ResourceTransformer> transformers = handler.getResourceTransformers();
 		assertThat(transformers).hasSize(2);
-		assertThat(transformers.get(0)).isSameAs(cachingTransformer);
-		assertThat(transformers.get(1)).isSameAs(cssLinkTransformer);
+		assertThat(transformers).element(0).isSameAs(cachingTransformer);
+		assertThat(transformers).element(1).isSameAs(cssLinkTransformer);
 	}
 
 	@Test

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

@@ -94,7 +94,7 @@ public class ViewResolverRegistryTests {
 	public void customViewResolver() {
 		InternalResourceViewResolver viewResolver = new InternalResourceViewResolver("/", ".jsp");
 		this.registry.viewResolver(viewResolver);
-		assertThat(this.registry.getViewResolvers().get(0)).isSameAs(viewResolver);
+		assertThat(this.registry.getViewResolvers()).element(0).isSameAs(viewResolver);
 	}
 
 	@Test

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

@@ -336,7 +336,7 @@ public class WebMvcConfigurationSupportExtensionTests {
 	public void crossOrigin() {
 		Map<String, CorsConfiguration> configs = this.config.getCorsConfigurations();
 		assertThat(configs).hasSize(1);
-		assertThat(configs.get("/resources/**").getAllowedOrigins().get(0)).isEqualTo("*");
+		assertThat(configs.get("/resources/**").getAllowedOrigins()).element(0).isEqualTo("*");
 	}
 
 

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

@@ -267,8 +267,8 @@ class DefaultServerRequestTests {
 
 		List<String> result = request.body(new ParameterizedTypeReference<List<String>>() {});
 		assertThat(result).hasSize(2);
-		assertThat(result.get(0)).isEqualTo("foo");
-		assertThat(result.get(1)).isEqualTo("bar");
+		assertThat(result).element(0).isEqualTo("foo");
+		assertThat(result).element(1).isEqualTo("bar");
 	}
 
 	@Test

spring-webmvc/src/test/java/org/springframework/web/servlet/handler/HandlerMethodMappingTests.java

@@ -217,7 +217,7 @@ public class HandlerMethodMappingTests {
 		List<String> directUrlMatches = this.mapping.getMappingRegistry().getMappingsByDirectPath(key1);
 		assertThat(directUrlMatches).isNotNull();
 		assertThat(directUrlMatches).hasSize(1);
-		assertThat(directUrlMatches.get(0)).isEqualTo(key1);
+		assertThat(directUrlMatches).element(0).isEqualTo(key1);
 
 		// Mapping name lookup
 
@@ -228,13 +228,13 @@ public class HandlerMethodMappingTests {
 		List<HandlerMethod> handlerMethods = this.mapping.getMappingRegistry().getHandlerMethodsByMappingName(name1);
 		assertThat(handlerMethods).isNotNull();
 		assertThat(handlerMethods).hasSize(1);
-		assertThat(handlerMethods.get(0)).isEqualTo(handlerMethod1);
+		assertThat(handlerMethods).element(0).isEqualTo(handlerMethod1);
 
 		String name2 = this.method2.getName();
 		handlerMethods = this.mapping.getMappingRegistry().getHandlerMethodsByMappingName(name2);
 		assertThat(handlerMethods).isNotNull();
 		assertThat(handlerMethods).hasSize(1);
-		assertThat(handlerMethods.get(0)).isEqualTo(handlerMethod2);
+		assertThat(handlerMethods).element(0).isEqualTo(handlerMethod2);
 	}
 
 	@Test
@@ -256,7 +256,7 @@ public class HandlerMethodMappingTests {
 		List<String> directUrlMatches = this.mapping.getMappingRegistry().getMappingsByDirectPath(key1);
 		assertThat(directUrlMatches).isNotNull();
 		assertThat(directUrlMatches).hasSize(1);
-		assertThat(directUrlMatches.get(0)).isEqualTo(key1);
+		assertThat(directUrlMatches).element(0).isEqualTo(key1);
 
 		// Mapping name lookup
 
@@ -264,8 +264,8 @@ public class HandlerMethodMappingTests {
 		List<HandlerMethod> handlerMethods = this.mapping.getMappingRegistry().getHandlerMethodsByMappingName(name);
 		assertThat(handlerMethods).isNotNull();
 		assertThat(handlerMethods).hasSize(2);
-		assertThat(handlerMethods.get(0)).isEqualTo(handlerMethod1);
-		assertThat(handlerMethods.get(1)).isEqualTo(handlerMethod2);
+		assertThat(handlerMethods).element(0).isEqualTo(handlerMethod1);
+		assertThat(handlerMethods).element(1).isEqualTo(handlerMethod2);
 	}
 
 	@Test

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

@@ -250,7 +250,7 @@ class RequestMappingInfoHandlerMappingTests {
 
 		HandlerExecutionChain chain = mapping.getHandler(new MockHttpServletRequest("GET", path));
 		assertThat(chain).isNotNull();
-		assertThat(chain.getInterceptorList().get(0)).isSameAs(interceptor);
+		assertThat(chain.getInterceptorList()).element(0).isSameAs(interceptor);
 
 		chain = mapping.getHandler(new MockHttpServletRequest("GET", "/invalid"));
 		assertThat(chain).isNull();

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

@@ -204,9 +204,9 @@ class RequestMappingInfoTests {
 		Collections.shuffle(list);
 		list.sort(comparator);
 
-		assertThat(list.get(0)).isEqualTo(oneMethodOneParam);
-		assertThat(list.get(1)).isEqualTo(oneMethod);
-		assertThat(list.get(2)).isEqualTo(noMethods);
+		assertThat(list).element(0).isEqualTo(oneMethodOneParam);
+		assertThat(list).element(1).isEqualTo(oneMethod);
+		assertThat(list).element(2).isEqualTo(noMethods);
 	}
 
 	@Test
@@ -226,9 +226,9 @@ class RequestMappingInfoTests {
 		Collections.shuffle(list);
 		list.sort(comparator);
 
-		assertThat(list.get(0)).isEqualTo(headMethod);
-		assertThat(list.get(1)).isEqualTo(getMethod);
-		assertThat(list.get(2)).isEqualTo(noMethods);
+		assertThat(list).element(0).isEqualTo(headMethod);
+		assertThat(list).element(1).isEqualTo(getMethod);
+		assertThat(list).element(2).isEqualTo(noMethods);
 	}
 
 	@PathPatternsParameterizedTest

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

@@ -474,7 +474,7 @@ class HttpEntityMethodProcessorMockTests {
 		ArgumentCaptor<HttpOutputMessage> outputMessage = ArgumentCaptor.forClass(HttpOutputMessage.class);
 		verify(stringHttpMessageConverter).write(eq("body"), eq(TEXT_PLAIN), outputMessage.capture());
 		assertThat(mavContainer.isRequestHandled()).isTrue();
-		assertThat(outputMessage.getValue().getHeaders().get("header").get(0)).isEqualTo("headerValue");
+		assertThat(outputMessage.getValue().getHeaders().get("header")).element(0).isEqualTo("headerValue");
 	}
 
 	@Test

spring-webmvc/src/test/java/org/springframework/web/servlet/view/ContentNegotiatingViewResolverTests.java

@@ -80,7 +80,7 @@ public class ContentNegotiatingViewResolverTests {
 		request.addHeader("Accept", "text/html,application/xml;q=0.9,application/xhtml+xml,*/*;q=0.8");
 		viewResolver.afterPropertiesSet();
 		List<MediaType> result = viewResolver.getMediaTypes(request);
-		assertThat(result.get(0)).as("Invalid content type").isEqualTo(new MediaType("application", "xhtml+xml"));
+		assertThat(result).element(0).as("Invalid content type").isEqualTo(new MediaType("application", "xhtml+xml"));
 	}
 
 	@Test

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

@@ -341,9 +341,9 @@ public class MessageBrokerBeanDefinitionParserTests {
 
 		List<MessageConverter> converters = compositeMessageConverter.getConverters();
 		assertThat(converters).hasSize(3);
-		assertThat(converters.get(0)).isInstanceOf(StringMessageConverter.class);
-		assertThat(converters.get(1)).isInstanceOf(ByteArrayMessageConverter.class);
-		assertThat(converters.get(2)).isInstanceOf(MappingJackson2MessageConverter.class);
+		assertThat(converters).element(0).isInstanceOf(StringMessageConverter.class);
+		assertThat(converters).element(1).isInstanceOf(ByteArrayMessageConverter.class);
+		assertThat(converters).element(2).isInstanceOf(MappingJackson2MessageConverter.class);
 
 		ContentTypeResolver resolver = ((MappingJackson2MessageConverter) converters.get(2)).getContentTypeResolver();
 		assertThat(((DefaultContentTypeResolver) resolver).getDefaultMimeType()).isEqualTo(MimeTypeUtils.APPLICATION_JSON);

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

@@ -185,7 +185,7 @@ class WebMvcStompWebSocketEndpointRegistrationTests {
 		assertThat(requestHandler.getWebSocketHandler()).isNotNull();
 		assertThat(requestHandler.getHandshakeHandler()).isSameAs(handshakeHandler);
 		assertThat(requestHandler.getHandshakeInterceptors()).hasSize(2);
-		assertThat(requestHandler.getHandshakeInterceptors().get(0)).isEqualTo(interceptor);
+		assertThat(requestHandler.getHandshakeInterceptors()).element(0).isEqualTo(interceptor);
 		assertThat(requestHandler.getHandshakeInterceptors().get(1).getClass()).isEqualTo(OriginHandshakeInterceptor.class);
 	}
 
@@ -209,7 +209,7 @@ class WebMvcStompWebSocketEndpointRegistrationTests {
 		assertThat(requestHandler.getWebSocketHandler()).isNotNull();
 		assertThat(requestHandler.getHandshakeHandler()).isSameAs(handshakeHandler);
 		assertThat(requestHandler.getHandshakeInterceptors()).hasSize(2);
-		assertThat(requestHandler.getHandshakeInterceptors().get(0)).isEqualTo(interceptor);
+		assertThat(requestHandler.getHandshakeInterceptors()).element(0).isEqualTo(interceptor);
 		assertThat(requestHandler.getHandshakeInterceptors().get(1).getClass()).isEqualTo(OriginHandshakeInterceptor.class);
 	}
 
@@ -239,7 +239,7 @@ class WebMvcStompWebSocketEndpointRegistrationTests {
 		WebSocketTransportHandler transportHandler = (WebSocketTransportHandler) handlers.get(TransportType.WEBSOCKET);
 		assertThat(transportHandler.getHandshakeHandler()).isSameAs(handshakeHandler);
 		assertThat(sockJsService.getHandshakeInterceptors()).hasSize(2);
-		assertThat(sockJsService.getHandshakeInterceptors().get(0)).isEqualTo(interceptor);
+		assertThat(sockJsService.getHandshakeInterceptors()).element(0).isEqualTo(interceptor);
 		assertThat(sockJsService.getHandshakeInterceptors().get(1).getClass()).isEqualTo(OriginHandshakeInterceptor.class);
 	}
 
@@ -271,7 +271,7 @@ class WebMvcStompWebSocketEndpointRegistrationTests {
 		WebSocketTransportHandler transportHandler = (WebSocketTransportHandler) handlers.get(TransportType.WEBSOCKET);
 		assertThat(transportHandler.getHandshakeHandler()).isSameAs(handshakeHandler);
 		assertThat(sockJsService.getHandshakeInterceptors()).hasSize(2);
-		assertThat(sockJsService.getHandshakeInterceptors().get(0)).isEqualTo(interceptor);
+		assertThat(sockJsService.getHandshakeInterceptors()).element(0).isEqualTo(interceptor);
 		assertThat(sockJsService.getHandshakeInterceptors().get(1).getClass()).isEqualTo(OriginHandshakeInterceptor.class);
 		assertThat(sockJsService.getAllowedOrigins().contains(origin)).isTrue();
 	}

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

@@ -157,7 +157,7 @@ public class WebSocketHandlerRegistrationTests {
 		assertThat(mapping.sockJsService).isNotNull();
 		assertThat(mapping.sockJsService.getAllowedOrigins().contains("https://mydomain1.example")).isTrue();
 		List<HandshakeInterceptor> interceptors = mapping.sockJsService.getHandshakeInterceptors();
-		assertThat(interceptors.get(0)).isEqualTo(interceptor);
+		assertThat(interceptors).element(0).isEqualTo(interceptor);
 
 		OriginHandshakeInterceptor originInterceptor = (OriginHandshakeInterceptor) interceptors.get(1);
 		assertThat(originInterceptor.getAllowedOrigins()).containsExactly("https://mydomain1.example");

spring-websocket/src/test/java/org/springframework/web/socket/handler/ConcurrentWebSocketSessionDecoratorTests.java

@@ -51,7 +51,7 @@ public class ConcurrentWebSocketSessionDecoratorTests {
 		decorator.sendMessage(textMessage);
 
 		assertThat(session.getSentMessages()).hasSize(1);
-		assertThat(session.getSentMessages().get(0)).isEqualTo(textMessage);
+		assertThat(session.getSentMessages()).element(0).isEqualTo(textMessage);
 
 		assertThat(decorator.getBufferSize()).isEqualTo(0);
 		assertThat(decorator.getTimeSinceSendStarted()).isEqualTo(0);

spring-websocket/src/test/java/org/springframework/web/socket/sockjs/transport/session/SockJsSessionTests.java

@@ -187,7 +187,7 @@ class SockJsSessionTests extends AbstractSockJsSessionTests<TestSockJsSession> {
 		this.session.close();
 
 		assertThat(this.session.getSockJsFramesWritten()).hasSize(1);
-		assertThat(this.session.getSockJsFramesWritten().get(0)).isEqualTo(SockJsFrame.closeFrameGoAway());
+		assertThat(this.session.getSockJsFramesWritten()).element(0).isEqualTo(SockJsFrame.closeFrameGoAway());
 
 		assertThat(this.session.getNumberOfLastActiveTimeUpdates()).isEqualTo(1);
 		assertThat(this.session.didCancelHeartbeat()).isTrue();
@@ -236,7 +236,7 @@ class SockJsSessionTests extends AbstractSockJsSessionTests<TestSockJsSession> {
 		this.session.writeFrame(SockJsFrame.openFrame());
 
 		assertThat(this.session.getSockJsFramesWritten()).hasSize(1);
-		assertThat(this.session.getSockJsFramesWritten().get(0)).isEqualTo(SockJsFrame.openFrame());
+		assertThat(this.session.getSockJsFramesWritten()).element(0).isEqualTo(SockJsFrame.openFrame());
 	}
 
 	@Test
@@ -256,7 +256,7 @@ class SockJsSessionTests extends AbstractSockJsSessionTests<TestSockJsSession> {
 		this.session.sendHeartbeat();
 
 		assertThat(this.session.getSockJsFramesWritten()).hasSize(1);
-		assertThat(this.session.getSockJsFramesWritten().get(0)).isEqualTo(SockJsFrame.heartbeatFrame());
+		assertThat(this.session.getSockJsFramesWritten()).element(0).isEqualTo(SockJsFrame.heartbeatFrame());
 
 		verify(this.taskScheduler).schedule(any(Runnable.class), any(Instant.class));
 		verifyNoMoreInteractions(this.taskScheduler);