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

Polish

Browse Source
This commit is contained in:
Stéphane Nicoll
2024-01-15 11:17:11 +01:00
parent e1236a8672
commit 0c42965fc3
71 changed files with 543 additions and 828 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -62,7 +62,7 @@ class BeanWrapperAutoGrowingTests {
@Test
void getPropertyValueAutoGrowArray() {
assertNotNull(wrapper.getPropertyValue("array[0]"));
assertThat(wrapper.getPropertyValue("array[0]")).isNotNull();
assertThat(bean.getArray()).hasSize(1);
assertThat(bean.getArray()[0]).isInstanceOf(Bean.class);
}
@@ -75,17 +75,17 @@ class BeanWrapperAutoGrowingTests {
@Test
void getPropertyValueAutoGrowArrayBySeveralElements() {
assertNotNull(wrapper.getPropertyValue("array[4]"));
assertThat(wrapper.getPropertyValue("array[4]")).isNotNull();
assertThat(bean.getArray()).hasSize(5);
assertThat(bean.getArray()[0]).isInstanceOf(Bean.class);
assertThat(bean.getArray()[1]).isInstanceOf(Bean.class);
assertThat(bean.getArray()[2]).isInstanceOf(Bean.class);
assertThat(bean.getArray()[3]).isInstanceOf(Bean.class);
assertThat(bean.getArray()[4]).isInstanceOf(Bean.class);
assertNotNull(wrapper.getPropertyValue("array[0]"));
assertNotNull(wrapper.getPropertyValue("array[1]"));
assertNotNull(wrapper.getPropertyValue("array[2]"));
assertNotNull(wrapper.getPropertyValue("array[3]"));
assertThat(wrapper.getPropertyValue("array[0]")).isNotNull();
assertThat(wrapper.getPropertyValue("array[1]")).isNotNull();
assertThat(wrapper.getPropertyValue("array[2]")).isNotNull();
assertThat(wrapper.getPropertyValue("array[3]")).isNotNull();
}
@Test
@@ -124,7 +124,7 @@ class BeanWrapperAutoGrowingTests {
@Test
void getPropertyValueAutoGrowList() {
assertNotNull(wrapper.getPropertyValue("list[0]"));
assertThat(wrapper.getPropertyValue("list[0]")).isNotNull();
assertThat(bean.getList()).hasSize(1);
assertThat(bean.getList()).element(0).isInstanceOf(Bean.class);
}
@@ -137,17 +137,13 @@ class BeanWrapperAutoGrowingTests {
@Test
void getPropertyValueAutoGrowListBySeveralElements() {
assertNotNull(wrapper.getPropertyValue("list[4]"));
assertThat(bean.getList()).hasSize(5);
assertThat(bean.getList()).element(0).isInstanceOf(Bean.class);
assertThat(bean.getList()).element(1).isInstanceOf(Bean.class);
assertThat(bean.getList()).element(2).isInstanceOf(Bean.class);
assertThat(bean.getList()).element(3).isInstanceOf(Bean.class);
assertThat(bean.getList()).element(4).isInstanceOf(Bean.class);
assertNotNull(wrapper.getPropertyValue("list[0]"));
assertNotNull(wrapper.getPropertyValue("list[1]"));
assertNotNull(wrapper.getPropertyValue("list[2]"));
assertNotNull(wrapper.getPropertyValue("list[3]"));
assertThat(wrapper.getPropertyValue("list[4]")).isNotNull();
assertThat(bean.getList()).hasSize(5).allSatisfy(entry ->
assertThat(entry).isInstanceOf(Bean.class));
assertThat(wrapper.getPropertyValue("list[0]")).isNotNull();
assertThat(wrapper.getPropertyValue("list[1]")).isNotNull();
assertThat(wrapper.getPropertyValue("list[2]")).isNotNull();
assertThat(wrapper.getPropertyValue("list[3]")).isNotNull();
}
@Test
@@ -160,9 +156,9 @@ class BeanWrapperAutoGrowingTests {
@Test
void getPropertyValueAutoGrowMultiDimensionalList() {
assertNotNull(wrapper.getPropertyValue("multiList[0][0]"));
assertThat(bean.getMultiList()).element(0).asList().hasSize(1);
assertThat(bean.getMultiList().get(0)).element(0).isInstanceOf(Bean.class);
assertThat(wrapper.getPropertyValue("multiList[0][0]")).isNotNull();
assertThat(bean.getMultiList()).hasSize(1);
assertThat(bean.getMultiList().get(0)).singleElement().isInstanceOf(Bean.class);
}
@Test
@@ -184,11 +180,6 @@ class BeanWrapperAutoGrowingTests {
}
private static void assertNotNull(Object propertyValue) {
assertThat(propertyValue).isNotNull();
}
@SuppressWarnings("rawtypes")
public static class Bean {

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

@@ -94,8 +94,8 @@ class BeanWrapperGenericsTests {
input.add("http://localhost:8080");
input.add("http://localhost:9090");
bw.setPropertyValue("resourceList", input);
assertThat(gb.getResourceList()).element(0).isEqualTo(new UrlResource("http://localhost:8080"));
assertThat(gb.getResourceList()).element(1).isEqualTo(new UrlResource("http://localhost:9090"));
assertThat(gb.getResourceList()).containsExactly(new UrlResource("http://localhost:8080"),
new UrlResource("http://localhost:9090"));
}
@Test
@@ -104,7 +104,7 @@ class BeanWrapperGenericsTests {
gb.setResourceList(new ArrayList<>());
BeanWrapper bw = new BeanWrapperImpl(gb);
bw.setPropertyValue("resourceList[0]", "http://localhost:8080");
assertThat(gb.getResourceList()).element(0).isEqualTo(new UrlResource("http://localhost:8080"));
assertThat(gb.getResourceList()).containsExactly(new UrlResource("http://localhost:8080"));
}
@Test

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

@@ -655,9 +655,7 @@ class DefaultListableBeanFactoryTests {
lbf.registerSingleton("string2", "B");
TestBean self = (TestBean) lbf.getBean("self");
assertThat(self.getStringArray()).hasSize(2);
assertThat(self.getStringArray()).contains("A");
assertThat(self.getStringArray()).contains("B");
assertThat(self.getStringArray()).containsOnly("A","B");
}
@Test
@@ -2237,10 +2235,10 @@ class DefaultListableBeanFactoryTests {
ObjectProvider<TestBean> testBeanProvider = lbf.getBeanProvider(ResolvableType.forClass(TestBean.class));
List<TestBean> resolved = testBeanProvider.orderedStream().toList();
assertThat(resolved.size()).isEqualTo(3);
assertThat(resolved).element(0).isSameAs(lbf.getBean("highPriorityTestBean"));
assertThat(resolved).element(1).isSameAs(lbf.getBean("lowPriorityTestBean"));
assertThat(resolved).element(2).isSameAs(lbf.getBean("plainTestBean"));
assertThat(resolved).containsExactly(
lbf.getBean("highPriorityTestBean", TestBean.class),
lbf.getBean("lowPriorityTestBean", TestBean.class),
lbf.getBean("plainTestBean", TestBean.class));
}
@Test

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

@@ -78,6 +78,7 @@ import org.springframework.util.Assert;
import org.springframework.util.ObjectUtils;
import org.springframework.util.ReflectionUtils;
import static java.util.Map.entry;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
@@ -583,15 +584,9 @@ class AutowiredAnnotationBeanPostProcessorTests {
assertThat(bean.getTestBean3()).isSameAs(tb);
assertThat(bean.getTestBean4()).isSameAs(tb);
assertThat(bean.getIndexedTestBean()).isSameAs(itb);
assertThat(bean.getNestedTestBeans()).hasSize(2);
assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb1);
assertThat(bean.getNestedTestBeans()).element(1).isSameAs(ntb2);
assertThat(bean.nestedTestBeansSetter).hasSize(2);
assertThat(bean.nestedTestBeansSetter).element(0).isSameAs(ntb1);
assertThat(bean.nestedTestBeansSetter).element(1).isSameAs(ntb2);
assertThat(bean.nestedTestBeansField).hasSize(2);
assertThat(bean.nestedTestBeansField).element(0).isSameAs(ntb1);
assertThat(bean.nestedTestBeansField).element(1).isSameAs(ntb2);
assertThat(bean.getNestedTestBeans()).containsExactly(ntb1, ntb2);
assertThat(bean.nestedTestBeansSetter).containsExactly(ntb1, ntb2);
assertThat(bean.nestedTestBeansField).containsExactly(ntb1, ntb2);
}
@Test
@@ -614,12 +609,9 @@ class AutowiredAnnotationBeanPostProcessorTests {
assertThat(bean.getTestBean3()).isSameAs(tb);
assertThat(bean.getTestBean4()).isSameAs(tb);
assertThat(bean.getIndexedTestBean()).isSameAs(itb);
assertThat(bean.getNestedTestBeans()).hasSize(1);
assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb1);
assertThat(bean.nestedTestBeansSetter).hasSize(1);
assertThat(bean.nestedTestBeansSetter).element(0).isSameAs(ntb1);
assertThat(bean.nestedTestBeansField).hasSize(1);
assertThat(bean.nestedTestBeansField).element(0).isSameAs(ntb1);
assertThat(bean.getNestedTestBeans()).containsExactly(ntb1);
assertThat(bean.nestedTestBeansSetter).containsExactly(ntb1);
assertThat(bean.nestedTestBeansField).containsExactly(ntb1);
}
@Test
@@ -1057,8 +1049,7 @@ class AutowiredAnnotationBeanPostProcessorTests {
ConstructorsCollectionResourceInjectionBean bean = bf.getBean("annotatedBean", ConstructorsCollectionResourceInjectionBean.class);
assertThat(bean.getTestBean3()).isNull();
assertThat(bean.getTestBean4()).isSameAs(tb);
assertThat(bean.getNestedTestBeans()).hasSize(1);
assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb2);
assertThat(bean.getNestedTestBeans()).containsExactly(ntb2);
Map<String, NestedTestBean> map = bf.getBeansOfType(NestedTestBean.class);
assertThat(map.get("nestedTestBean1")).isNull();
@@ -1079,9 +1070,7 @@ class AutowiredAnnotationBeanPostProcessorTests {
ConstructorsCollectionResourceInjectionBean bean = bf.getBean("annotatedBean", ConstructorsCollectionResourceInjectionBean.class);
assertThat(bean.getTestBean3()).isNull();
assertThat(bean.getTestBean4()).isSameAs(tb);
assertThat(bean.getNestedTestBeans()).hasSize(2);
assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb1);
assertThat(bean.getNestedTestBeans()).element(1).isSameAs(ntb2);
assertThat(bean.getNestedTestBeans()).contains(ntb1, ntb2);
}
@Test
@@ -1515,8 +1504,7 @@ class AutowiredAnnotationBeanPostProcessorTests {
SelfInjectionCollectionBean bean = bf.getBean("annotatedBean", SelfInjectionCollectionBean.class);
SelfInjectionCollectionBean bean2 = bf.getBean("annotatedBean2", SelfInjectionCollectionBean.class);
assertThat(bean.reference).isSameAs(bean2);
assertThat(bean2.referenceCollection).hasSize(1);
assertThat(bean.referenceCollection).element(0).isSameAs(bean2);
assertThat(bean2.referenceCollection).containsExactly(bean2);
}
@Test
@@ -1682,22 +1670,12 @@ class AutowiredAnnotationBeanPostProcessorTests {
assertThat(bean.getUniqueTestBean()).isNull();
assertThat(bean.consumeUniqueTestBean()).isNull();
List<?> testBeans = bean.iterateTestBeans();
assertThat(testBeans).hasSize(2);
assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean1"));
assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean2"));
testBeans = bean.forEachTestBeans();
assertThat(testBeans).hasSize(2);
assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean1"));
assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean2"));
testBeans = bean.streamTestBeans();
assertThat(testBeans).hasSize(2);
assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean1"));
assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean2"));
testBeans = bean.sortedTestBeans();
assertThat(testBeans).hasSize(2);
assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean1"));
assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean2"));
TestBean testBean1 = bf.getBean("testBean1", TestBean.class);
TestBean testBean2 = bf.getBean("testBean2", TestBean.class);
assertThat(bean.iterateTestBeans()).containsExactly(testBean1, testBean2);
assertThat(bean.forEachTestBeans()).containsExactly(testBean1, testBean2);
assertThat(bean.streamTestBeans()).containsExactly(testBean1, testBean2);
assertThat(bean.sortedTestBeans()).containsExactly(testBean1, testBean2);
}
@Test
@@ -1713,29 +1691,19 @@ class AutowiredAnnotationBeanPostProcessorTests {
bf.registerBeanDefinition("testBean2", tb2);
ObjectProviderInjectionBean bean = bf.getBean("annotatedBean", ObjectProviderInjectionBean.class);
assertThat(bean.getTestBean()).isSameAs(bf.getBean("testBean1"));
assertThat(bean.getOptionalTestBean()).isSameAs(bf.getBean("testBean1"));
assertThat(bean.consumeOptionalTestBean()).isSameAs(bf.getBean("testBean1"));
assertThat(bean.getUniqueTestBean()).isSameAs(bf.getBean("testBean1"));
assertThat(bean.consumeUniqueTestBean()).isSameAs(bf.getBean("testBean1"));
TestBean testBean1 = bf.getBean("testBean1", TestBean.class);
assertThat(bean.getTestBean()).isSameAs(testBean1);
assertThat(bean.getOptionalTestBean()).isSameAs(testBean1);
assertThat(bean.consumeOptionalTestBean()).isSameAs(testBean1);
assertThat(bean.getUniqueTestBean()).isSameAs(testBean1);
assertThat(bean.consumeUniqueTestBean()).isSameAs(testBean1);
assertThat(bf.containsSingleton("testBean2")).isFalse();
List<?> testBeans = bean.iterateTestBeans();
assertThat(testBeans).hasSize(2);
assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean1"));
assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean2"));
testBeans = bean.forEachTestBeans();
assertThat(testBeans).hasSize(2);
assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean1"));
assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean2"));
testBeans = bean.streamTestBeans();
assertThat(testBeans).hasSize(2);
assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean1"));
assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean2"));
testBeans = bean.sortedTestBeans();
assertThat(testBeans).hasSize(2);
assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean2"));
assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean1"));
TestBean testBean2 = bf.getBean("testBean2", TestBean.class);
assertThat(bean.iterateTestBeans()).containsExactly(testBean1, testBean2);
assertThat(bean.forEachTestBeans()).containsExactly(testBean1, testBean2);
assertThat(bean.streamTestBeans()).containsExactly(testBean1, testBean2);
assertThat(bean.sortedTestBeans()).containsExactly(testBean2, testBean1);
}
@Test
@@ -1751,10 +1719,8 @@ class AutowiredAnnotationBeanPostProcessorTests {
bf.registerBeanDefinition("testBean2", tb2);
ObjectProviderInjectionBean bean = bf.getBean("annotatedBean", ObjectProviderInjectionBean.class);
List<?> testBeans = bean.sortedTestBeans();
assertThat(testBeans).hasSize(2);
assertThat(testBeans).element(0).isSameAs(bf.getBean("testBean2"));
assertThat(testBeans).element(1).isSameAs(bf.getBean("testBean1"));
assertThat(bean.sortedTestBeans()).containsExactly(bf.getBean("testBean2", TestBean.class),
bf.getBean("testBean1", TestBean.class));
}
@Test
@@ -2094,18 +2060,12 @@ class AutowiredAnnotationBeanPostProcessorTests {
Repository<?> ir = bf.getBean("integerRepository", Repository.class);
assertThat(bean.stringRepository).isSameAs(sr);
assertThat(bean.integerRepository).isSameAs(ir);
assertThat(bean.stringRepositoryArray).hasSize(1);
assertThat(bean.integerRepositoryArray).hasSize(1);
assertThat(bean.stringRepositoryArray[0]).isSameAs(sr);
assertThat(bean.integerRepositoryArray[0]).isSameAs(ir);
assertThat(bean.stringRepositoryList).hasSize(1);
assertThat(bean.integerRepositoryList).hasSize(1);
assertThat(bean.stringRepositoryList).element(0).isSameAs(sr);
assertThat(bean.integerRepositoryList).element(0).isSameAs(ir);
assertThat(bean.stringRepositoryMap).hasSize(1);
assertThat(bean.integerRepositoryMap).hasSize(1);
assertThat(bean.stringRepositoryMap.get("stringRepo")).isSameAs(sr);
assertThat(bean.integerRepositoryMap.get("integerRepository")).isSameAs(ir);
assertThat(bean.stringRepositoryArray).singleElement().isSameAs(sr);
assertThat(bean.integerRepositoryArray).singleElement().isSameAs(ir);
assertThat(bean.stringRepositoryList).singleElement().isSameAs(sr);
assertThat(bean.integerRepositoryList).singleElement().isSameAs(ir);
assertThat(bean.stringRepositoryMap).containsOnly(entry("stringRepo", sr));
assertThat(bean.integerRepositoryMap).containsOnly(entry("integerRepository", ir));
}
@Test
@@ -2121,16 +2081,14 @@ class AutowiredAnnotationBeanPostProcessorTests {
Repository<?> repo = bf.getBean("repo", Repository.class);
assertThat(bean.repository).isSameAs(repo);
assertThat(bean.stringRepository).isSameAs(repo);
assertThat(bean.repositoryArray).hasSize(1);
assertThat(bean.repositoryArray).containsExactly(repo);
assertThat(bean.stringRepositoryArray).hasSize(1);
assertThat(bean.repositoryArray[0]).isSameAs(repo);
assertThat(bean.stringRepositoryArray[0]).isSameAs(repo);
assertThat(bean.repositoryList).containsExactly(repo);
assertThat(bean.stringRepositoryList).hasSize(1);
assertThat(bean.stringRepositoryList).element(0).isSameAs(repo);
assertThat(bean.repositoryMap).hasSize(1);
assertThat(bean.repositoryMap).containsOnly(entry("repo", repo));
assertThat(bean.stringRepositoryMap).hasSize(1);
assertThat(bean.repositoryMap.get("repo")).isSameAs(repo);
assertThat(bean.stringRepositoryMap.get("repo")).isSameAs(repo);
assertThat(bf.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class))).isEqualTo(new String[] {"repo"});

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

@@ -195,9 +195,7 @@ class InjectAnnotationBeanPostProcessorTests {
ConstructorsCollectionResourceInjectionBean bean = (ConstructorsCollectionResourceInjectionBean) bf.getBean("annotatedBean");
assertThat(bean.getTestBean3()).isNull();
assertThat(bean.getTestBean4()).isSameAs(tb);
assertThat(bean.getNestedTestBeans()).hasSize(2);
assertThat(bean.getNestedTestBeans()).element(0).isSameAs(ntb1);
assertThat(bean.getNestedTestBeans()).element(1).isSameAs(ntb2);
assertThat(bean.getNestedTestBeans()).containsExactly(ntb1, ntb2);
}
@Test
@@ -530,8 +528,8 @@ class InjectAnnotationBeanPostProcessorTests {
bf.registerBeanDefinition("testBean", new RootBeanDefinition(TestBean.class));
OptionalListFieldInjectionBean bean = (OptionalListFieldInjectionBean) bf.getBean("annotatedBean");
assertThat(bean.getTestBean()).isPresent();
assertThat(bean.getTestBean().get()).element(0).isSameAs(bf.getBean("testBean"));
assertThat(bean.getTestBean()).hasValueSatisfying(list ->
assertThat(list).containsExactly(bf.getBean("testBean", TestBean.class)));
}
@Test
@@ -548,8 +546,8 @@ class InjectAnnotationBeanPostProcessorTests {
bf.registerBeanDefinition("testBean", new RootBeanDefinition(TestBean.class));
OptionalListMethodInjectionBean bean = (OptionalListMethodInjectionBean) bf.getBean("annotatedBean");
assertThat(bean.getTestBean()).isPresent();
assertThat(bean.getTestBean().get()).element(0).isSameAs(bf.getBean("testBean"));
assertThat(bean.getTestBean()).hasValueSatisfying(list ->
assertThat(list).containsExactly(bf.getBean("testBean", TestBean.class)));
}
@Test

4
spring-beans/src/test/java/org/springframework/beans/factory/aot/AotServicesTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2023 the original author or authors.
* Copyright 2002-2024 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.
@@ -115,7 +115,7 @@ class AotServicesTests {
AotServices<?> loaded = AotServices
.factories(new TestSpringFactoriesClassLoader("aot-services.factories"))
.load(TestService.class);
assertThat(loaded).element(0).isInstanceOf(TestServiceImpl.class);
assertThat(loaded).singleElement().isInstanceOf(TestServiceImpl.class);
}
@Test

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

@@ -21,7 +21,6 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Predicate;
@@ -29,6 +28,7 @@ import java.util.function.Supplier;
import javax.lang.model.element.Modifier;
import org.assertj.core.api.InstanceOfAssertFactories;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.reactivestreams.Publisher;
@@ -260,11 +260,11 @@ class BeanDefinitionPropertiesCodeGeneratorTests {
compile((actual, compiled) -> {
ConstructorArgumentValues argumentValues = actual.getConstructorArgumentValues();
List<ValueHolder> values = argumentValues.getGenericArgumentValues();
assertThat(values).element(0).satisfies(assertValueHolder(String.class, null, null));
assertThat(values).element(1).satisfies(assertValueHolder(2, Long.class, null));
assertThat(values).element(2).satisfies(assertValueHolder("value", null, "param1"));
assertThat(values).element(3).satisfies(assertValueHolder("another", CharSequence.class, "param2"));
assertThat(values).hasSize(4);
assertThat(values).satisfiesExactly(
assertValueHolder(String.class, null, null),
assertValueHolder(2, Long.class, null),
assertValueHolder("value", null, "param1"),
assertValueHolder("another", CharSequence.class, "param2"));
assertThat(argumentValues.getIndexedArgumentValues()).isEmpty();
});
}
@@ -324,8 +324,8 @@ class BeanDefinitionPropertiesCodeGeneratorTests {
this.beanDefinition.getPropertyValues().add("value", managedList);
compile((actual, compiled) -> {
Object value = actual.getPropertyValues().get("value");
assertThat(value).isInstanceOf(ManagedList.class);
assertThat(((List<?>) value)).element(0).isInstanceOf(BeanReference.class);
assertThat(value).isInstanceOf(ManagedList.class).asInstanceOf(InstanceOfAssertFactories.LIST)
.singleElement().isInstanceOf(BeanReference.class);
});
}
@@ -336,8 +336,9 @@ class BeanDefinitionPropertiesCodeGeneratorTests {
this.beanDefinition.getPropertyValues().add("value", managedSet);
compile((actual, compiled) -> {
Object value = actual.getPropertyValues().get("value");
assertThat(value).isInstanceOf(ManagedSet.class);
assertThat(((Set<?>) value)).element(0).isInstanceOf(BeanReference.class);
assertThat(value).isInstanceOf(ManagedSet.class)
.asInstanceOf(InstanceOfAssertFactories.COLLECTION)
.singleElement().isInstanceOf(BeanReference.class);
});
}
@@ -348,8 +349,9 @@ class BeanDefinitionPropertiesCodeGeneratorTests {
this.beanDefinition.getPropertyValues().add("value", managedMap);
compile((actual, compiled) -> {
Object value = actual.getPropertyValues().get("value");
assertThat(value).isInstanceOf(ManagedMap.class);
assertThat(((Map<?, ?>) value).get("test")).isInstanceOf(BeanReference.class);
assertThat(value).isInstanceOf(ManagedMap.class)
.asInstanceOf(InstanceOfAssertFactories.map(String.class, Object.class))
.hasEntrySatisfying("test", ref -> assertThat(ref).isInstanceOf(BeanReference.class));
});
}
@@ -429,9 +431,8 @@ class BeanDefinitionPropertiesCodeGeneratorTests {
this.beanDefinition.addQualifier(new AutowireCandidateQualifier("com.example.Another", ChronoUnit.SECONDS));
compile((actual, compiled) -> {
List<AutowireCandidateQualifier> qualifiers = new ArrayList<>(actual.getQualifiers());
assertThat(qualifiers).element(0).satisfies(isQualifierFor("com.example.Qualifier", "id"));
assertThat(qualifiers).element(1).satisfies(isQualifierFor("com.example.Another", ChronoUnit.SECONDS));
assertThat(qualifiers).hasSize(2);
assertThat(qualifiers).satisfiesExactly(isQualifierFor("com.example.Qualifier", "id"),
isQualifierFor("com.example.Another", ChronoUnit.SECONDS));
});
}

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

@@ -400,12 +400,11 @@ class PropertyResourceConfigurerTests {
assertThat(tb1.getSpouse()).isEqualTo(tb2);
assertThat(tb1.getSomeMap()).hasSize(1);
assertThat(tb1.getSomeMap().get("myKey")).isEqualTo("myValue");
assertThat(tb2.getStringArray()).hasSize(2);
assertThat(tb2.getStringArray()[0]).isEqualTo(System.getProperty("os.name"));
assertThat(tb2.getStringArray()[1]).isEqualTo("98");
assertThat(tb2.getFriends()).hasSize(2);
assertThat(tb2.getFriends()).element(0).isEqualTo("na98me");
assertThat(tb2.getFriends().toArray()[1]).isEqualTo(tb2);
assertThat(tb2.getStringArray()).containsExactly(System.getProperty("os.name"), "98");
assertThat(tb2.getFriends()).satisfiesExactly(
zero -> assertThat(zero).isInstanceOfSatisfying(
String.class, value -> assertThat(value).isEqualTo("na98me")),
one -> assertThat(one).isEqualTo(tb2));
assertThat(tb2.getSomeSet()).hasSize(3);
assertThat(tb2.getSomeSet().contains("na98me")).isTrue();
assertThat(tb2.getSomeSet().contains(tb2)).isTrue();

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

@@ -27,7 +27,6 @@ import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
@@ -573,9 +572,10 @@ class BeanFactoryGenericsTests {
new XmlBeanDefinitionReader(bf).loadBeanDefinitions(
new ClassPathResource("genericBeanTests.xml", getClass()));
GenericSetOfIntegerBean gb = (GenericSetOfIntegerBean) bf.getBean("setOfIntegerBean");
assertThat(gb.getGenericProperty()).element(0).isEqualTo(10);
assertThat(gb.getGenericListProperty().get(0)).containsExactly(20);
assertThat(gb.getGenericListProperty().get(1)).containsExactly(30);
assertThat(gb.getGenericProperty()).singleElement().isEqualTo(10);
assertThat(gb.getGenericListProperty()).satisfiesExactly(
zero -> assertThat(zero).containsExactly(20),
first -> assertThat(first).containsExactly(30));
}
@Test
@@ -782,8 +782,10 @@ class BeanFactoryGenericsTests {
new RootBeanDefinition(NumberBean.class, RootBeanDefinition.AUTOWIRE_CONSTRUCTOR, false));
NumberBean nb = bf.getBean(NumberBean.class);
assertThat(nb.getDoubleStore()).isSameAs(bf.getBean("store1"));
assertThat(nb.getFloatStore()).isSameAs(bf.getBean("store2"));
NumberStore<?> store1 = bf.getBean("store1", NumberStore.class);
assertThat(nb.getDoubleStore()).isSameAs(store1);
NumberStore<?> store2 = bf.getBean("store2", NumberStore.class);
assertThat(nb.getFloatStore()).isSameAs(store2);
String[] numberStoreNames = bf.getBeanNamesForType(ResolvableType.forClass(NumberStore.class));
String[] doubleStoreNames = bf.getBeanNamesForType(ResolvableType.forClassWithGenerics(NumberStore.class, Double.class));
@@ -798,54 +800,36 @@ class BeanFactoryGenericsTests {
assertThatExceptionOfType(NoUniqueBeanDefinitionException.class).isThrownBy(numberStoreProvider::getObject);
assertThatExceptionOfType(NoUniqueBeanDefinitionException.class).isThrownBy(numberStoreProvider::getIfAvailable);
assertThat(numberStoreProvider.getIfUnique()).isNull();
assertThat(doubleStoreProvider.getObject()).isSameAs(bf.getBean("store1"));
assertThat(doubleStoreProvider.getIfAvailable()).isSameAs(bf.getBean("store1"));
assertThat(doubleStoreProvider.getIfUnique()).isSameAs(bf.getBean("store1"));
assertThat(floatStoreProvider.getObject()).isSameAs(bf.getBean("store2"));
assertThat(floatStoreProvider.getIfAvailable()).isSameAs(bf.getBean("store2"));
assertThat(floatStoreProvider.getIfUnique()).isSameAs(bf.getBean("store2"));
assertThat(doubleStoreProvider.getObject()).isSameAs(store1);
assertThat(doubleStoreProvider.getIfAvailable()).isSameAs(store1);
assertThat(doubleStoreProvider.getIfUnique()).isSameAs(store1);
assertThat(floatStoreProvider.getObject()).isSameAs(store2);
assertThat(floatStoreProvider.getIfAvailable()).isSameAs(store2);
assertThat(floatStoreProvider.getIfUnique()).isSameAs(store2);
List<NumberStore<?>> resolved = new ArrayList<>();
for (NumberStore<?> instance : numberStoreProvider) {
resolved.add(instance);
}
assertThat(resolved).hasSize(2);
assertThat(resolved).element(0).isSameAs(bf.getBean("store1"));
assertThat(resolved).element(1).isSameAs(bf.getBean("store2"));
resolved = numberStoreProvider.stream().toList();
assertThat(resolved).hasSize(2);
assertThat(resolved).element(0).isSameAs(bf.getBean("store1"));
assertThat(resolved).element(1).isSameAs(bf.getBean("store2"));
resolved = numberStoreProvider.orderedStream().toList();
assertThat(resolved).hasSize(2);
assertThat(resolved).element(0).isSameAs(bf.getBean("store2"));
assertThat(resolved).element(1).isSameAs(bf.getBean("store1"));
assertThat(resolved).containsExactly(store1, store2);
assertThat(numberStoreProvider.stream()).containsExactly(store1, store2);
assertThat(numberStoreProvider.orderedStream()).containsExactly(store2, store1);
resolved = new ArrayList<>();
for (NumberStore<Double> instance : doubleStoreProvider) {
resolved.add(instance);
}
assertThat(resolved).containsExactly(bf.getBean("store1", NumberStore.class));
resolved = doubleStoreProvider.stream().collect(Collectors.toList());
assertThat(resolved).containsExactly(bf.getBean("store1", NumberStore.class));
resolved = doubleStoreProvider.orderedStream().collect(Collectors.toList());
assertThat(resolved).containsExactly(bf.getBean("store1", NumberStore.class));
assertThat(resolved).containsExactly(store1);
assertThat(doubleStoreProvider.stream()).singleElement().isEqualTo(store1);
assertThat(doubleStoreProvider.orderedStream()).singleElement().isEqualTo(store1);
resolved = new ArrayList<>();
for (NumberStore<Float> instance : floatStoreProvider) {
resolved.add(instance);
}
assertThat(resolved).containsExactly(bf.getBean("store2", NumberStore.class));
resolved = floatStoreProvider.stream().collect(Collectors.toList());
assertThat(resolved).containsExactly(bf.getBean("store2", NumberStore.class));
resolved = floatStoreProvider.orderedStream().collect(Collectors.toList());
assertThat(resolved).containsExactly(bf.getBean("store2", NumberStore.class));
assertThat(resolved).containsExactly(store2);
assertThat(floatStoreProvider.stream()).singleElement().isEqualTo(store2);
assertThat(floatStoreProvider.orderedStream()).singleElement().isEqualTo(store2);
}
@Test
@@ -862,10 +846,8 @@ class BeanFactoryGenericsTests {
bf.registerBeanDefinition("store2", bd2);
ObjectProvider<NumberStore<?>> numberStoreProvider = bf.getBeanProvider(ResolvableType.forClass(NumberStore.class));
List<NumberStore<?>> resolved = numberStoreProvider.orderedStream().toList();
assertThat(resolved).hasSize(2);
assertThat(resolved).element(0).isSameAs(bf.getBean("store2"));
assertThat(resolved).element(1).isSameAs(bf.getBean("store1"));
assertThat(numberStoreProvider.orderedStream()).containsExactly(
bf.getBean("store2", NumberStore.class), bf.getBean("store1", NumberStore.class));
}

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

@@ -131,10 +131,7 @@ class CollectionMergingTests {
void mergeListWithInnerBeanAsListElementInConstructor() {
TestBean bean = (TestBean) this.beanFactory.getBean("childWithListOfRefsInConstructor");
List<?> list = bean.getSomeList();
assertThat(list).isNotNull();
assertThat(list).hasSize(3);
assertThat(list).element(2).isNotNull();
assertThat(list.get(2)).isInstanceOf(TestBean.class);
assertThat(list).hasSize(3).element(2).isInstanceOf(TestBean.class);
}
@Test

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

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

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

@@ -24,6 +24,7 @@ import java.util.Properties;
import java.util.Set;
import java.util.TreeMap;
import org.assertj.core.api.InstanceOfAssertFactories;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -125,36 +126,41 @@ class UtilNamespaceHandlerTests {
@Test
void testSimpleList() {
List<?> list = (List) this.beanFactory.getBean("simpleList");
assertThat(list).element(0).isEqualTo("Rob Harrop");
List<?> list2 = (List) this.beanFactory.getBean("simpleList");
assertThat(list).isSameAs(list2);
assertThat(this.beanFactory.getBean("simpleList"))
.asInstanceOf(InstanceOfAssertFactories.LIST).element(0).isEqualTo("Rob Harrop");
assertThat(this.beanFactory.getBean("simpleList"))
.isSameAs(this.beanFactory.getBean("simpleList"));
}
@Test
void testScopedList() {
List<?> list = (List) this.beanFactory.getBean("scopedList");
assertThat(list).element(0).isEqualTo("Rob Harrop");
List<?> list2 = (List) this.beanFactory.getBean("scopedList");
assertThat(list2).element(0).isEqualTo("Rob Harrop");
assertThat(list).isNotSameAs(list2);
assertThat(this.beanFactory.getBean("scopedList"))
.asInstanceOf(InstanceOfAssertFactories.LIST).element(0).isEqualTo("Rob Harrop");
assertThat(this.beanFactory.getBean("scopedList"))
.asInstanceOf(InstanceOfAssertFactories.LIST).element(0).isEqualTo("Rob Harrop");
assertThat(this.beanFactory.getBean("scopedList"))
.isNotSameAs(this.beanFactory.getBean("scopedList"));
}
@Test
void testSimpleSet() {
Set<?> set = (Set) this.beanFactory.getBean("simpleSet");
assertThat(set.contains("Rob Harrop")).isTrue();
Set<?> set2 = (Set) this.beanFactory.getBean("simpleSet");
assertThat(set).isSameAs(set2);
assertThat(this.beanFactory.getBean("simpleSet")).isInstanceOf(Set.class)
.asInstanceOf(InstanceOfAssertFactories.collection(String.class))
.containsOnly("Rob Harrop");
assertThat(this.beanFactory.getBean("simpleSet"))
.isSameAs(this.beanFactory.getBean("simpleSet"));
}
@Test
void testScopedSet() {
Set<?> set = (Set) this.beanFactory.getBean("scopedSet");
assertThat(set.contains("Rob Harrop")).isTrue();
Set<?> set2 = (Set) this.beanFactory.getBean("scopedSet");
assertThat(set2.contains("Rob Harrop")).isTrue();
assertThat(set).isNotSameAs(set2);
assertThat(this.beanFactory.getBean("scopedSet")).isInstanceOf(Set.class)
.asInstanceOf(InstanceOfAssertFactories.collection(String.class))
.containsOnly("Rob Harrop");
assertThat(this.beanFactory.getBean("scopedSet")).isInstanceOf(Set.class)
.asInstanceOf(InstanceOfAssertFactories.collection(String.class))
.containsOnly("Rob Harrop");
assertThat(this.beanFactory.getBean("scopedSet"))
.isNotSameAs(this.beanFactory.getBean("scopedSet"));
}
@Test
@@ -175,95 +181,71 @@ class UtilNamespaceHandlerTests {
void testNestedCollections() {
TestBean bean = (TestBean) this.beanFactory.getBean("nestedCollectionsBean");
List<?> list = bean.getSomeList();
assertThat(list).hasSize(1);
assertThat(list).element(0).isEqualTo("foo");
Set<?> set = bean.getSomeSet();
assertThat(set).hasSize(1);
assertThat(set.contains("bar")).isTrue();
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();
assertThat(bean.getSomeList()).singleElement().isEqualTo("foo");
assertThat(bean.getSomeSet()).singleElement().isEqualTo("bar");
assertThat(bean.getSomeMap()).hasSize(1).allSatisfy((key, nested) -> {
assertThat(key).isEqualTo("foo");
assertThat(nested).isInstanceOf(Set.class).asInstanceOf(
InstanceOfAssertFactories.collection(String.class)).containsOnly("bar");
});
TestBean bean2 = (TestBean) this.beanFactory.getBean("nestedCollectionsBean");
assertThat(bean2.getSomeList()).isEqualTo(list);
assertThat(bean2.getSomeSet()).isEqualTo(set);
assertThat(bean2.getSomeMap()).isEqualTo(map);
assertThat(list).isNotSameAs(bean2.getSomeList());
assertThat(set).isNotSameAs(bean2.getSomeSet());
assertThat(map).isNotSameAs(bean2.getSomeMap());
assertThat(bean2.getSomeList()).isEqualTo(bean.getSomeList());
assertThat(bean2.getSomeSet()).isEqualTo(bean.getSomeSet());
assertThat(bean2.getSomeMap()).isEqualTo(bean.getSomeMap());
assertThat(bean.getSomeList()).isNotSameAs(bean2.getSomeList());
assertThat(bean.getSomeSet()).isNotSameAs(bean2.getSomeSet());
assertThat(bean.getSomeMap()).isNotSameAs(bean2.getSomeMap());
}
@Test
void testNestedShortcutCollections() {
TestBean bean = (TestBean) this.beanFactory.getBean("nestedShortcutCollections");
assertThat(bean.getStringArray()).hasSize(1);
assertThat(bean.getStringArray()[0]).isEqualTo("fooStr");
List<?> list = bean.getSomeList();
assertThat(list).hasSize(1);
assertThat(list).element(0).isEqualTo("foo");
Set<?> set = bean.getSomeSet();
assertThat(set).hasSize(1);
assertThat(set.contains("bar")).isTrue();
assertThat(bean.getStringArray()).containsExactly("fooStr");
assertThat(bean.getSomeList()).singleElement().isEqualTo("foo");
assertThat(bean.getSomeSet()).singleElement().isEqualTo("bar");
TestBean bean2 = (TestBean) this.beanFactory.getBean("nestedShortcutCollections");
assertThat(Arrays.equals(bean.getStringArray(), bean2.getStringArray())).isTrue();
assertThat(bean.getStringArray()).isNotSameAs(bean2.getStringArray());
assertThat(bean2.getSomeList()).isEqualTo(list);
assertThat(bean2.getSomeSet()).isEqualTo(set);
assertThat(list).isNotSameAs(bean2.getSomeList());
assertThat(set).isNotSameAs(bean2.getSomeSet());
assertThat(bean2.getSomeList()).isEqualTo(bean.getSomeList());
assertThat(bean2.getSomeSet()).isEqualTo(bean.getSomeSet());
assertThat(bean.getSomeList()).isNotSameAs(bean2.getSomeList());
assertThat(bean.getSomeSet()).isNotSameAs(bean2.getSomeSet());
}
@Test
void testNestedInCollections() {
TestBean bean = (TestBean) this.beanFactory.getBean("nestedCustomTagBean");
List<?> list = bean.getSomeList();
assertThat(list).hasSize(1);
assertThat(list).element(0).isEqualTo(Integer.MIN_VALUE);
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).hasSize(1);
assertThat(map.get("min")).isEqualTo(CustomEnum.VALUE_1);
assertThat(bean.getSomeList()).singleElement().isEqualTo(Integer.MIN_VALUE);
assertThat(bean.getSomeSet()).asInstanceOf(InstanceOfAssertFactories.collection(Thread.State.class))
.containsOnly(Thread.State.NEW,Thread.State.RUNNABLE);
assertThat(bean.getSomeMap()).hasSize(1).allSatisfy((key, value) -> {
assertThat(key).isEqualTo("min");
assertThat(value).isEqualTo(CustomEnum.VALUE_1);
});
TestBean bean2 = (TestBean) this.beanFactory.getBean("nestedCustomTagBean");
assertThat(bean2.getSomeList()).isEqualTo(list);
assertThat(bean2.getSomeSet()).isEqualTo(set);
assertThat(bean2.getSomeMap()).isEqualTo(map);
assertThat(list).isNotSameAs(bean2.getSomeList());
assertThat(set).isNotSameAs(bean2.getSomeSet());
assertThat(map).isNotSameAs(bean2.getSomeMap());
assertThat(bean2.getSomeList()).isEqualTo(bean.getSomeList());
assertThat(bean2.getSomeSet()).isEqualTo(bean.getSomeSet());
assertThat(bean2.getSomeMap()).isEqualTo(bean.getSomeMap());
assertThat(bean.getSomeList()).isNotSameAs(bean2.getSomeList());
assertThat(bean.getSomeSet()).isNotSameAs(bean2.getSomeSet());
assertThat(bean.getSomeMap()).isNotSameAs(bean2.getSomeMap());
}
@Test
void testCircularCollections() {
TestBean bean = (TestBean) this.beanFactory.getBean("circularCollectionsBean");
List<?> list = bean.getSomeList();
assertThat(list).hasSize(1);
assertThat(list).element(0).isEqualTo(bean);
Set<?> set = bean.getSomeSet();
assertThat(set).hasSize(1);
assertThat(set.contains(bean)).isTrue();
Map<?, ?> map = bean.getSomeMap();
assertThat(map).hasSize(1);
assertThat(map.get("foo")).isEqualTo(bean);
assertThat(bean.getSomeList()).singleElement().isEqualTo(bean);
assertThat(bean.getSomeSet()).singleElement().isEqualTo(bean);
assertThat(bean.getSomeMap()).hasSize(1).allSatisfy((key, value) -> {
assertThat(key).isEqualTo("foo");
assertThat(value).isEqualTo(bean);
});
}
@Test
@@ -273,18 +255,18 @@ class UtilNamespaceHandlerTests {
List<?> list = bean.getSomeList();
assertThat(Proxy.isProxyClass(list.getClass())).isTrue();
assertThat(list).hasSize(1);
assertThat(list).element(0).isEqualTo(bean);
assertThat(list).singleElement().isEqualTo(bean);
Set<?> set = bean.getSomeSet();
assertThat(Proxy.isProxyClass(set.getClass())).isFalse();
assertThat(set).hasSize(1);
assertThat(set.contains(bean)).isTrue();
assertThat(set).singleElement().isEqualTo(bean);
Map<?, ?> map = bean.getSomeMap();
assertThat(Proxy.isProxyClass(map.getClass())).isFalse();
assertThat(map).hasSize(1);
assertThat(map.get("foo")).isEqualTo(bean);
assertThat(map).hasSize(1).allSatisfy((key, value) -> {
assertThat(key).isEqualTo("foo");
assertThat(value).isEqualTo(bean);
});
}
@Test
@@ -294,18 +276,18 @@ class UtilNamespaceHandlerTests {
List<?> list = bean.getSomeList();
assertThat(Proxy.isProxyClass(list.getClass())).isFalse();
assertThat(list).hasSize(1);
assertThat(list).element(0).isEqualTo(bean);
assertThat(list).singleElement().isEqualTo(bean);
Set<?> set = bean.getSomeSet();
assertThat(Proxy.isProxyClass(set.getClass())).isTrue();
assertThat(set).hasSize(1);
assertThat(set.contains(bean)).isTrue();
assertThat(set).singleElement().isEqualTo(bean);
Map<?, ?> map = bean.getSomeMap();
assertThat(Proxy.isProxyClass(map.getClass())).isFalse();
assertThat(map).hasSize(1);
assertThat(map.get("foo")).isEqualTo(bean);
assertThat(map).hasSize(1).allSatisfy((key, value) -> {
assertThat(key).isEqualTo("foo");
assertThat(value).isEqualTo(bean);
});
}
@Test
@@ -315,18 +297,18 @@ class UtilNamespaceHandlerTests {
List<?> list = bean.getSomeList();
assertThat(Proxy.isProxyClass(list.getClass())).isFalse();
assertThat(list).hasSize(1);
assertThat(list).element(0).isEqualTo(bean);
assertThat(list).singleElement().isEqualTo(bean);
Set<?> set = bean.getSomeSet();
assertThat(Proxy.isProxyClass(set.getClass())).isFalse();
assertThat(set).hasSize(1);
assertThat(set.contains(bean)).isTrue();
assertThat(set).singleElement().isEqualTo(bean);
Map<?, ?> map = bean.getSomeMap();
assertThat(Proxy.isProxyClass(map.getClass())).isTrue();
assertThat(map).hasSize(1);
assertThat(map.get("foo")).isEqualTo(bean);
assertThat(map).hasSize(1).allSatisfy((key, value) -> {
assertThat(key).isEqualTo("foo");
assertThat(value).isEqualTo(bean);
});
}
@Test

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

@@ -154,14 +154,13 @@ class XmlBeanCollectionTests {
void testRefSubelementsBuildCollectionFromSingleElement() {
TestBean loner = (TestBean) this.beanFactory.getBean("loner");
TestBean dave = (TestBean) this.beanFactory.getBean("david");
assertThat(loner.getFriends().size()).isEqualTo(1);
assertThat(loner.getFriends()).contains(dave);
assertThat(loner.getFriends()).containsOnly(dave);
}
@Test
void testBuildCollectionFromMixtureOfReferencesAndValues() {
MixedCollectionBean jumble = (MixedCollectionBean) this.beanFactory.getBean("jumble");
assertThat(jumble.getJumble().size()).as("Expected 5 elements, not " + jumble.getJumble().size()).isEqualTo(5);
assertThat(jumble.getJumble()).as("Expected 5 elements, not " + jumble.getJumble()).hasSize(5);
List l = (List) jumble.getJumble();
assertThat(l.get(0).equals(this.beanFactory.getBean("david"))).isTrue();
assertThat(l.get(1).equals("literal")).isTrue();
@@ -183,13 +182,13 @@ class XmlBeanCollectionTests {
@Test
void testEmptyMap() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("emptyMap");
assertThat(hasMap.getMap().size()).isEqualTo(0);
assertThat(hasMap.getMap()).hasSize(0);
}
@Test
void testMapWithLiteralsOnly() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("literalMap");
assertThat(hasMap.getMap().size()).isEqualTo(3);
assertThat(hasMap.getMap()).hasSize(3);
assertThat(hasMap.getMap().get("foo").equals("bar")).isTrue();
assertThat(hasMap.getMap().get("fi").equals("fum")).isTrue();
assertThat(hasMap.getMap().get("fa")).isNull();
@@ -198,7 +197,7 @@ class XmlBeanCollectionTests {
@Test
void testMapWithLiteralsAndReferences() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("mixedMap");
assertThat(hasMap.getMap().size()).isEqualTo(5);
assertThat(hasMap.getMap()).hasSize(5);
assertThat(hasMap.getMap().get("foo")).isEqualTo(10);
TestBean jenny = (TestBean) this.beanFactory.getBean("jenny");
assertThat(hasMap.getMap().get("jenny")).isSameAs(jenny);
@@ -213,13 +212,13 @@ class XmlBeanCollectionTests {
void testMapWithLiteralsAndPrototypeReferences() {
TestBean jenny = (TestBean) this.beanFactory.getBean("pJenny");
HasMap hasMap = (HasMap) this.beanFactory.getBean("pMixedMap");
assertThat(hasMap.getMap().size()).isEqualTo(2);
assertThat(hasMap.getMap()).hasSize(2);
assertThat(hasMap.getMap().get("foo").equals("bar")).isTrue();
assertThat(hasMap.getMap().get("jenny").toString()).isEqualTo(jenny.toString());
assertThat(hasMap.getMap().get("jenny")).as("Not same instance").isNotSameAs(jenny);
HasMap hasMap2 = (HasMap) this.beanFactory.getBean("pMixedMap");
assertThat(hasMap2.getMap().size()).isEqualTo(2);
assertThat(hasMap2.getMap()).hasSize(2);
assertThat(hasMap2.getMap().get("foo").equals("bar")).isTrue();
assertThat(hasMap2.getMap().get("jenny").toString()).isEqualTo(jenny.toString());
assertThat(hasMap2.getMap().get("jenny")).as("Not same instance").isNotSameAs(hasMap.getMap().get("jenny"));
@@ -228,7 +227,7 @@ class XmlBeanCollectionTests {
@Test
void testMapWithLiteralsReferencesAndList() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("mixedMapWithList");
assertThat(hasMap.getMap().size()).isEqualTo(4);
assertThat(hasMap.getMap()).hasSize(4);
assertThat(hasMap.getMap().get(null).equals("bar")).isTrue();
TestBean jenny = (TestBean) this.beanFactory.getBean("jenny");
assertThat(hasMap.getMap().get("jenny")).isEqualTo(jenny);
@@ -236,28 +235,28 @@ class XmlBeanCollectionTests {
// Check list
List l = (List) hasMap.getMap().get("list");
assertThat(l).isNotNull();
assertThat(l.size()).isEqualTo(4);
assertThat(l).hasSize(4);
assertThat(l.get(0).equals("zero")).isTrue();
assertThat(l).element(3).isNull();
// Check nested map in list
Map m = (Map) l.get(1);
assertThat(m).isNotNull();
assertThat(m.size()).isEqualTo(2);
assertThat(m).hasSize(2);
assertThat(m.get("fo").equals("bar")).isTrue();
assertThat(m.get("jen").equals(jenny)).as("Map element 'jenny' should be equal to jenny bean, not " + m.get("jen")).isTrue();
// Check nested list in list
l = (List) l.get(2);
assertThat(l).isNotNull();
assertThat(l.size()).isEqualTo(2);
assertThat(l).hasSize(2);
assertThat(l.get(0)).isEqualTo(jenny);
assertThat(l.get(1).equals("ba")).isTrue();
// Check nested map
m = (Map) hasMap.getMap().get("map");
assertThat(m).isNotNull();
assertThat(m.size()).isEqualTo(2);
assertThat(m).hasSize(2);
assertThat(m.get("foo").equals("bar")).isTrue();
assertThat(m.get("jenny").equals(jenny)).as("Map element 'jenny' should be equal to jenny bean, not " + m.get("jenny")).isTrue();
}
@@ -265,13 +264,13 @@ class XmlBeanCollectionTests {
@Test
void testEmptySet() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("emptySet");
assertThat(hasMap.getSet().size()).isEqualTo(0);
assertThat(hasMap.getSet()).hasSize(0);
}
@Test
void testPopulatedSet() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("set");
assertThat(hasMap.getSet().size()).isEqualTo(3);
assertThat(hasMap.getSet()).hasSize(3);
assertThat(hasMap.getSet().contains("bar")).isTrue();
TestBean jenny = (TestBean) this.beanFactory.getBean("jenny");
assertThat(hasMap.getSet().contains(jenny)).isTrue();
@@ -285,7 +284,7 @@ class XmlBeanCollectionTests {
@Test
void testPopulatedConcurrentSet() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("concurrentSet");
assertThat(hasMap.getConcurrentSet().size()).isEqualTo(3);
assertThat(hasMap.getConcurrentSet()).hasSize(3);
assertThat(hasMap.getConcurrentSet().contains("bar")).isTrue();
TestBean jenny = (TestBean) this.beanFactory.getBean("jenny");
assertThat(hasMap.getConcurrentSet().contains(jenny)).isTrue();
@@ -295,7 +294,7 @@ class XmlBeanCollectionTests {
@Test
void testPopulatedIdentityMap() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("identityMap");
assertThat(hasMap.getIdentityMap().size()).isEqualTo(2);
assertThat(hasMap.getIdentityMap()).hasSize(2);
HashSet set = new HashSet(hasMap.getIdentityMap().keySet());
assertThat(set).contains("foo");
assertThat(set).contains("jenny");
@@ -304,14 +303,14 @@ class XmlBeanCollectionTests {
@Test
void testEmptyProps() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("emptyProps");
assertThat(hasMap.getProps().size()).isEqualTo(0);
assertThat(hasMap.getProps()).hasSize(0);
assertThat(Properties.class).isEqualTo(hasMap.getProps().getClass());
}
@Test
void testPopulatedProps() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("props");
assertThat(hasMap.getProps().size()).isEqualTo(2);
assertThat(hasMap.getProps()).hasSize(2);
assertThat(hasMap.getProps().get("foo").equals("bar")).isTrue();
assertThat(hasMap.getProps().get("2").equals("TWO")).isTrue();
}
@@ -344,7 +343,7 @@ class XmlBeanCollectionTests {
@Test
void testClassList() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("classList");
assertThat(hasMap.getClassList().size()).isEqualTo(2);
assertThat(hasMap.getClassList()).hasSize(2);
assertThat(hasMap.getClassList().get(0).equals(String.class)).isTrue();
assertThat(hasMap.getClassList().get(1).equals(Exception.class)).isTrue();
}

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

@@ -22,6 +22,7 @@ import java.util.Properties;
import org.junit.jupiter.api.Test;
import static java.util.Map.entry;
import static org.assertj.core.api.Assertions.assertThat;
/**
@@ -132,9 +133,8 @@ class PropertiesEditorTests {
PropertiesEditor pe= new PropertiesEditor();
pe.setAsText(s);
Properties p = (Properties) pe.getValue();
assertThat(p.size()).as("contains 3 entries, not " + p.size()).isEqualTo(3);
assertThat(p.get("foo").equals("bar")).as("foo is bar").isTrue();
assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
assertThat(p).contains(entry("foo", "bar"), entry("me", "mi"));
assertThat(p).hasSize(3);
}
@Test