Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use AssertJ's hasSize() for collections and maps

Browse Source 
Achieved via a global search-and-replace.
This commit is contained in:
Sam Brannen
2022-11-22 16:50:10 +01:00
parent f9f8f2d89e
commit 36f7597f25
237 changed files with 1161 additions and 1172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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