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

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

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

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

2
spring-context-support/src/test/java/org/springframework/cache/jcache/interceptor/CacheResolverAdapterTests.java vendored
View File

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

4
spring-context-support/src/test/java/org/springframework/cache/jcache/interceptor/CacheResultOperationTests.java vendored
View File

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

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

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

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

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

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

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

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

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

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

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

2
spring-context/src/test/java/org/springframework/cache/interceptor/ExpressionEvaluatorTests.java vendored
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2
spring-context/src/testFixtures/java/org/springframework/context/testfixture/cache/AbstractCacheTests.java vendored
View File

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

28
spring-core/src/test/java/org/springframework/core/ConstantsTests.java
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

18
spring-core/src/test/java/org/springframework/core/env/MutablePropertySourcesTests.java vendored
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2
spring-messaging/src/test/java/org/springframework/messaging/MessageHeadersTests.java
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Some files were not shown because too many files have changed in this diff Show More