root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 8 Packages Projects Releases Wiki Activity

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

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

Closes gh-31759
This commit is contained in:
Yanming Zhou 2023-12-06 14:25:18 +08:00 committed by Brian Clozel
parent 785ad399e9
commit 59815cefce
94 changed files with 549 additions and 549 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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

2
spring-beans/src/test/java/org/springframework/beans/AbstractPropertyAccessorTests.java
View File

@ -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

16
spring-beans/src/test/java/org/springframework/beans/BeanWrapperAutoGrowingTests.java
View File

@ -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

18
spring-beans/src/test/java/org/springframework/beans/BeanWrapperGenericsTests.java
View File

@ -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

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

@ -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

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

@ -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);

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

@ -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

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

@ -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);
});
}

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

@ -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"));
}

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

@ -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();
}

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

@ -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");

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

@ -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();

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

@ -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

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

@ -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");
}

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

@ -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);

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

@ -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")

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

@ -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

2
spring-context/src/test/java/org/springframework/cache/concurrent/ConcurrentMapCacheTests.java vendored
View File

@ -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

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

@ -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);

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

@ -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();
});

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

@ -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();
}

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

@ -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

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

@ -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);

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

@ -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();

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

@ -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();
}

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

@ -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);
}

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

@ -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);
}

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

@ -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 {

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

@ -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();
}

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

@ -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

4
spring-core/src/test/java/org/springframework/core/env/SimpleCommandLinePropertySourceTests.java vendored
View File

@ -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");
}
}

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

@ -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");
}
}

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

@ -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();
}

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

@ -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();

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

@ -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

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

@ -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);

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

@ -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

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

@ -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();

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

@ -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);
}

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

@ -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

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

@ -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();

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

@ -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();
}

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

@ -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);

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

@ -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);

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

@ -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

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

@ -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());

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

@ -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

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

@ -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());
}

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

@ -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();

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

@ -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

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

@ -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;
}
};

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

@ -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);
}

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

@ -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();
}

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

@ -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();
}

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

@ -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.");
}

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

@ -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);
}

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

@ -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

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

@ -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);
}

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

@ -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

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

@ -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

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

@ -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");
}
}

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

@ -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

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

@ -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);
}

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

@ -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

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

@ -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

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

@ -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

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

@ -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

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

@ -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/*"));

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

@ -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

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

@ -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

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

@ -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

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

@ -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()

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

@ -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");

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

@ -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

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

@ -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);
});

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

@ -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")

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

@ -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");
}

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

@ -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);
}
}

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

@ -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

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

@ -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);
}

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

@ -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

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

@ -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

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

@ -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("*");
}

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

@ -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

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

@ -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

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

@ -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();

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

@ -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

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

@ -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

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

@ -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

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

@ -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);

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

@ -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();
}

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

@ -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");

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

@ -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);

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

@ -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);