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

User AssertJ's hasSize() for arrays 

Achieved via global search-and-replace.
This commit is contained in:
Sam Brannen 2022-11-22 17:03:45 +01:00
parent 36f7597f25
commit d5b0b2b1a1
72 changed files with 277 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -195,7 +195,7 @@ abstract class AbstractAspectJAdvisorFactoryTests {
Advised advised = (Advised) itb;
// Will be ExposeInvocationInterceptor, synthetic instantiation advisor, 2 method advisors
assertThat(advised.getAdvisors().length).isEqualTo(4);
assertThat(advised.getAdvisors()).hasSize(4);
ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor sia =
(ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor) advised.getAdvisors()[1];
assertThat(sia.getPointcut().getMethodMatcher().matches(TestBean.class.getMethod("getSpouse"), null)).isTrue();
@ -231,7 +231,7 @@ abstract class AbstractAspectJAdvisorFactoryTests {
Advised advised = (Advised) itb;
// Will be ExposeInvocationInterceptor, synthetic instantiation advisor, 2 method advisors
assertThat(advised.getAdvisors().length).isEqualTo(4);
assertThat(advised.getAdvisors()).hasSize(4);
ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor sia =
(ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor) advised.getAdvisors()[1];
assertThat(sia.getPointcut().getMethodMatcher().matches(TestBean.class.getMethod("getSpouse"), null)).isTrue();

2
spring-aop/src/test/java/org/springframework/aop/support/AbstractRegexpMethodPointcutTests.java
View File

@ -56,7 +56,7 @@ public abstract class AbstractRegexpMethodPointcutTests {
protected void noPatternSuppliedTests(AbstractRegexpMethodPointcut rpc) throws Exception {
assertThat(rpc.matches(Object.class.getMethod("hashCode"), String.class)).isFalse();
assertThat(rpc.matches(Object.class.getMethod("wait"), Object.class)).isFalse();
assertThat(rpc.getPatterns().length).isEqualTo(0);
assertThat(rpc.getPatterns()).hasSize(0);
}
@Test

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

@ -63,7 +63,7 @@ public class BeanWrapperAutoGrowingTests {
@Test
public void getPropertyValueAutoGrowArray() {
assertNotNull(wrapper.getPropertyValue("array[0]"));
assertThat(bean.getArray().length).isEqualTo(1);
assertThat(bean.getArray()).hasSize(1);
assertThat(bean.getArray()[0]).isInstanceOf(Bean.class);
}
@ -76,7 +76,7 @@ public class BeanWrapperAutoGrowingTests {
@Test
public void getPropertyValueAutoGrowArrayBySeveralElements() {
assertNotNull(wrapper.getPropertyValue("array[4]"));
assertThat(bean.getArray().length).isEqualTo(5);
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);
@ -91,7 +91,7 @@ public class BeanWrapperAutoGrowingTests {
@Test
public void getPropertyValueAutoGrow2dArray() {
assertNotNull(wrapper.getPropertyValue("multiArray[0][0]"));
assertThat(bean.getMultiArray()[0].length).isEqualTo(1);
assertThat(bean.getMultiArray()[0]).hasSize(1);
assertThat(bean.getMultiArray()[0][0]).isInstanceOf(Bean.class);
}

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

@ -62,7 +62,7 @@ public class BeanWrapperEnumTests {
GenericBean<?> gb = new GenericBean<>();
BeanWrapper bw = new BeanWrapperImpl(gb);
bw.setPropertyValue("customEnumArray", "VALUE_1");
assertThat(gb.getCustomEnumArray().length).isEqualTo(1);
assertThat(gb.getCustomEnumArray()).hasSize(1);
assertThat(gb.getCustomEnumArray()[0]).isEqualTo(CustomEnum.VALUE_1);
}
@ -71,7 +71,7 @@ public class BeanWrapperEnumTests {
GenericBean<?> gb = new GenericBean<>();
BeanWrapper bw = new BeanWrapperImpl(gb);
bw.setPropertyValue("customEnumArray", new String[] {"VALUE_1", "VALUE_2"});
assertThat(gb.getCustomEnumArray().length).isEqualTo(2);
assertThat(gb.getCustomEnumArray()).hasSize(2);
assertThat(gb.getCustomEnumArray()[0]).isEqualTo(CustomEnum.VALUE_1);
assertThat(gb.getCustomEnumArray()[1]).isEqualTo(CustomEnum.VALUE_2);
}
@ -81,7 +81,7 @@ public class BeanWrapperEnumTests {
GenericBean<?> gb = new GenericBean<>();
BeanWrapper bw = new BeanWrapperImpl(gb);
bw.setPropertyValue("customEnumArray", "VALUE_1,VALUE_2");
assertThat(gb.getCustomEnumArray().length).isEqualTo(2);
assertThat(gb.getCustomEnumArray()).hasSize(2);
assertThat(gb.getCustomEnumArray()[0]).isEqualTo(CustomEnum.VALUE_1);
assertThat(gb.getCustomEnumArray()[1]).isEqualTo(CustomEnum.VALUE_2);
}

10
spring-beans/src/test/java/org/springframework/beans/ExtendedBeanInfoTests.java
View File

@ -200,11 +200,11 @@ class ExtendedBeanInfoTests {
}
{ // always passes
BeanInfo info = Introspector.getBeanInfo(Bean.class);
assertThat(info.getPropertyDescriptors().length).isEqualTo(2);
assertThat(info.getPropertyDescriptors()).hasSize(2);
}
{ // failed prior to fix for SPR-9453
BeanInfo info = new ExtendedBeanInfo(Introspector.getBeanInfo(Bean.class));
assertThat(info.getPropertyDescriptors().length).isEqualTo(2);
assertThat(info.getPropertyDescriptors()).hasSize(2);
}
}
@ -585,7 +585,7 @@ class ExtendedBeanInfoTests {
assertThat(hasReadMethodForProperty(ebi, "foo")).isTrue();
assertThat(hasWriteMethodForProperty(ebi, "foo")).isTrue();
assertThat(ebi.getPropertyDescriptors().length).isEqualTo(bi.getPropertyDescriptors().length);
assertThat(ebi.getPropertyDescriptors()).hasSize(bi.getPropertyDescriptors().length);
}
@Test
@ -711,7 +711,7 @@ class ExtendedBeanInfoTests {
BeanInfo bi = Introspector.getBeanInfo(TestBean.class);
BeanInfo ebi = new ExtendedBeanInfo(bi);
assertThat(ebi.getPropertyDescriptors().length).isEqualTo(bi.getPropertyDescriptors().length);
assertThat(ebi.getPropertyDescriptors()).hasSize(bi.getPropertyDescriptors().length);
}
@Test
@ -731,7 +731,7 @@ class ExtendedBeanInfoTests {
}
}
assertThat(found).isTrue();
assertThat(ebi.getPropertyDescriptors().length).isEqualTo(bi.getPropertyDescriptors().length+1);
assertThat(ebi.getPropertyDescriptors()).hasSize(bi.getPropertyDescriptors().length+1);
}
/**

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

@ -159,7 +159,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
assertThat(bean.getBeanFactory()).isSameAs(bf);
String[] depBeans = bf.getDependenciesForBean("annotatedBean");
assertThat(depBeans.length).isEqualTo(2);
assertThat(depBeans).hasSize(2);
assertThat(depBeans[0]).isEqualTo("testBean");
assertThat(depBeans[1]).isEqualTo("nestedTestBean");
}
@ -266,10 +266,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
assertThat(bean.getTestBean3()).isSameAs(tb);
assertThat(bean.getTestBean4()).isSameAs(tb);
assertThat(bean.getIndexedTestBean()).isSameAs(itb);
assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
assertThat(bean.getNestedTestBeans()).hasSize(2);
assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
assertThat(bean.nestedTestBeansField).hasSize(2);
assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb1);
assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb2);
}
@ -294,10 +294,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
assertThat(bean.getTestBean3()).isSameAs(tb);
assertThat(bean.getTestBean4()).isSameAs(tb);
assertThat(bean.getIndexedTestBean()).isSameAs(itb);
assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
assertThat(bean.getNestedTestBeans()).hasSize(2);
assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
assertThat(bean.nestedTestBeansField).hasSize(2);
assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb1);
assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb2);
@ -309,10 +309,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
assertThat(bean.getTestBean3()).isNull();
assertThat(bean.getTestBean4()).isNull();
assertThat(bean.getIndexedTestBean()).isSameAs(itb);
assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
assertThat(bean.getNestedTestBeans()).hasSize(2);
assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
assertThat(bean.nestedTestBeansField).hasSize(2);
assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb1);
assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb2);
@ -324,10 +324,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
assertThat(bean.getTestBean3()).isSameAs(tb);
assertThat(bean.getTestBean4()).isSameAs(tb);
assertThat(bean.getIndexedTestBean()).isSameAs(itb);
assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
assertThat(bean.getNestedTestBeans()).hasSize(2);
assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
assertThat(bean.nestedTestBeansField).hasSize(2);
assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb1);
assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb2);
}
@ -351,10 +351,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
assertThat(bean.getTestBean3()).isSameAs(bf.getBean("testBean"));
assertThat(bean.getTestBean4()).isSameAs(bf.getBean("testBean"));
assertThat(bean.getIndexedTestBean()).isSameAs(itb);
assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
assertThat(bean.getNestedTestBeans()).hasSize(2);
assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
assertThat(bean.nestedTestBeansField).hasSize(2);
assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb1);
assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb2);
@ -366,10 +366,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
assertThat(bean.getTestBean3()).isNull();
assertThat(bean.getTestBean4()).isNull();
assertThat(bean.getIndexedTestBean()).isSameAs(itb);
assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
assertThat(bean.getNestedTestBeans()).hasSize(2);
assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
assertThat(bean.nestedTestBeansField).hasSize(2);
assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb1);
assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb2);
@ -381,10 +381,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
assertThat(bean.getTestBean3()).isSameAs(bf.getBean("testBean"));
assertThat(bean.getTestBean4()).isSameAs(bf.getBean("testBean"));
assertThat(bean.getIndexedTestBean()).isSameAs(itb);
assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
assertThat(bean.getNestedTestBeans()).hasSize(2);
assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
assertThat(bean.nestedTestBeansField).hasSize(2);
assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb1);
assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb2);
}
@ -496,10 +496,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
assertThat(bean.getTestBean3()).isSameAs(tb);
assertThat(bean.getTestBean4()).isSameAs(tb);
assertThat(bean.getIndexedTestBean()).isSameAs(itb);
assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
assertThat(bean.getNestedTestBeans()).hasSize(2);
assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb2);
assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb1);
assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
assertThat(bean.nestedTestBeansField).hasSize(2);
assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb2);
assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb1);
}
@ -522,10 +522,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
assertThat(bean.getTestBean3()).isSameAs(tb);
assertThat(bean.getTestBean4()).isSameAs(tb);
assertThat(bean.getIndexedTestBean()).isSameAs(itb);
assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
assertThat(bean.getNestedTestBeans()).hasSize(2);
assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb2);
assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb1);
assertThat(bean.nestedTestBeansField.length).isEqualTo(2);
assertThat(bean.nestedTestBeansField).hasSize(2);
assertThat(bean.nestedTestBeansField[0]).isSameAs(ntb2);
assertThat(bean.nestedTestBeansField[1]).isSameAs(ntb1);
}
@ -772,7 +772,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
ConstructorsResourceInjectionBean bean = (ConstructorsResourceInjectionBean) bf.getBean("annotatedBean");
assertThat(bean.getTestBean3()).isNull();
assertThat(bean.getTestBean4()).isSameAs(tb);
assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
assertThat(bean.getNestedTestBeans()).hasSize(2);
assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb1);
assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb2);
}
@ -838,7 +838,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
ConstructorsResourceInjectionBean bean = (ConstructorsResourceInjectionBean) bf.getBean("annotatedBean");
assertThat(bean.getTestBean3()).isNull();
assertThat(bean.getTestBean4()).isSameAs(tb);
assertThat(bean.getNestedTestBeans().length).isEqualTo(2);
assertThat(bean.getNestedTestBeans()).hasSize(2);
assertThat(bean.getNestedTestBeans()[0]).isSameAs(ntb2);
assertThat(bean.getNestedTestBeans()[1]).isSameAs(ntb1);
}

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

@ -401,7 +401,7 @@ public class PropertyResourceConfigurerTests {
assertThat(tb1.getSpouse()).isEqualTo(tb2);
assertThat(tb1.getSomeMap()).hasSize(1);
assertThat(tb1.getSomeMap().get("myKey")).isEqualTo("myValue");
assertThat(tb2.getStringArray().length).isEqualTo(2);
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);
@ -577,7 +577,7 @@ public class PropertyResourceConfigurerTests {
TestBean tb = (TestBean) factory.getBean("tb");
assertThat(tb).isNotNull();
assertThat(factory.getAliases("tb").length).isEqualTo(0);
assertThat(factory.getAliases("tb")).hasSize(0);
}
@Test

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

@ -63,7 +63,7 @@ public class SimpleScopeTests {
beanFactory.registerScope("myScope", scope);
String[] scopeNames = beanFactory.getRegisteredScopeNames();
assertThat(scopeNames.length).isEqualTo(1);
assertThat(scopeNames).hasSize(1);
assertThat(scopeNames[0]).isEqualTo("myScope");
assertThat(beanFactory.getRegisteredScope("myScope")).isSameAs(scope);

8
spring-beans/src/test/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistryTests.java
View File

@ -45,13 +45,13 @@ public class DefaultSingletonBeanRegistryTests {
assertThat(beanRegistry.getSingleton("tb2")).isSameAs(tb2);
assertThat(beanRegistry.getSingletonCount()).isEqualTo(2);
String[] names = beanRegistry.getSingletonNames();
assertThat(names.length).isEqualTo(2);
assertThat(names).hasSize(2);
assertThat(names[0]).isEqualTo("tb");
assertThat(names[1]).isEqualTo("tb2");
beanRegistry.destroySingletons();
assertThat(beanRegistry.getSingletonCount()).isEqualTo(0);
assertThat(beanRegistry.getSingletonNames().length).isEqualTo(0);
assertThat(beanRegistry.getSingletonNames()).hasSize(0);
}
@Test
@ -66,13 +66,13 @@ public class DefaultSingletonBeanRegistryTests {
assertThat(beanRegistry.getSingleton("tb")).isSameAs(tb);
assertThat(beanRegistry.getSingletonCount()).isEqualTo(1);
String[] names = beanRegistry.getSingletonNames();
assertThat(names.length).isEqualTo(1);
assertThat(names).hasSize(1);
assertThat(names[0]).isEqualTo("tb");
assertThat(tb.wasDestroyed()).isFalse();
beanRegistry.destroySingletons();
assertThat(beanRegistry.getSingletonCount()).isEqualTo(0);
assertThat(beanRegistry.getSingletonNames().length).isEqualTo(0);
assertThat(beanRegistry.getSingletonNames()).hasSize(0);
assertThat(tb.wasDestroyed()).isTrue();
}

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

@ -75,23 +75,23 @@ class EventPublicationTests {
void beanEventReceived() throws Exception {
ComponentDefinition componentDefinition1 = this.eventListener.getComponentDefinition("testBean");
assertThat(componentDefinition1).isInstanceOf(BeanComponentDefinition.class);
assertThat(componentDefinition1.getBeanDefinitions().length).isEqualTo(1);
assertThat(componentDefinition1.getBeanDefinitions()).hasSize(1);
BeanDefinition beanDefinition1 = componentDefinition1.getBeanDefinitions()[0];
assertThat(beanDefinition1.getConstructorArgumentValues().getGenericArgumentValue(String.class).getValue()).isEqualTo(new TypedStringValue("Rob Harrop"));
assertThat(componentDefinition1.getBeanReferences().length).isEqualTo(1);
assertThat(componentDefinition1.getBeanReferences()).hasSize(1);
assertThat(componentDefinition1.getBeanReferences()[0].getBeanName()).isEqualTo("testBean2");
assertThat(componentDefinition1.getInnerBeanDefinitions().length).isEqualTo(1);
assertThat(componentDefinition1.getInnerBeanDefinitions()).hasSize(1);
BeanDefinition innerBd1 = componentDefinition1.getInnerBeanDefinitions()[0];
assertThat(innerBd1.getConstructorArgumentValues().getGenericArgumentValue(String.class).getValue()).isEqualTo(new TypedStringValue("ACME"));
assertThat(componentDefinition1.getSource()).isInstanceOf(Element.class);
ComponentDefinition componentDefinition2 = this.eventListener.getComponentDefinition("testBean2");
assertThat(componentDefinition2).isInstanceOf(BeanComponentDefinition.class);
assertThat(componentDefinition1.getBeanDefinitions().length).isEqualTo(1);
assertThat(componentDefinition1.getBeanDefinitions()).hasSize(1);
BeanDefinition beanDefinition2 = componentDefinition2.getBeanDefinitions()[0];
assertThat(beanDefinition2.getPropertyValues().getPropertyValue("name").getValue()).isEqualTo(new TypedStringValue("Juergen Hoeller"));
assertThat(componentDefinition2.getBeanReferences().length).isEqualTo(0);
assertThat(componentDefinition2.getInnerBeanDefinitions().length).isEqualTo(1);
assertThat(componentDefinition2.getBeanReferences()).hasSize(0);
assertThat(componentDefinition2.getInnerBeanDefinitions()).hasSize(1);
BeanDefinition innerBd2 = componentDefinition2.getInnerBeanDefinitions()[0];
assertThat(innerBd2.getPropertyValues().getPropertyValue("name").getValue()).isEqualTo(new TypedStringValue("Eva Schallmeiner"));
assertThat(componentDefinition2.getSource()).isInstanceOf(Element.class);

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

@ -203,7 +203,7 @@ public class UtilNamespaceHandlerTests {
void testNestedShortcutCollections() {
TestBean bean = (TestBean) this.beanFactory.getBean("nestedShortcutCollections");
assertThat(bean.getStringArray().length).isEqualTo(1);
assertThat(bean.getStringArray()).hasSize(1);
assertThat(bean.getStringArray()[0]).isEqualTo("fooStr");
List<?> list = bean.getSomeList();

4
spring-beans/src/test/java/org/springframework/beans/factory/xml/XmlBeanDefinitionReaderTests.java
View File

@ -109,7 +109,7 @@ public class XmlBeanDefinitionReaderTests {
private void testBeanDefinitions(BeanDefinitionRegistry registry) {
assertThat(registry.getBeanDefinitionCount()).isEqualTo(24);
assertThat(registry.getBeanDefinitionNames().length).isEqualTo(24);
assertThat(registry.getBeanDefinitionNames()).hasSize(24);
assertThat(Arrays.asList(registry.getBeanDefinitionNames()).contains("rod")).isTrue();
assertThat(Arrays.asList(registry.getBeanDefinitionNames()).contains("aliased")).isTrue();
assertThat(registry.containsBeanDefinition("rod")).isTrue();
@ -118,7 +118,7 @@ public class XmlBeanDefinitionReaderTests {
assertThat(registry.getBeanDefinition("aliased").getBeanClassName()).isEqualTo(TestBean.class.getName());
assertThat(registry.isAlias("youralias")).isTrue();
String[] aliases = registry.getAliases("aliased");
assertThat(aliases.length).isEqualTo(2);
assertThat(aliases).hasSize(2);
assertThat(ObjectUtils.containsElement(aliases, "myalias")).isTrue();
assertThat(ObjectUtils.containsElement(aliases, "youralias")).isTrue();
}

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

@ -1393,7 +1393,7 @@ class CustomEditorTests {
}
});
bw.setPropertyValue("array", new String[] {"a", "b"});
assertThat(tb.getArray().length).isEqualTo(2);
assertThat(tb.getArray()).hasSize(2);
assertThat(tb.getArray()[0].getName()).isEqualTo("a");
assertThat(tb.getArray()[1].getName()).isEqualTo("b");
}

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

@ -45,7 +45,7 @@ public class CachePutOperationTests extends AbstractCacheOperationTests<CachePut
CachePutOperation operation = createSimpleOperation();
CacheInvocationParameter[] allParameters = operation.getAllParameters(2L, sampleInstance);
assertThat(allParameters.length).isEqualTo(2);
assertThat(allParameters).hasSize(2);
assertCacheInvocationParameter(allParameters[0], Long.class, 2L, 0);
assertCacheInvocationParameter(allParameters[1], SampleObject.class, sampleInstance, 1);

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

@ -42,7 +42,7 @@ public class CacheRemoveAllOperationTests extends AbstractCacheOperationTests<Ca
CacheRemoveAllOperation operation = createSimpleOperation();
CacheInvocationParameter[] allParameters = operation.getAllParameters();
assertThat(allParameters.length).isEqualTo(0);
assertThat(allParameters).hasSize(0);
}
}

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

@ -42,7 +42,7 @@ public class CacheRemoveOperationTests extends AbstractCacheOperationTests<Cache
CacheRemoveOperation operation = createSimpleOperation();
CacheInvocationParameter[] allParameters = operation.getAllParameters(2L);
assertThat(allParameters.length).isEqualTo(1);
assertThat(allParameters).hasSize(1);
assertCacheInvocationParameter(allParameters[0], Long.class, 2L, 0);
}

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

@ -57,11 +57,11 @@ public class CacheResultOperationTests extends AbstractCacheOperationTests<Cache
assertThat(operation.getExceptionCacheResolver()).isEqualTo(defaultExceptionCacheResolver);
CacheInvocationParameter[] allParameters = operation.getAllParameters(2L);
assertThat(allParameters.length).isEqualTo(1);
assertThat(allParameters).hasSize(1);
assertCacheInvocationParameter(allParameters[0], Long.class, 2L, 0);
CacheInvocationParameter[] keyParameters = operation.getKeyParameters(2L);
assertThat(keyParameters.length).isEqualTo(1);
assertThat(keyParameters).hasSize(1);
assertCacheInvocationParameter(keyParameters[0], Long.class, 2L, 0);
}
@ -72,7 +72,7 @@ public class CacheResultOperationTests extends AbstractCacheOperationTests<Cache
CacheResultOperation operation = createDefaultOperation(methodDetails);
CacheInvocationParameter[] keyParameters = operation.getKeyParameters(3L, Boolean.TRUE, "Foo");
assertThat(keyParameters.length).isEqualTo(2);
assertThat(keyParameters).hasSize(2);
assertCacheInvocationParameter(keyParameters[0], Long.class, 3L, 0);
assertCacheInvocationParameter(keyParameters[1], String.class, "Foo", 2);
}

2
spring-context/src/test/java/org/springframework/aop/aspectj/autoproxy/AtAspectJAnnotationBindingTests.java
View File

@ -51,7 +51,7 @@ public class AtAspectJAnnotationBindingTests {
public void testAnnotationBindingInAroundAdvice() {
assertThat(testBean.doThis()).isEqualTo("this value doThis");
assertThat(testBean.doThat()).isEqualTo("that value doThat");
assertThat(testBean.doArray().length).isEqualTo(2);
assertThat(testBean.doArray()).hasSize(2);
}
@Test

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

@ -214,7 +214,7 @@ public abstract class AbstractAopProxyTests {
Advised a1 = (Advised) p;
Advised a2 = (Advised) p2;
// Check we can manipulate state of p2
assertThat(a2.getAdvisors().length).isEqualTo(a1.getAdvisors().length);
assertThat(a2.getAdvisors()).hasSize(a1.getAdvisors().length);
// This should work as SerializablePerson is equal
assertThat(p2).as("Proxies should be equal, even after one was serialized").isEqualTo(p);
@ -748,7 +748,7 @@ public abstract class AbstractAopProxyTests {
.withMessageContaining("frozen");
// Check it still works: proxy factory state shouldn't have been corrupted
assertThat(proxied.getAge()).isEqualTo(target.getAge());
assertThat(((Advised) proxied).getAdvisors().length).isEqualTo(1);
assertThat(((Advised) proxied).getAdvisors()).hasSize(1);
}
/**
@ -771,7 +771,7 @@ public abstract class AbstractAopProxyTests {
.withMessageContaining("frozen");
// Check it still works: proxy factory state shouldn't have been corrupted
assertThat(proxied.getAge()).isEqualTo(target.getAge());
assertThat(advised.getAdvisors().length).isEqualTo(1);
assertThat(advised.getAdvisors()).hasSize(1);
}
@Test
@ -790,13 +790,13 @@ public abstract class AbstractAopProxyTests {
.isThrownBy(() -> advised.removeAdvisor(0))
.withMessageContaining("frozen");
// Didn't get removed
assertThat(advised.getAdvisors().length).isEqualTo(1);
assertThat(advised.getAdvisors()).hasSize(1);
pc.setFrozen(false);
// Can now remove it
advised.removeAdvisor(0);
// Check it still works: proxy factory state shouldn't have been corrupted
assertThat(proxied.getAge()).isEqualTo(target.getAge());
assertThat(advised.getAdvisors().length).isEqualTo(0);
assertThat(advised.getAdvisors()).hasSize(0);
}
@Test
@ -1173,7 +1173,7 @@ public abstract class AbstractAopProxyTests {
IOther proxyA = (IOther) createProxy(pfa);
IOther proxyB = (IOther) createProxy(pfb);
assertThat(pfb.getAdvisors().length).isEqualTo(pfa.getAdvisors().length);
assertThat(pfb.getAdvisors()).hasSize(pfa.getAdvisors().length);
assertThat(b).isEqualTo(a);
assertThat(i2).isEqualTo(i1);
assertThat(proxyB).isEqualTo(proxyA);

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

@ -190,7 +190,7 @@ class XmlBeanFactoryTests {
assertThat(hasInnerBeans.getFriends()).isNotNull();
Object[] friends = hasInnerBeans.getFriends().toArray();
assertThat(friends.length).isEqualTo(3);
assertThat(friends).hasSize(3);
DerivedTestBean inner2 = (DerivedTestBean) friends[0];
assertThat(inner2.getName()).isEqualTo("inner2");
assertThat(inner2.getBeanName().startsWith(DerivedTestBean.class.getName())).isTrue();
@ -261,7 +261,7 @@ class XmlBeanFactoryTests {
assertThat(hasInnerBeans.getFriends()).isNotNull();
Object[] friends = hasInnerBeans.getFriends().toArray();
assertThat(friends.length).isEqualTo(3);
assertThat(friends).hasSize(3);
DerivedTestBean inner2 = (DerivedTestBean) friends[0];
assertThat(inner2.getName()).isEqualTo("inner2");
assertThat(inner2.getBeanName().startsWith(DerivedTestBean.class.getName())).isTrue();
@ -1510,7 +1510,7 @@ class XmlBeanFactoryTests {
new XmlBeanDefinitionReader(xbf).loadBeanDefinitions(CONSTRUCTOR_ARG_CONTEXT);
ConstructorArrayTestBean bean = (ConstructorArrayTestBean) xbf.getBean("constructorArray");
assertThat(bean.array instanceof int[]).isTrue();
assertThat(((int[]) bean.array).length).isEqualTo(1);
assertThat(((int[]) bean.array)).hasSize(1);
assertThat(((int[]) bean.array)[0]).isEqualTo(1);
}
@ -1520,7 +1520,7 @@ class XmlBeanFactoryTests {
new XmlBeanDefinitionReader(xbf).loadBeanDefinitions(CONSTRUCTOR_ARG_CONTEXT);
ConstructorArrayTestBean bean = (ConstructorArrayTestBean) xbf.getBean("indexedConstructorArray");
assertThat(bean.array instanceof int[]).isTrue();
assertThat(((int[]) bean.array).length).isEqualTo(1);
assertThat(((int[]) bean.array)).hasSize(1);
assertThat(((int[]) bean.array)[0]).isEqualTo(1);
}
@ -1530,7 +1530,7 @@ class XmlBeanFactoryTests {
new XmlBeanDefinitionReader(xbf).loadBeanDefinitions(CONSTRUCTOR_ARG_CONTEXT);
ConstructorArrayTestBean bean = (ConstructorArrayTestBean) xbf.getBean("constructorArrayNoType");
assertThat(bean.array instanceof String[]).isTrue();
assertThat(((String[]) bean.array).length).isEqualTo(0);
assertThat(((String[]) bean.array)).hasSize(0);
}
@Test
@ -1541,7 +1541,7 @@ class XmlBeanFactoryTests {
bd.setLenientConstructorResolution(false);
ConstructorArrayTestBean bean = (ConstructorArrayTestBean) xbf.getBean("constructorArrayNoType");
assertThat(bean.array instanceof String[]).isTrue();
assertThat(((String[]) bean.array).length).isEqualTo(0);
assertThat(((String[]) bean.array)).hasSize(0);
}
@Test
@ -1596,7 +1596,7 @@ class XmlBeanFactoryTests {
@Override
public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
assertThat(args.length).isEqualTo(1);
assertThat(args).hasSize(1);
assertThat(method.getName()).isEqualTo("doSomething");
lastArg = args[0];
return null;

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

@ -473,7 +473,7 @@ public class ClassPathBeanDefinitionScannerTests {
assertThat(fooService.eventPublisher).isSameAs(context);
assertThat(fooService.messageSource).isSameAs(ms);
assertThat(fooService.context).isSameAs(context);
assertThat(fooService.configurableContext.length).isEqualTo(1);
assertThat(fooService.configurableContext).hasSize(1);
assertThat(fooService.configurableContext[0]).isSameAs(context);
assertThat(fooService.genericContext).isSameAs(context);
}

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

@ -232,7 +232,7 @@ public class CommonAnnotationBeanPostProcessorTests {
assertThat(tb).isNotSameAs(anotherBean.getTestBean6());
String[] depBeans = bf.getDependenciesForBean("annotatedBean");
assertThat(depBeans.length).isEqualTo(1);
assertThat(depBeans).hasSize(1);
assertThat(depBeans[0]).isEqualTo("testBean4");
}

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

@ -647,11 +647,11 @@ class ConfigurationClassPostProcessorTests {
assertThat(beanNames).contains("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
}
@ -665,11 +665,11 @@ class ConfigurationClassPostProcessorTests {
assertThat(beanNames).contains("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
}
@ -682,10 +682,10 @@ class ConfigurationClassPostProcessorTests {
assertThat(beanNames).contains("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(0);
assertThat(beanNames).hasSize(0);
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(0);
assertThat(beanNames).hasSize(0);
}
@Test
@ -698,11 +698,11 @@ class ConfigurationClassPostProcessorTests {
assertThat(beanNames).contains("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
}
@ -715,11 +715,11 @@ class ConfigurationClassPostProcessorTests {
assertThat(beanNames).contains("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
}
@ -733,11 +733,11 @@ class ConfigurationClassPostProcessorTests {
assertThat(beanNames).contains("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
}
@ -755,11 +755,11 @@ class ConfigurationClassPostProcessorTests {
assertThat(beanNames).contains("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
assertThat(AopUtils.isCglibProxy(beanFactory.getBean("stringRepo"))).isTrue();
@ -780,11 +780,11 @@ class ConfigurationClassPostProcessorTests {
assertThat(beanNames).contains("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
assertThat(AopUtils.isCglibProxy(beanFactory.getBean("stringRepo"))).isTrue();
@ -805,11 +805,11 @@ class ConfigurationClassPostProcessorTests {
assertThat(beanNames).contains("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
assertThat(AopUtils.isCglibProxy(beanFactory.getBean("stringRepo"))).isTrue();
@ -830,11 +830,11 @@ class ConfigurationClassPostProcessorTests {
assertThat(beanNames).contains("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(Repository.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
assertThat(AopUtils.isCglibProxy(beanFactory.getBean("stringRepo"))).isTrue();
@ -853,11 +853,11 @@ class ConfigurationClassPostProcessorTests {
assertThat(beanNames).contains("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
assertThat(AopUtils.isJdkDynamicProxy(beanFactory.getBean("stringRepo"))).isTrue();
@ -877,11 +877,11 @@ class ConfigurationClassPostProcessorTests {
assertThat(beanNames).contains("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
assertThat(AopUtils.isJdkDynamicProxy(beanFactory.getBean("stringRepo"))).isTrue();
@ -901,11 +901,11 @@ class ConfigurationClassPostProcessorTests {
assertThat(beanNames).contains("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
assertThat(AopUtils.isJdkDynamicProxy(beanFactory.getBean("stringRepo"))).isTrue();
@ -925,11 +925,11 @@ class ConfigurationClassPostProcessorTests {
assertThat(beanNames).contains("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
beanNames = beanFactory.getBeanNamesForType(ResolvableType.forClassWithGenerics(RepositoryInterface.class, String.class));
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("stringRepo");
assertThat(AopUtils.isJdkDynamicProxy(beanFactory.getBean("stringRepo"))).isTrue();
@ -1030,7 +1030,7 @@ class ConfigurationClassPostProcessorTests {
ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(VarargConfiguration.class, TestBean.class);
VarargConfiguration bean = ctx.getBean(VarargConfiguration.class);
assertThat(bean.testBeans).isNotNull();
assertThat(bean.testBeans.length).isEqualTo(1);
assertThat(bean.testBeans).hasSize(1);
assertThat(bean.testBeans[0]).isSameAs(ctx.getBean(TestBean.class));
ctx.close();
}
@ -1040,7 +1040,7 @@ class ConfigurationClassPostProcessorTests {
ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(VarargConfiguration.class);
VarargConfiguration bean = ctx.getBean(VarargConfiguration.class);
assertThat(bean.testBeans).isNotNull();
assertThat(bean.testBeans.length).isEqualTo(0);
assertThat(bean.testBeans).hasSize(0);
ctx.close();
}

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

@ -172,15 +172,15 @@ class ConfigurationClassProcessingTests {
assertThat(condition).isTrue();
String[] beanNames = factory.getBeanNamesForType(FactoryBean.class);
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("&factoryBean");
beanNames = factory.getBeanNamesForType(BeanClassLoaderAware.class);
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("&factoryBean");
beanNames = factory.getBeanNamesForType(ListFactoryBean.class);
assertThat(beanNames.length).isEqualTo(1);
assertThat(beanNames).hasSize(1);
assertThat(beanNames[0]).isEqualTo("&factoryBean");
beanNames = factory.getBeanNamesForType(List.class);

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

@ -261,11 +261,11 @@ public class ClassPathXmlApplicationContextTests {
assertThat(myMs).isSameAs(someMs);
String[] aliases = child.getAliases("someMessageSource");
assertThat(aliases.length).isEqualTo(2);
assertThat(aliases).hasSize(2);
assertThat(aliases[0]).isEqualTo("myMessageSource");
assertThat(aliases[1]).isEqualTo("yourMessageSource");
aliases = child.getAliases("myMessageSource");
assertThat(aliases.length).isEqualTo(2);
assertThat(aliases).hasSize(2);
assertThat(aliases[0]).isEqualTo("someMessageSource");
assertThat(aliases[1]).isEqualTo("yourMessageSource");
@ -299,16 +299,16 @@ public class ClassPathXmlApplicationContextTests {
private void assertOneMessageSourceOnly(ClassPathXmlApplicationContext ctx, Object myMessageSource) {
String[] beanNamesForType = ctx.getBeanNamesForType(StaticMessageSource.class);
assertThat(beanNamesForType.length).isEqualTo(1);
assertThat(beanNamesForType).hasSize(1);
assertThat(beanNamesForType[0]).isEqualTo("myMessageSource");
beanNamesForType = ctx.getBeanNamesForType(StaticMessageSource.class, true, true);
assertThat(beanNamesForType.length).isEqualTo(1);
assertThat(beanNamesForType).hasSize(1);
assertThat(beanNamesForType[0]).isEqualTo("myMessageSource");
beanNamesForType = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(ctx, StaticMessageSource.class);
assertThat(beanNamesForType.length).isEqualTo(1);
assertThat(beanNamesForType).hasSize(1);
assertThat(beanNamesForType[0]).isEqualTo("myMessageSource");
beanNamesForType = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(ctx, StaticMessageSource.class, true, true);
assertThat(beanNamesForType.length).isEqualTo(1);
assertThat(beanNamesForType).hasSize(1);
assertThat(beanNamesForType[0]).isEqualTo("myMessageSource");
Map<?, StaticMessageSource> beansOfType = ctx.getBeansOfType(StaticMessageSource.class);

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

@ -108,7 +108,7 @@ public class ModelMapTests {
assertThat(model).hasSize(1);
String[] strings = (String[]) model.get("stringList");
assertThat(strings).isNotNull();
assertThat(strings.length).isEqualTo(2);
assertThat(strings).hasSize(2);
assertThat(strings[0]).isEqualTo("foo");
assertThat(strings[1]).isEqualTo("boing");
}
@ -134,7 +134,7 @@ public class ModelMapTests {
assertThat(model).hasSize(1);
int[] ints = (int[]) model.get("intList");
assertThat(ints).isNotNull();
assertThat(ints.length).isEqualTo(0);
assertThat(ints).hasSize(0);
}
@Test

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

@ -1724,7 +1724,7 @@ class DataBinderTests {
pvs.add("stringArray", new String[] {"a1", "b2"});
binder.bind(pvs);
assertThat(binder.getBindingResult().hasErrors()).isFalse();
assertThat(tb.getStringArray().length).isEqualTo(2);
assertThat(tb.getStringArray()).hasSize(2);
assertThat(tb.getStringArray()[0]).isEqualTo("Xa1");
assertThat(tb.getStringArray()[1]).isEqualTo("Xb2");
}

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

@ -168,7 +168,7 @@ class GenericTypeResolverTests {
void resolveIncompleteTypeVariables() {
Class<?>[] resolved = GenericTypeResolver.resolveTypeArguments(IdFixingRepository.class, Repository.class);
assertThat(resolved).isNotNull();
assertThat(resolved.length).isEqualTo(2);
assertThat(resolved).hasSize(2);
assertThat(resolved[0]).isEqualTo(Object.class);
assertThat(resolved[1]).isEqualTo(Long.class);
}

14
spring-core/src/test/java/org/springframework/core/LocalVariableTableParameterNameDiscovererTests.java
View File

@ -162,23 +162,23 @@ class LocalVariableTableParameterNameDiscovererTests {
Constructor<?> ctor = clazz.getDeclaredConstructor(Object.class);
String[] names = discoverer.getParameterNames(ctor);
assertThat(names.length).isEqualTo(1);
assertThat(names).hasSize(1);
assertThat(names[0]).isEqualTo("key");
ctor = clazz.getDeclaredConstructor(Object.class, Object.class);
names = discoverer.getParameterNames(ctor);
assertThat(names.length).isEqualTo(2);
assertThat(names).hasSize(2);
assertThat(names[0]).isEqualTo("key");
assertThat(names[1]).isEqualTo("value");
Method m = clazz.getMethod("generifiedStaticMethod", Object.class);
names = discoverer.getParameterNames(m);
assertThat(names.length).isEqualTo(1);
assertThat(names).hasSize(1);
assertThat(names[0]).isEqualTo("param");
m = clazz.getMethod("generifiedMethod", Object.class, long.class, Object.class, Object.class);
names = discoverer.getParameterNames(m);
assertThat(names.length).isEqualTo(4);
assertThat(names).hasSize(4);
assertThat(names[0]).isEqualTo("param");
assertThat(names[1]).isEqualTo("x");
assertThat(names[2]).isEqualTo("key");
@ -186,21 +186,21 @@ class LocalVariableTableParameterNameDiscovererTests {
m = clazz.getMethod("voidStaticMethod", Object.class, long.class, int.class);
names = discoverer.getParameterNames(m);
assertThat(names.length).isEqualTo(3);
assertThat(names).hasSize(3);
assertThat(names[0]).isEqualTo("obj");
assertThat(names[1]).isEqualTo("x");
assertThat(names[2]).isEqualTo("i");
m = clazz.getMethod("nonVoidStaticMethod", Object.class, long.class, int.class);
names = discoverer.getParameterNames(m);
assertThat(names.length).isEqualTo(3);
assertThat(names).hasSize(3);
assertThat(names[0]).isEqualTo("obj");
assertThat(names[1]).isEqualTo("x");
assertThat(names[2]).isEqualTo("i");
m = clazz.getMethod("getDate");
names = discoverer.getParameterNames(m);
assertThat(names.length).isEqualTo(0);
assertThat(names).hasSize(0);
}
@Disabled("Ignored because Ubuntu packages OpenJDK with debug symbols enabled. See SPR-8078.")

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

@ -535,7 +535,7 @@ class ResolvableTypeTests {
void getGenericsFromParameterizedType() throws Exception {
ResolvableType type = ResolvableType.forClass(List.class, ExtendsList.class);
ResolvableType[] generics = type.getGenerics();
assertThat(generics.length).isEqualTo(1);
assertThat(generics).hasSize(1);
assertThat(generics[0].resolve()).isEqualTo(CharSequence.class);
}
@ -543,7 +543,7 @@ class ResolvableTypeTests {
void getGenericsFromClass() throws Exception {
ResolvableType type = ResolvableType.forClass(List.class);
ResolvableType[] generics = type.getGenerics();
assertThat(generics.length).isEqualTo(1);
assertThat(generics).hasSize(1);
assertThat(generics[0].getType().toString()).isEqualTo("E");
}
@ -558,7 +558,7 @@ class ResolvableTypeTests {
void getResolvedGenerics() throws Exception {
ResolvableType type = ResolvableType.forClass(List.class, ExtendsList.class);
Class<?>[] generics = type.resolveGenerics();
assertThat(generics.length).isEqualTo(1);
assertThat(generics).hasSize(1);
assertThat(generics[0]).isEqualTo(CharSequence.class);
}
@ -1307,7 +1307,7 @@ class ResolvableTypeTests {
Type type = resolvableType.getType();
assertThat(type).isInstanceOf(ParameterizedType.class);
assertThat(((ParameterizedType) type).getRawType()).isEqualTo(Callable.class);
assertThat(((ParameterizedType) type).getActualTypeArguments().length).isEqualTo(1);
assertThat(((ParameterizedType) type).getActualTypeArguments()).hasSize(1);
assertThat(((ParameterizedType) type).getActualTypeArguments()[0]).isEqualTo(String.class);
}

6
spring-core/src/test/java/org/springframework/core/annotation/AnnotationAttributesTests.java
View File

@ -108,12 +108,12 @@ class AnnotationAttributesTests {
AnnotationAttributes[] array = attributes.getAnnotationArray("nestedAttributes");
assertThat(array).isNotNull();
assertThat(array.length).isEqualTo(1);
assertThat(array).hasSize(1);
assertThat(array[0].getString("name")).isEqualTo("Dilbert");
Filter[] filters = attributes.getAnnotationArray("filters", Filter.class);
assertThat(filters).isNotNull();
assertThat(filters.length).isEqualTo(1);
assertThat(filters).hasSize(1);
assertThat(filters[0].pattern()).isEqualTo("foo");
}
@ -130,7 +130,7 @@ class AnnotationAttributesTests {
Filter[] retrievedFilters = attributes.getAnnotationArray("filters", Filter.class);
assertThat(retrievedFilters).isNotNull();
assertThat(retrievedFilters.length).isEqualTo(2);
assertThat(retrievedFilters).hasSize(2);
assertThat(retrievedFilters[1].pattern()).isEqualTo("foo");
}

6
spring-core/src/test/java/org/springframework/core/annotation/AnnotationUtilsTests.java
View File

@ -507,7 +507,7 @@ class AnnotationUtilsTests {
@Test
void getValueFromNonPublicAnnotation() throws Exception {
Annotation[] declaredAnnotations = NonPublicAnnotatedClass.class.getDeclaredAnnotations();
assertThat(declaredAnnotations.length).isEqualTo(1);
assertThat(declaredAnnotations).hasSize(1);
Annotation annotation = declaredAnnotations[0];
assertThat(annotation).isNotNull();
assertThat(annotation.annotationType().getSimpleName()).isEqualTo("NonPublicAnnotation");
@ -527,7 +527,7 @@ class AnnotationUtilsTests {
@Test
void getDefaultValueFromNonPublicAnnotation() {
Annotation[] declaredAnnotations = NonPublicAnnotatedClass.class.getDeclaredAnnotations();
assertThat(declaredAnnotations.length).isEqualTo(1);
assertThat(declaredAnnotations).hasSize(1);
Annotation annotation = declaredAnnotations[0];
assertThat(annotation).isNotNull();
assertThat(annotation.annotationType().getSimpleName()).isEqualTo("NonPublicAnnotation");
@ -706,7 +706,7 @@ class AnnotationUtilsTests {
// Java 8
MyRepeatable[] array = clazz.getDeclaredAnnotationsByType(MyRepeatable.class);
assertThat(array).isNotNull();
assertThat(array.length).isEqualTo(0);
assertThat(array).hasSize(0);
// Spring
Set<MyRepeatable> set = getDeclaredRepeatableAnnotations(clazz, MyRepeatable.class, MyRepeatableContainer.class);

24
spring-core/src/test/java/org/springframework/core/convert/TypeDescriptorTests.java
View File

@ -65,7 +65,7 @@ class TypeDescriptorTests {
assertThat(desc.getName()).isEqualTo("int");
assertThat(desc.toString()).isEqualTo("int");
assertThat(desc.isPrimitive()).isTrue();
assertThat(desc.getAnnotations().length).isEqualTo(0);
assertThat(desc.getAnnotations()).hasSize(0);
assertThat(desc.isCollection()).isFalse();
assertThat(desc.isMap()).isFalse();
}
@ -78,7 +78,7 @@ class TypeDescriptorTests {
assertThat(desc.getName()).isEqualTo("java.lang.String");
assertThat(desc.toString()).isEqualTo("java.lang.String");
assertThat(!desc.isPrimitive()).isTrue();
assertThat(desc.getAnnotations().length).isEqualTo(0);
assertThat(desc.getAnnotations()).hasSize(0);
assertThat(desc.isCollection()).isFalse();
assertThat(desc.isArray()).isFalse();
assertThat(desc.isMap()).isFalse();
@ -93,7 +93,7 @@ class TypeDescriptorTests {
assertThat(desc.getName()).isEqualTo("java.util.List");
assertThat(desc.toString()).isEqualTo("java.util.List<java.util.List<java.util.Map<java.lang.Integer, java.lang.Enum<?>>>>");
assertThat(!desc.isPrimitive()).isTrue();
assertThat(desc.getAnnotations().length).isEqualTo(0);
assertThat(desc.getAnnotations()).hasSize(0);
assertThat(desc.isCollection()).isTrue();
assertThat(desc.isArray()).isFalse();
assertThat(desc.getElementTypeDescriptor().getType()).isEqualTo(List.class);
@ -114,7 +114,7 @@ class TypeDescriptorTests {
assertThat(desc.getName()).isEqualTo("java.util.List");
assertThat(desc.toString()).isEqualTo("java.util.List<?>");
assertThat(!desc.isPrimitive()).isTrue();
assertThat(desc.getAnnotations().length).isEqualTo(0);
assertThat(desc.getAnnotations()).hasSize(0);
assertThat(desc.isCollection()).isTrue();
assertThat(desc.isArray()).isFalse();
assertThat((Object) desc.getElementTypeDescriptor()).isNull();
@ -130,7 +130,7 @@ class TypeDescriptorTests {
assertThat(desc.getName()).isEqualTo("java.lang.Integer[]");
assertThat(desc.toString()).isEqualTo("java.lang.Integer[]");
assertThat(!desc.isPrimitive()).isTrue();
assertThat(desc.getAnnotations().length).isEqualTo(0);
assertThat(desc.getAnnotations()).hasSize(0);
assertThat(desc.isCollection()).isFalse();
assertThat(desc.isArray()).isTrue();
assertThat(desc.getElementTypeDescriptor().getType()).isEqualTo(Integer.class);
@ -147,7 +147,7 @@ class TypeDescriptorTests {
assertThat(desc.getName()).isEqualTo("java.util.Map");
assertThat(desc.toString()).isEqualTo("java.util.Map<java.lang.Integer, java.util.List<java.lang.String>>");
assertThat(!desc.isPrimitive()).isTrue();
assertThat(desc.getAnnotations().length).isEqualTo(0);
assertThat(desc.getAnnotations()).hasSize(0);
assertThat(desc.isCollection()).isFalse();
assertThat(desc.isArray()).isFalse();
assertThat(desc.isMap()).isTrue();
@ -162,7 +162,7 @@ class TypeDescriptorTests {
void parameterAnnotated() throws Exception {
TypeDescriptor t1 = new TypeDescriptor(new MethodParameter(getClass().getMethod("testAnnotatedMethod", String.class), 0));
assertThat(t1.getType()).isEqualTo(String.class);
assertThat(t1.getAnnotations().length).isEqualTo(1);
assertThat(t1.getAnnotations()).hasSize(1);
assertThat(t1.getAnnotation(ParameterAnnotation.class)).isNotNull();
assertThat(t1.hasAnnotation(ParameterAnnotation.class)).isTrue();
assertThat(t1.getAnnotation(ParameterAnnotation.class).value()).isEqualTo(123);
@ -335,7 +335,7 @@ class TypeDescriptorTests {
@Test
void fieldAnnotated() throws Exception {
TypeDescriptor typeDescriptor = new TypeDescriptor(getClass().getField("fieldAnnotated"));
assertThat(typeDescriptor.getAnnotations().length).isEqualTo(1);
assertThat(typeDescriptor.getAnnotations()).hasSize(1);
assertThat(typeDescriptor.getAnnotation(FieldAnnotation.class)).isNotNull();
}
@ -463,7 +463,7 @@ class TypeDescriptorTests {
assertThat(desc.getName()).isEqualTo("java.util.List");
assertThat(desc.toString()).isEqualTo("java.util.List<java.lang.Integer>");
assertThat(!desc.isPrimitive()).isTrue();
assertThat(desc.getAnnotations().length).isEqualTo(0);
assertThat(desc.getAnnotations()).hasSize(0);
assertThat(desc.isCollection()).isTrue();
assertThat(desc.isArray()).isFalse();
assertThat(desc.getElementTypeDescriptor().getType()).isEqualTo(Integer.class);
@ -479,7 +479,7 @@ class TypeDescriptorTests {
assertThat(desc.getName()).isEqualTo("java.util.List");
assertThat(desc.toString()).isEqualTo("java.util.List<java.util.List<java.lang.Integer>>");
assertThat(!desc.isPrimitive()).isTrue();
assertThat(desc.getAnnotations().length).isEqualTo(0);
assertThat(desc.getAnnotations()).hasSize(0);
assertThat(desc.isCollection()).isTrue();
assertThat(desc.isArray()).isFalse();
assertThat(desc.getElementTypeDescriptor().getType()).isEqualTo(List.class);
@ -495,7 +495,7 @@ class TypeDescriptorTests {
assertThat(desc.getName()).isEqualTo("java.util.Map");
assertThat(desc.toString()).isEqualTo("java.util.Map<java.lang.String, java.lang.Integer>");
assertThat(!desc.isPrimitive()).isTrue();
assertThat(desc.getAnnotations().length).isEqualTo(0);
assertThat(desc.getAnnotations()).hasSize(0);
assertThat(desc.isCollection()).isFalse();
assertThat(desc.isArray()).isFalse();
assertThat(desc.isMap()).isTrue();
@ -512,7 +512,7 @@ class TypeDescriptorTests {
assertThat(desc.getName()).isEqualTo("java.util.Map");
assertThat(desc.toString()).isEqualTo("java.util.Map<java.lang.String, java.util.Map<java.lang.String, java.lang.Integer>>");
assertThat(!desc.isPrimitive()).isTrue();
assertThat(desc.getAnnotations().length).isEqualTo(0);
assertThat(desc.getAnnotations()).hasSize(0);
assertThat(desc.isCollection()).isFalse();
assertThat(desc.isArray()).isFalse();
assertThat(desc.isMap()).isTrue();

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

@ -452,7 +452,7 @@ class DefaultConversionServiceTests {
@Test
void convertObjectToArray() {
Object[] result = conversionService.convert(3L, Object[].class);
assertThat(result.length).isEqualTo(1);
assertThat(result).hasSize(1);
assertThat(result[0]).isEqualTo(3L);
}

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

@ -335,7 +335,7 @@ class GenericConversionServiceTests {
TypeDescriptor sourceType = TypeDescriptor.forObject(list);
TypeDescriptor targetType = TypeDescriptor.valueOf(String[].class);
assertThat(conversionService.canConvert(sourceType, targetType)).isTrue();
assertThat(((String[]) conversionService.convert(list, sourceType, targetType)).length).isEqualTo(0);
assertThat(((String[]) conversionService.convert(list, sourceType, targetType))).hasSize(0);
}
@Test

22
spring-core/src/test/java/org/springframework/core/env/StandardEnvironmentTests.java vendored
View File

@ -113,12 +113,12 @@ public class StandardEnvironmentTests {
@Test
void activeProfilesIsEmptyByDefault() {
assertThat(environment.getActiveProfiles().length).isEqualTo(0);
assertThat(environment.getActiveProfiles()).hasSize(0);
}
@Test
void defaultProfilesContainsDefaultProfileByDefault() {
assertThat(environment.getDefaultProfiles().length).isEqualTo(1);
assertThat(environment.getDefaultProfiles()).hasSize(1);
assertThat(environment.getDefaultProfiles()[0]).isEqualTo("default");
}
@ -127,7 +127,7 @@ public class StandardEnvironmentTests {
environment.setActiveProfiles("local", "embedded");
String[] activeProfiles = environment.getActiveProfiles();
assertThat(activeProfiles).contains("local", "embedded");
assertThat(activeProfiles.length).isEqualTo(2);
assertThat(activeProfiles).hasSize(2);
}
@Test
@ -172,17 +172,17 @@ public class StandardEnvironmentTests {
@Test
void addActiveProfile() {
assertThat(environment.getActiveProfiles().length).isEqualTo(0);
assertThat(environment.getActiveProfiles()).hasSize(0);
environment.setActiveProfiles("local", "embedded");
assertThat(environment.getActiveProfiles()).contains("local", "embedded");
assertThat(environment.getActiveProfiles().length).isEqualTo(2);
assertThat(environment.getActiveProfiles()).hasSize(2);
environment.addActiveProfile("p1");
assertThat(environment.getActiveProfiles()).contains("p1");
assertThat(environment.getActiveProfiles().length).isEqualTo(3);
assertThat(environment.getActiveProfiles()).hasSize(3);
environment.addActiveProfile("p2");
environment.addActiveProfile("p3");
assertThat(environment.getActiveProfiles()).contains("p2", "p3");
assertThat(environment.getActiveProfiles().length).isEqualTo(5);
assertThat(environment.getActiveProfiles()).hasSize(5);
}
@Test
@ -218,9 +218,9 @@ public class StandardEnvironmentTests {
@Test
void getActiveProfiles_systemPropertiesEmpty() {
assertThat(environment.getActiveProfiles().length).isEqualTo(0);
assertThat(environment.getActiveProfiles()).hasSize(0);
System.setProperty(ACTIVE_PROFILES_PROPERTY_NAME, "");
assertThat(environment.getActiveProfiles().length).isEqualTo(0);
assertThat(environment.getActiveProfiles()).hasSize(0);
System.clearProperty(ACTIVE_PROFILES_PROPERTY_NAME);
}
@ -249,14 +249,14 @@ public class StandardEnvironmentTests {
void getDefaultProfiles() {
assertThat(environment.getDefaultProfiles()).isEqualTo(new String[] {RESERVED_DEFAULT_PROFILE_NAME});
environment.getPropertySources().addFirst(new MockPropertySource().withProperty(DEFAULT_PROFILES_PROPERTY_NAME, "pd1"));
assertThat(environment.getDefaultProfiles().length).isEqualTo(1);
assertThat(environment.getDefaultProfiles()).hasSize(1);
assertThat(Arrays.asList(environment.getDefaultProfiles())).contains("pd1");
}
@Test
void setDefaultProfiles() {
environment.setDefaultProfiles();
assertThat(environment.getDefaultProfiles().length).isEqualTo(0);
assertThat(environment.getDefaultProfiles()).hasSize(0);
environment.setDefaultProfiles("pd1");
assertThat(Arrays.asList(environment.getDefaultProfiles())).contains("pd1");
environment.setDefaultProfiles("pd2", "pd3");

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

@ -90,7 +90,7 @@ class AnnotationMetadataTests {
assertThat(metadata.isConcrete()).isTrue();
assertThat(metadata.hasSuperClass()).isTrue();
assertThat(metadata.getSuperClassName()).isEqualTo(AnnotatedComponent.class.getName());
assertThat(metadata.getInterfaceNames().length).isEqualTo(0);
assertThat(metadata.getInterfaceNames()).hasSize(0);
assertThat(metadata.isAnnotated(Component.class.getName())).isFalse();
assertThat(metadata.isAnnotated(Scope.class.getName())).isFalse();
assertThat(metadata.isAnnotated(SpecialAttr.class.getName())).isFalse();
@ -141,7 +141,7 @@ class AnnotationMetadataTests {
assertThat(metadata.isConcrete()).isFalse();
assertThat(metadata.hasSuperClass()).isFalse();
assertThat(metadata.getSuperClassName()).isNull();
assertThat(metadata.getInterfaceNames().length).isEqualTo(2);
assertThat(metadata.getInterfaceNames()).hasSize(2);
assertThat(metadata.getInterfaceNames()[0]).isEqualTo(ClassMetadata.class.getName());
assertThat(metadata.getInterfaceNames()[1]).isEqualTo(AnnotatedTypeMetadata.class.getName());
assertThat(metadata.getAnnotationTypes()).hasSize(0);
@ -169,7 +169,7 @@ class AnnotationMetadataTests {
assertThat(metadata.isConcrete()).isFalse();
assertThat(metadata.hasSuperClass()).isFalse();
assertThat(metadata.getSuperClassName()).isNull();
assertThat(metadata.getInterfaceNames().length).isEqualTo(1);
assertThat(metadata.getInterfaceNames()).hasSize(1);
assertThat(metadata.getInterfaceNames()[0]).isEqualTo(Annotation.class.getName());
assertThat(metadata.isAnnotated(Documented.class.getName())).isFalse();
assertThat(metadata.isAnnotated(Scope.class.getName())).isFalse();
@ -287,7 +287,7 @@ class AnnotationMetadataTests {
assertThat(metadata.isConcrete()).isTrue();
assertThat(metadata.hasSuperClass()).isTrue();
assertThat(metadata.getSuperClassName()).isEqualTo(Object.class.getName());
assertThat(metadata.getInterfaceNames().length).isEqualTo(1);
assertThat(metadata.getInterfaceNames()).hasSize(1);
assertThat(metadata.getInterfaceNames()[0]).isEqualTo(Serializable.class.getName());
assertThat(metadata.isAnnotated(Component.class.getName())).isTrue();
@ -335,7 +335,7 @@ class AnnotationMetadataTests {
assertThat((Class<?>[]) nestedAnno.get("classArray")).isEqualTo(new Class<?>[] {String.class});
AnnotationAttributes[] nestedAnnoArray = specialAttrs.getAnnotationArray("nestedAnnoArray");
assertThat(nestedAnnoArray.length).isEqualTo(2);
assertThat(nestedAnnoArray).hasSize(2);
assertThat(nestedAnnoArray[0].getString("value")).isEqualTo("default");
assertThat(nestedAnnoArray[0].getEnum("anEnum").equals(SomeEnum.DEFAULT)).isTrue();
assertThat((Class<?>[]) nestedAnnoArray[0].get("classArray")).isEqualTo(new Class<?>[] {Void.class});
@ -351,7 +351,7 @@ class AnnotationMetadataTests {
assertThat(optional.getClassArray("classArray")).isEqualTo(new Class<?>[] {Void.class});
AnnotationAttributes[] optionalArray = specialAttrs.getAnnotationArray("optionalArray");
assertThat(optionalArray.length).isEqualTo(1);
assertThat(optionalArray).hasSize(1);
assertThat(optionalArray[0].getString("value")).isEqualTo("optional");
assertThat(optionalArray[0].getEnum("anEnum").equals(SomeEnum.DEFAULT)).isTrue();
assertThat((Class<?>[]) optionalArray[0].get("classArray")).isEqualTo(new Class<?>[] {Void.class});
@ -363,7 +363,7 @@ class AnnotationMetadataTests {
allMeta = metadata.getAllAnnotationAttributes(DirectAnnotation.class.getName()).get("additional");
assertThat(new HashSet<>(allMeta)).isEqualTo(new HashSet<Object>(Arrays.asList("direct", "")));
assertThat(metadata.getAnnotationAttributes(DirectAnnotation.class.getName()).get("additional")).isEqualTo("");
assertThat(((String[]) metadata.getAnnotationAttributes(DirectAnnotation.class.getName()).get("additionalArray")).length).isEqualTo(0);
assertThat(((String[]) metadata.getAnnotationAttributes(DirectAnnotation.class.getName()).get("additionalArray"))).hasSize(0);
}
{ // perform tests with classValuesAsString = true
AnnotationAttributes specialAttrs = (AnnotationAttributes) metadata.getAnnotationAttributes(

4
spring-core/src/test/java/org/springframework/util/FastByteArrayOutputStreamTests.java
View File

@ -45,7 +45,7 @@ class FastByteArrayOutputStreamTests {
@Test
void size() throws Exception {
this.os.write(this.helloBytes);
assertThat(this.helloBytes.length).isEqualTo(this.os.size());
assertThat(this.helloBytes).hasSize(this.os.size());
}
@Test
@ -123,7 +123,7 @@ class FastByteArrayOutputStreamTests {
@Test
void getInputStreamAvailable() throws Exception {
this.os.write(this.helloBytes);
assertThat(this.helloBytes.length).isEqualTo(this.os.getInputStream().available());
assertThat(this.helloBytes).hasSize(this.os.getInputStream().available());
}
@Test

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

@ -151,7 +151,7 @@ class ObjectUtilsTests {
void toObjectArrayWithNull() {
Object[] objects = ObjectUtils.toObjectArray(null);
assertThat(objects).isNotNull();
assertThat(objects.length).isEqualTo(0);
assertThat(objects).hasSize(0);
}
@Test

16
spring-core/src/test/java/org/springframework/util/StringUtilsTests.java
View File

@ -441,7 +441,7 @@ class StringUtilsTests {
String[] input1 = new String[] {"myString2"};
String[] input2 = new String[] {"myString1", "myString2"};
String[] result = StringUtils.concatenateStringArrays(input1, input2);
assertThat(result.length).isEqualTo(3);
assertThat(result).hasSize(3);
assertThat(result[0]).isEqualTo("myString2");
assertThat(result[1]).isEqualTo("myString1");
assertThat(result[2]).isEqualTo("myString2");
@ -490,21 +490,21 @@ class StringUtilsTests {
@Test
void tokenizeToStringArray() {
String[] sa = StringUtils.tokenizeToStringArray("a,b , ,c", ",");
assertThat(sa.length).isEqualTo(3);
assertThat(sa).hasSize(3);
assertThat(sa[0].equals("a") && sa[1].equals("b") && sa[2].equals("c")).as("components are correct").isTrue();
}
@Test
void tokenizeToStringArrayWithNotIgnoreEmptyTokens() {
String[] sa = StringUtils.tokenizeToStringArray("a,b , ,c", ",", true, false);
assertThat(sa.length).isEqualTo(4);
assertThat(sa).hasSize(4);
assertThat(sa[0].equals("a") && sa[1].equals("b") && sa[2].isEmpty() && sa[3].equals("c")).as("components are correct").isTrue();
}
@Test
void tokenizeToStringArrayWithNotTrimTokens() {
String[] sa = StringUtils.tokenizeToStringArray("a,b ,c", ",", false, true);
assertThat(sa.length).isEqualTo(3);
assertThat(sa).hasSize(3);
assertThat(sa[0].equals("a") && sa[1].equals("b ") && sa[2].equals("c")).as("components are correct").isTrue();
}
@ -525,7 +525,7 @@ class StringUtilsTests {
@Test
void delimitedListToStringArrayWithComma() {
String[] sa = StringUtils.delimitedListToStringArray("a,b", ",");
assertThat(sa.length).isEqualTo(2);
assertThat(sa).hasSize(2);
assertThat(sa[0]).isEqualTo("a");
assertThat(sa[1]).isEqualTo("b");
}
@ -533,7 +533,7 @@ class StringUtilsTests {
@Test
void delimitedListToStringArrayWithSemicolon() {
String[] sa = StringUtils.delimitedListToStringArray("a;b", ";");
assertThat(sa.length).isEqualTo(2);
assertThat(sa).hasSize(2);
assertThat(sa[0]).isEqualTo("a");
assertThat(sa[1]).isEqualTo("b");
}
@ -541,7 +541,7 @@ class StringUtilsTests {
@Test
void delimitedListToStringArrayWithEmptyDelimiter() {
String[] sa = StringUtils.delimitedListToStringArray("a,b", "");
assertThat(sa.length).isEqualTo(3);
assertThat(sa).hasSize(3);
assertThat(sa[0]).isEqualTo("a");
assertThat(sa[1]).isEqualTo(",");
assertThat(sa[2]).isEqualTo("b");
@ -550,7 +550,7 @@ class StringUtilsTests {
@Test
void delimitedListToStringArrayWithNullDelimiter() {
String[] sa = StringUtils.delimitedListToStringArray("a,b", null);
assertThat(sa.length).isEqualTo(1);
assertThat(sa).hasSize(1);
assertThat(sa[0]).isEqualTo("a,b");
}

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

@ -166,7 +166,7 @@ public class TemplateExpressionParsingTests extends AbstractExpressionTests {
assertThat(ex.getClass()).isEqualTo(CompositeStringExpression.class);
CompositeStringExpression cse = (CompositeStringExpression)ex;
Expression[] exprs = cse.getExpressions();
assertThat(exprs.length).isEqualTo(3);
assertThat(exprs).hasSize(3);
assertThat(exprs[1].getExpressionString()).isEqualTo("listOfNumbersUpToTen.$[#root.listOfNumbersUpToTen.$[#this%2==1]==3]");
s = ex.getValue(TestScenarioCreator.getTestEvaluationContext(),String.class);
assertThat(s).isEqualTo("hello world");

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

@ -253,11 +253,11 @@ public class ReflectionHelperTests extends AbstractExpressionTests {
Object[] newArray = ReflectionHelper.setupArgumentsForVarargsInvocation(
new Class<?>[] {String[].class}, "a", "b", "c");
assertThat(newArray.length).isEqualTo(1);
assertThat(newArray).hasSize(1);
Object firstParam = newArray[0];
assertThat(firstParam.getClass().getComponentType()).isEqualTo(String.class);
Object[] firstParamArray = (Object[]) firstParam;
assertThat(firstParamArray.length).isEqualTo(3);
assertThat(firstParamArray).hasSize(3);
assertThat(firstParamArray[0]).isEqualTo("a");
assertThat(firstParamArray[1]).isEqualTo("b");
assertThat(firstParamArray[2]).isEqualTo("c");
@ -412,7 +412,7 @@ public class ReflectionHelperTests extends AbstractExpressionTests {
}
private void checkArguments(Object[] args, Object... expected) {
assertThat(args.length).isEqualTo(expected.length);
assertThat(args).hasSize(expected.length);
for (int i = 0; i < expected.length; i++) {
checkArgument(expected[i],args[i]);
}

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

@ -161,7 +161,7 @@ public class NamedParameterUtilsTests {
paramMap.addValue("b", "b");
paramMap.addValue("c", "c");
Object[] params = NamedParameterUtils.buildValueArray(psql1, paramMap, null);
assertThat(params.length).isEqualTo(4);
assertThat(params).hasSize(4);
assertThat(params[0]).isEqualTo("a");
assertThat(params[1]).isEqualTo("b");
assertThat(params[2]).isEqualTo("c");

6
spring-jdbc/src/test/java/org/springframework/jdbc/object/BatchSqlUpdateTests.java
View File

@ -77,11 +77,11 @@ public class BatchSqlUpdateTests {
if (flushThroughBatchSize) {
assertThat(update.getQueueCount()).isEqualTo(0);
assertThat(update.getRowsAffected().length).isEqualTo(2);
assertThat(update.getRowsAffected()).hasSize(2);
}
else {
assertThat(update.getQueueCount()).isEqualTo(2);
assertThat(update.getRowsAffected().length).isEqualTo(0);
assertThat(update.getRowsAffected()).hasSize(0);
}
int[] actualRowsAffected = update.flush();
@ -102,7 +102,7 @@ public class BatchSqlUpdateTests {
assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected[1]);
update.reset();
assertThat(update.getRowsAffected().length).isEqualTo(0);
assertThat(update.getRowsAffected()).hasSize(0);
verify(preparedStatement).setObject(1, ids[0], Types.INTEGER);
verify(preparedStatement).setObject(1, ids[1], Types.INTEGER);

12
spring-jdbc/src/test/java/org/springframework/jdbc/support/SQLErrorCodesFactoryTests.java
View File

@ -185,7 +185,7 @@ public class SQLErrorCodesFactoryTests {
// Should have loaded without error
TestSQLErrorCodesFactory sf = new TestSQLErrorCodesFactory();
assertThat(sf.getErrorCodes("XX").getBadSqlGrammarCodes().length == 0).isTrue();
assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes().length).isEqualTo(2);
assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes()).hasSize(2);
assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes()[0]).isEqualTo("1");
assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes()[1]).isEqualTo("2");
}
@ -206,7 +206,7 @@ public class SQLErrorCodesFactoryTests {
// Should have failed to load without error
TestSQLErrorCodesFactory sf = new TestSQLErrorCodesFactory();
assertThat(sf.getErrorCodes("XX").getBadSqlGrammarCodes().length == 0).isTrue();
assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes().length).isEqualTo(0);
assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes()).hasSize(0);
}
/**
@ -226,11 +226,11 @@ public class SQLErrorCodesFactoryTests {
// Should have loaded without error
TestSQLErrorCodesFactory sf = new TestSQLErrorCodesFactory();
assertThat(sf.getErrorCodes("Oracle").getCustomTranslations().length).isEqualTo(1);
assertThat(sf.getErrorCodes("Oracle").getCustomTranslations()).hasSize(1);
CustomSQLErrorCodesTranslation translation =
sf.getErrorCodes("Oracle").getCustomTranslations()[0];
assertThat(translation.getExceptionClass()).isEqualTo(CustomErrorCodeException.class);
assertThat(translation.getErrorCodes().length).isEqualTo(1);
assertThat(translation.getErrorCodes()).hasSize(1);
}
@Test
@ -371,8 +371,8 @@ public class SQLErrorCodesFactoryTests {
}
private void assertIsEmpty(SQLErrorCodes sec) {
assertThat(sec.getBadSqlGrammarCodes().length).isEqualTo(0);
assertThat(sec.getDataIntegrityViolationCodes().length).isEqualTo(0);
assertThat(sec.getBadSqlGrammarCodes()).hasSize(0);
assertThat(sec.getDataIntegrityViolationCodes()).hasSize(0);
}
}

2
spring-jms/src/test/java/org/springframework/jms/support/SimpleMessageConverterTests.java
View File

@ -78,7 +78,7 @@ public class SimpleMessageConverterTests {
SimpleMessageConverter converter = new SimpleMessageConverter();
Message msg = converter.toMessage(content, session);
assertThat(((byte[]) converter.fromMessage(msg)).length).isEqualTo(content.length);
assertThat(((byte[]) converter.fromMessage(msg))).hasSize(content.length);
verify(message).writeBytes(content);
}

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

@ -82,7 +82,7 @@ public class SimpAttributesTests {
this.simpAttributes.registerDestructionCallback("name1", callback1);
this.simpAttributes.registerDestructionCallback("name2", callback2);
assertThat(this.simpAttributes.getAttributeNames().length).isEqualTo(2);
assertThat(this.simpAttributes.getAttributeNames()).hasSize(2);
}
@Test

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

@ -46,7 +46,7 @@ public class StompDecoderTests {
assertThat(headers.getCommand()).isEqualTo(StompCommand.DISCONNECT);
assertThat(headers.toNativeHeaderMap()).hasSize(0);
assertThat(frame.getPayload().length).isEqualTo(0);
assertThat(frame.getPayload()).hasSize(0);
}
@Test
@ -56,7 +56,7 @@ public class StompDecoderTests {
assertThat(headers.getCommand()).isEqualTo(StompCommand.DISCONNECT);
assertThat(headers.toNativeHeaderMap()).hasSize(0);
assertThat(frame.getPayload().length).isEqualTo(0);
assertThat(frame.getPayload()).hasSize(0);
}
@Test
@ -73,7 +73,7 @@ public class StompDecoderTests {
assertThat(headers.getFirstNativeHeader("accept-version")).isEqualTo("1.1");
assertThat(headers.getHost()).isEqualTo("github.org");
assertThat(frame.getPayload().length).isEqualTo(0);
assertThat(frame.getPayload()).hasSize(0);
}
@Test
@ -173,7 +173,7 @@ public class StompDecoderTests {
assertThat(headers.getFirstNativeHeader("accept-version")).isEqualTo("1.1");
assertThat(headers.getFirstNativeHeader("key")).isEqualTo("\\value");
assertThat(frame.getPayload().length).isEqualTo(0);
assertThat(frame.getPayload()).hasSize(0);
}
@Test
@ -220,7 +220,7 @@ public class StompDecoderTests {
assertThat(headers.getFirstNativeHeader("accept-version")).isEqualTo("1.1");
assertThat(headers.getFirstNativeHeader("key")).isEqualTo("");
assertThat(frame.getPayload().length).isEqualTo(0);
assertThat(frame.getPayload()).hasSize(0);
}
@Test

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

@ -57,7 +57,7 @@ public class PersistenceXmlParsingTests {
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertThat(info).isNotNull();
assertThat(info.length).isEqualTo(1);
assertThat(info).hasSize(1);
assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement");
assertThat(info[0].getJarFileUrls()).hasSize(2);
@ -75,7 +75,7 @@ public class PersistenceXmlParsingTests {
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertThat(info).isNotNull();
assertThat(info.length).isEqualTo(1);
assertThat(info).hasSize(1);
assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement");
assertThat(info[0].excludeUnlistedClasses()).as("Exclude unlisted should default false in 1.0.").isFalse();
@ -89,7 +89,7 @@ public class PersistenceXmlParsingTests {
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertThat(info).isNotNull();
assertThat(info.length).isEqualTo(1);
assertThat(info).hasSize(1);
assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement2");
@ -108,7 +108,7 @@ public class PersistenceXmlParsingTests {
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertThat(info).isNotNull();
assertThat(info.length).isEqualTo(1);
assertThat(info).hasSize(1);
assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement3");
assertThat(info[0].getJarFileUrls()).hasSize(2);
@ -134,7 +134,7 @@ public class PersistenceXmlParsingTests {
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertThat(info).isNotNull();
assertThat(info.length).isEqualTo(1);
assertThat(info).hasSize(1);
assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement4");
assertThat(info[0].getMappingFileNames()).hasSize(1);
@ -161,7 +161,7 @@ public class PersistenceXmlParsingTests {
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertThat(info).isNotNull();
assertThat(info.length).isEqualTo(1);
assertThat(info).hasSize(1);
assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement5");
assertThat(info[0].getMappingFileNames()).hasSize(2);
@ -192,7 +192,7 @@ public class PersistenceXmlParsingTests {
new PathMatchingResourcePatternResolver(), dataSourceLookup);
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertThat(info.length).isEqualTo(2);
assertThat(info).hasSize(2);
PersistenceUnitInfo pu1 = info[0];
@ -247,7 +247,7 @@ public class PersistenceXmlParsingTests {
new PathMatchingResourcePatternResolver(), new JndiDataSourceLookup());
String resource = "/org/springframework/orm/jpa/persistence-example6.xml";
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertThat(info.length).isEqualTo(1);
assertThat(info).hasSize(1);
assertThat(info[0].getPersistenceUnitName()).isEqualTo("pu");
assertThat(info[0].getProperties().keySet()).hasSize(0);

8
spring-test/src/test/java/org/springframework/mock/web/MockHttpServletRequestTests.java
View File

@ -236,11 +236,11 @@ class MockHttpServletRequestTests {
params.put("key3", new String[] { "value3A", "value3B" });
request.setParameters(params);
String[] values1 = request.getParameterValues("key1");
assertThat(values1.length).isEqualTo(1);
assertThat(values1).hasSize(1);
assertThat(request.getParameter("key1")).isEqualTo("newValue1");
assertThat(request.getParameter("key2")).isEqualTo("value2");
String[] values3 = request.getParameterValues("key3");
assertThat(values3.length).isEqualTo(2);
assertThat(values3).hasSize(2);
assertThat(values3[0]).isEqualTo("value3A");
assertThat(values3[1]).isEqualTo("value3B");
}
@ -254,12 +254,12 @@ class MockHttpServletRequestTests {
params.put("key3", new String[] { "value3A", "value3B" });
request.addParameters(params);
String[] values1 = request.getParameterValues("key1");
assertThat(values1.length).isEqualTo(2);
assertThat(values1).hasSize(2);
assertThat(values1[0]).isEqualTo("value1");
assertThat(values1[1]).isEqualTo("newValue1");
assertThat(request.getParameter("key2")).isEqualTo("value2");
String[] values3 = request.getParameterValues("key3");
assertThat(values3.length).isEqualTo(2);
assertThat(values3).hasSize(2);
assertThat(values3[0]).isEqualTo("value3A");
assertThat(values3[1]).isEqualTo("value3B");
}

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

@ -280,7 +280,7 @@ class MockHttpServletResponseTests {
int size = response.getBufferSize();
response.getOutputStream().write(new byte[size]);
assertThat(response.isCommitted()).isTrue();
assertThat(response.getContentAsByteArray().length).isEqualTo((size + 1));
assertThat(response.getContentAsByteArray()).hasSize((size + 1));
}
@Test
@ -290,7 +290,7 @@ class MockHttpServletResponseTests {
assertThat(response.isCommitted()).isFalse();
response.flushBuffer();
assertThat(response.isCommitted()).isTrue();
assertThat(response.getContentAsByteArray().length).isEqualTo(1);
assertThat(response.getContentAsByteArray()).hasSize(1);
}
@Test
@ -303,7 +303,7 @@ class MockHttpServletResponseTests {
Arrays.fill(data, 'p');
response.getWriter().write(data);
assertThat(response.isCommitted()).isTrue();
assertThat(response.getContentAsByteArray().length).isEqualTo((size + 1));
assertThat(response.getContentAsByteArray()).hasSize((size + 1));
}
@Test
@ -313,7 +313,7 @@ class MockHttpServletResponseTests {
assertThat(response.isCommitted()).isFalse();
response.getOutputStream().flush();
assertThat(response.isCommitted()).isTrue();
assertThat(response.getContentAsByteArray().length).isEqualTo(1);
assertThat(response.getContentAsByteArray()).hasSize(1);
}
@Test
@ -323,7 +323,7 @@ class MockHttpServletResponseTests {
assertThat(response.isCommitted()).isFalse();
response.getWriter().flush();
assertThat(response.isCommitted()).isTrue();
assertThat(response.getContentAsByteArray().length).isEqualTo(1);
assertThat(response.getContentAsByteArray()).hasSize(1);
}
@Test // SPR-16683
@ -333,7 +333,7 @@ class MockHttpServletResponseTests {
assertThat(response.isCommitted()).isFalse();
response.getWriter().close();
assertThat(response.isCommitted()).isTrue();
assertThat(response.getContentAsByteArray().length).isEqualTo(1);
assertThat(response.getContentAsByteArray()).hasSize(1);
}
@Test // gh-23219

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

@ -77,7 +77,7 @@ class TestContextConcurrencyTests {
});
assertThat(actualMethods).isEqualTo(expectedMethods);
});
assertThat(tcm.getTestContext().attributeNames().length).isEqualTo(0);
assertThat(tcm.getTestContext().attributeNames()).hasSize(0);
}

2
spring-test/src/test/java/org/springframework/test/context/support/AnnotationConfigContextLoaderUtilsTests.java
View File

@ -47,7 +47,7 @@ class AnnotationConfigContextLoaderUtilsTests {
void detectDefaultConfigurationClassesWithoutConfigurationClass() {
Class<?>[] configClasses = detectDefaultConfigurationClasses(NoConfigTestCase.class);
assertThat(configClasses).isNotNull();
assertThat(configClasses.length).isEqualTo(0);
assertThat(configClasses).hasSize(0);
}
@Test

16
spring-test/src/test/java/org/springframework/test/context/support/ContextLoaderUtilsContextHierarchyTests.java
View File

@ -338,20 +338,20 @@ class ContextLoaderUtilsContextHierarchyTests extends AbstractContextConfigurati
List<ContextConfigurationAttributes> alphaConfig = map.get("alpha");
assertThat(alphaConfig).hasSize(2);
assertThat(alphaConfig.get(0).getLocations().length).isEqualTo(1);
assertThat(alphaConfig.get(0).getLocations()).hasSize(1);
assertThat(alphaConfig.get(0).getLocations()[0]).isEqualTo("1-A.xml");
assertThat(alphaConfig.get(0).getInitializers().length).isEqualTo(0);
assertThat(alphaConfig.get(1).getLocations().length).isEqualTo(0);
assertThat(alphaConfig.get(1).getInitializers().length).isEqualTo(1);
assertThat(alphaConfig.get(0).getInitializers()).hasSize(0);
assertThat(alphaConfig.get(1).getLocations()).hasSize(0);
assertThat(alphaConfig.get(1).getInitializers()).hasSize(1);
assertThat(alphaConfig.get(1).getInitializers()[0]).isEqualTo(DummyApplicationContextInitializer.class);
List<ContextConfigurationAttributes> betaConfig = map.get("beta");
assertThat(betaConfig).hasSize(2);
assertThat(betaConfig.get(0).getLocations().length).isEqualTo(1);
assertThat(betaConfig.get(0).getLocations()).hasSize(1);
assertThat(betaConfig.get(0).getLocations()[0]).isEqualTo("1-B.xml");
assertThat(betaConfig.get(0).getInitializers().length).isEqualTo(0);
assertThat(betaConfig.get(1).getLocations().length).isEqualTo(0);
assertThat(betaConfig.get(1).getInitializers().length).isEqualTo(1);
assertThat(betaConfig.get(0).getInitializers()).hasSize(0);
assertThat(betaConfig.get(1).getLocations()).hasSize(0);
assertThat(betaConfig.get(1).getInitializers()).hasSize(1);
assertThat(betaConfig.get(1).getInitializers()[0]).isEqualTo(DummyApplicationContextInitializer.class);
}

32
spring-test/src/test/java/org/springframework/test/web/client/response/ResponseCreatorsTests.java
View File

@ -46,7 +46,7 @@ class ResponseCreatorsTests {
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(response.getHeaders().isEmpty()).isTrue();
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -77,7 +77,7 @@ class ResponseCreatorsTests {
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
assertThat(response.getHeaders().getLocation()).isEqualTo(location);
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -86,7 +86,7 @@ class ResponseCreatorsTests {
MockClientHttpResponse response = (MockClientHttpResponse) responseCreator.createResponse(null);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.ACCEPTED);
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -96,7 +96,7 @@ class ResponseCreatorsTests {
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT);
assertThat(response.getHeaders().isEmpty()).isTrue();
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -106,7 +106,7 @@ class ResponseCreatorsTests {
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
assertThat(response.getHeaders().isEmpty()).isTrue();
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -116,7 +116,7 @@ class ResponseCreatorsTests {
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
assertThat(response.getHeaders().isEmpty()).isTrue();
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -125,7 +125,7 @@ class ResponseCreatorsTests {
MockClientHttpResponse response = (MockClientHttpResponse) responseCreator.createResponse(null);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -134,7 +134,7 @@ class ResponseCreatorsTests {
MockClientHttpResponse response = (MockClientHttpResponse) responseCreator.createResponse(null);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -143,7 +143,7 @@ class ResponseCreatorsTests {
MockClientHttpResponse response = (MockClientHttpResponse) responseCreator.createResponse(null);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CONFLICT);
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -153,7 +153,7 @@ class ResponseCreatorsTests {
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.TOO_MANY_REQUESTS);
assertThat(response.getHeaders()).doesNotContainKey(HttpHeaders.RETRY_AFTER);
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -163,7 +163,7 @@ class ResponseCreatorsTests {
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.TOO_MANY_REQUESTS);
assertThat(response.getHeaders().getFirst(HttpHeaders.RETRY_AFTER)).isEqualTo("512");
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -173,7 +173,7 @@ class ResponseCreatorsTests {
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR);
assertThat(response.getHeaders().isEmpty()).isTrue();
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -182,7 +182,7 @@ class ResponseCreatorsTests {
MockClientHttpResponse response = (MockClientHttpResponse) responseCreator.createResponse(null);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_GATEWAY);
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -191,7 +191,7 @@ class ResponseCreatorsTests {
MockClientHttpResponse response = (MockClientHttpResponse) responseCreator.createResponse(null);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.SERVICE_UNAVAILABLE);
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -200,7 +200,7 @@ class ResponseCreatorsTests {
MockClientHttpResponse response = (MockClientHttpResponse) responseCreator.createResponse(null);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.GATEWAY_TIMEOUT);
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test
@ -210,7 +210,7 @@ class ResponseCreatorsTests {
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
assertThat(response.getHeaders().isEmpty()).isTrue();
assertThat(StreamUtils.copyToByteArray(response.getBody()).length).isEqualTo(0);
assertThat(StreamUtils.copyToByteArray(response.getBody())).hasSize(0);
}
@Test

6
spring-test/src/test/java/org/springframework/test/web/servlet/htmlunit/HtmlUnitRequestBuilderTests.java
View File

@ -230,7 +230,7 @@ public class HtmlUnitRequestBuilderTests {
MockHttpServletRequest actualRequest = requestBuilder.buildRequest(servletContext);
Cookie[] cookies = actualRequest.getCookies();
assertThat(cookies.length).isEqualTo(1);
assertThat(cookies).hasSize(1);
assertThat(cookies[0].getName()).isEqualTo("name");
assertThat(cookies[0].getValue()).isEqualTo("value");
}
@ -242,7 +242,7 @@ public class HtmlUnitRequestBuilderTests {
MockHttpServletRequest actualRequest = requestBuilder.buildRequest(servletContext);
Cookie[] cookies = actualRequest.getCookies();
assertThat(cookies.length).isEqualTo(2);
assertThat(cookies).hasSize(2);
Cookie cookie = cookies[0];
assertThat(cookie.getName()).isEqualTo("name");
assertThat(cookie.getValue()).isEqualTo("value");
@ -857,7 +857,7 @@ public class HtmlUnitRequestBuilderTests {
Cookie[] cookies = mockMvc.perform(requestBuilder).andReturn().getRequest().getCookies();
assertThat(cookies).isNotNull();
assertThat(cookies.length).isEqualTo(1);
assertThat(cookies).hasSize(1);
Cookie cookie = cookies[0];
assertThat(cookie.getName()).isEqualTo(cookieName);
assertThat(cookie.getValue()).isEqualTo(cookieValue);

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

@ -463,7 +463,7 @@ class MockHttpServletRequestBuilderTests {
MockHttpServletRequest request = this.builder.buildRequest(this.servletContext);
Cookie[] cookies = request.getCookies();
assertThat(cookies.length).isEqualTo(2);
assertThat(cookies).hasSize(2);
assertThat(cookies[0].getName()).isEqualTo("foo");
assertThat(cookies[0].getValue()).isEqualTo("bar");
assertThat(cookies[1].getName()).isEqualTo("baz");

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

@ -190,7 +190,7 @@ class PrintingResultHandlerTests {
Map<String, Map<String, Object>> printedValues = this.handler.getPrinter().printedValues;
String[] cookies = (String[]) printedValues.get(heading).get("Cookies");
assertThat(cookies.length).isEqualTo(2);
assertThat(cookies).hasSize(2);
String cookie1 = cookies[0];
String cookie2 = cookies[1];
assertThat(cookie1.startsWith("[" + Cookie.class.getSimpleName())).isTrue();

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

@ -68,7 +68,7 @@ class RandomHandlerIntegrationTests extends AbstractHttpHandlerIntegrationTests
assertThat(response.getBody()).isNotNull();
assertThat(response.getHeaders().getContentLength()).isEqualTo(RESPONSE_SIZE);
assertThat(response.getBody().length).isEqualTo(RESPONSE_SIZE);
assertThat(response.getBody()).hasSize(RESPONSE_SIZE);
}

4
spring-web/src/test/java/org/springframework/web/bind/support/WebRequestDataBinderTests.java
View File

@ -269,7 +269,7 @@ public class WebRequestDataBinderTests {
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
request.addFile(new MockMultipartFile("stringArray", "Juergen".getBytes()));
binder.bind(new ServletWebRequest(request));
assertThat(target.getStringArray().length).isEqualTo(1);
assertThat(target.getStringArray()).hasSize(1);
assertThat(target.getStringArray()[0]).isEqualTo("Juergen");
}
@ -283,7 +283,7 @@ public class WebRequestDataBinderTests {
request.addFile(new MockMultipartFile("stringArray", "Juergen".getBytes()));
request.addFile(new MockMultipartFile("stringArray", "Eva".getBytes()));
binder.bind(new ServletWebRequest(request));
assertThat(target.getStringArray().length).isEqualTo(2);
assertThat(target.getStringArray()).hasSize(2);
assertThat(target.getStringArray()[0]).isEqualTo("Juergen");
assertThat(target.getStringArray()[1]).isEqualTo("Eva");
}

8
spring-web/src/test/java/org/springframework/web/context/request/ServletWebRequestTests.java
View File

@ -61,18 +61,18 @@ public class ServletWebRequestTests {
servletRequest.addParameter("param2", "value2a");
assertThat(request.getParameter("param1")).isEqualTo("value1");
assertThat(request.getParameterValues("param1").length).isEqualTo(1);
assertThat(request.getParameterValues("param1")).hasSize(1);
assertThat(request.getParameterValues("param1")[0]).isEqualTo("value1");
assertThat(request.getParameter("param2")).isEqualTo("value2");
assertThat(request.getParameterValues("param2").length).isEqualTo(2);
assertThat(request.getParameterValues("param2")).hasSize(2);
assertThat(request.getParameterValues("param2")[0]).isEqualTo("value2");
assertThat(request.getParameterValues("param2")[1]).isEqualTo("value2a");
Map<String, String[]> paramMap = request.getParameterMap();
assertThat(paramMap).hasSize(2);
assertThat(paramMap.get("param1").length).isEqualTo(1);
assertThat(paramMap.get("param1")).hasSize(1);
assertThat(paramMap.get("param1")[0]).isEqualTo("value1");
assertThat(paramMap.get("param2").length).isEqualTo(2);
assertThat(paramMap.get("param2")).hasSize(2);
assertThat(paramMap.get("param2")[0]).isEqualTo("value2");
assertThat(paramMap.get("param2")[1]).isEqualTo("value2a");
}

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

@ -225,7 +225,7 @@ public class RequestParamMethodArgumentResolverTests {
boolean condition = result instanceof MultipartFile[];
assertThat(condition).isTrue();
MultipartFile[] parts = (MultipartFile[]) result;
assertThat(parts.length).isEqualTo(2);
assertThat(parts).hasSize(2);
assertThat(expected1).isEqualTo(parts[0]);
assertThat(expected2).isEqualTo(parts[1]);
}
@ -309,7 +309,7 @@ public class RequestParamMethodArgumentResolverTests {
boolean condition = result instanceof Part[];
assertThat(condition).isTrue();
Part[] parts = (Part[]) result;
assertThat(parts.length).isEqualTo(2);
assertThat(parts).hasSize(2);
assertThat(expected1).isEqualTo(parts[0]);
assertThat(expected2).isEqualTo(parts[1]);
}

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

@ -262,7 +262,7 @@ public class RequestMappingMessageConversionIntegrationTests extends AbstractReq
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(response.hasBody()).isTrue();
assertThat(response.getHeaders().getContentLength()).isEqualTo(951);
assertThat(response.getBody().length).isEqualTo(951);
assertThat(response.getBody()).hasSize(951);
assertThat(response.getHeaders().getContentType()).isEqualTo(new MediaType("image", "png"));
}

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

@ -775,11 +775,11 @@ public class MvcNamespaceTests {
CallableProcessingInterceptor[] callableInterceptors =
(CallableProcessingInterceptor[]) fieldAccessor.getPropertyValue("callableInterceptors");
assertThat(callableInterceptors.length).isEqualTo(1);
assertThat(callableInterceptors).hasSize(1);
DeferredResultProcessingInterceptor[] deferredResultInterceptors =
(DeferredResultProcessingInterceptor[]) fieldAccessor.getPropertyValue("deferredResultInterceptors");
assertThat(deferredResultInterceptors.length).isEqualTo(1);
assertThat(deferredResultInterceptors).hasSize(1);
}
@Test
@ -907,7 +907,7 @@ public class MvcNamespaceTests {
loadBeanDefinitions("mvc-config-cors-minimal.xml");
String[] beanNames = appContext.getBeanNamesForType(AbstractHandlerMapping.class);
assertThat(beanNames.length).isEqualTo(2);
assertThat(beanNames).hasSize(2);
for (String beanName : beanNames) {
AbstractHandlerMapping handlerMapping = (AbstractHandlerMapping)appContext.getBean(beanName);
assertThat(handlerMapping).isNotNull();
@ -932,7 +932,7 @@ public class MvcNamespaceTests {
loadBeanDefinitions("mvc-config-cors.xml");
String[] beanNames = appContext.getBeanNamesForType(AbstractHandlerMapping.class);
assertThat(beanNames.length).isEqualTo(2);
assertThat(beanNames).hasSize(2);
for (String beanName : beanNames) {
AbstractHandlerMapping handlerMapping = (AbstractHandlerMapping)appContext.getBean(beanName);
assertThat(handlerMapping).isNotNull();

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

@ -137,7 +137,7 @@ public class WebMvcConfigurationSupportExtensionTests {
assertThat(chain).isNotNull();
HandlerInterceptor[] interceptors = chain.getInterceptors();
assertThat(interceptors).isNotNull();
assertThat(interceptors.length).isEqualTo(4);
assertThat(interceptors).hasSize(4);
assertThat(interceptors[0].getClass().getSimpleName()).isEqualTo("CorsInterceptor");
assertThat(interceptors[1].getClass()).isEqualTo(LocaleChangeInterceptor.class);
assertThat(interceptors[2].getClass()).isEqualTo(ConversionServiceExposingInterceptor.class);
@ -235,11 +235,11 @@ public class WebMvcConfigurationSupportExtensionTests {
CallableProcessingInterceptor[] callableInterceptors =
(CallableProcessingInterceptor[]) fieldAccessor.getPropertyValue("callableInterceptors");
assertThat(callableInterceptors.length).isEqualTo(1);
assertThat(callableInterceptors).hasSize(1);
DeferredResultProcessingInterceptor[] deferredResultInterceptors =
(DeferredResultProcessingInterceptor[]) fieldAccessor.getPropertyValue("deferredResultInterceptors");
assertThat(deferredResultInterceptors.length).isEqualTo(1);
assertThat(deferredResultInterceptors).hasSize(1);
assertThat(fieldAccessor.getPropertyValue("ignoreDefaultModelOnRedirect")).asInstanceOf(BOOLEAN).isTrue();
}

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

@ -163,7 +163,7 @@ public class WebMvcConfigurationSupportTests {
assertThat(chain).isNotNull();
HandlerInterceptor[] interceptors = chain.getInterceptors();
assertThat(interceptors).isNotNull();
assertThat(interceptors.length).isEqualTo(3);
assertThat(interceptors).hasSize(3);
assertThat(interceptors[1].getClass()).isEqualTo(ConversionServiceExposingInterceptor.class);
assertThat(interceptors[2].getClass()).isEqualTo(ResourceUrlProviderExposingInterceptor.class);
}

2
spring-webmvc/src/test/java/org/springframework/web/servlet/function/DefaultRenderingResponseTests.java
View File

@ -140,7 +140,7 @@ public class DefaultRenderingResponseTests {
MockHttpServletResponse response = new MockHttpServletResponse();
ModelAndView mav = result.writeTo(request, response, EMPTY_CONTEXT);
assertThat(mav).isNotNull();
assertThat(response.getCookies().length).isEqualTo(1);
assertThat(response.getCookies()).hasSize(1);
assertThat(response.getCookies()[0].getName()).isEqualTo("name");
assertThat(response.getCookies()[0].getValue()).isEqualTo("value");
}

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

@ -162,7 +162,7 @@ public class ResourceHandlerFunctionTests {
assertThat(servletResponse.getStatus()).isEqualTo(200);
byte[] actualBytes = servletResponse.getContentAsByteArray();
assertThat(actualBytes.length).isEqualTo(0);
assertThat(actualBytes).hasSize(0);
assertThat(servletResponse.getContentType()).isEqualTo(MediaType.TEXT_PLAIN_VALUE);
assertThat(servletResponse.getContentLength()).isEqualTo(this.resource.contentLength());
}
@ -185,7 +185,7 @@ public class ResourceHandlerFunctionTests {
String[] methods = StringUtils.tokenizeToStringArray(allowHeader, ",");
assertThat(methods).containsExactlyInAnyOrder("GET","HEAD","OPTIONS");
byte[] actualBytes = servletResponse.getContentAsByteArray();
assertThat(actualBytes.length).isEqualTo(0);
assertThat(actualBytes).hasSize(0);
}
}

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

@ -832,7 +832,7 @@ public class HttpEntityMethodProcessorMockTests {
assertResponseBody(body);
}
else {
assertThat(servletResponse.getContentAsByteArray().length).isEqualTo(0);
assertThat(servletResponse.getContentAsByteArray()).hasSize(0);
}
if (etag != null) {
assertThat(servletResponse.getHeaderValues(HttpHeaders.ETAG)).hasSize(1);

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

@ -203,7 +203,7 @@ public class RequestPartMethodArgumentResolverTests {
assertThat(actual).isNotNull();
assertThat(actual instanceof MultipartFile[]).isTrue();
MultipartFile[] parts = (MultipartFile[]) actual;
assertThat(parts.length).isEqualTo(2);
assertThat(parts).hasSize(2);
assertThat(multipartFile1).isEqualTo(parts[0]);
assertThat(multipartFile2).isEqualTo(parts[1]);
}
@ -269,7 +269,7 @@ public class RequestPartMethodArgumentResolverTests {
Object result = resolver.resolveArgument(paramPartArray, null, webRequest, null);
assertThat(result instanceof Part[]).isTrue();
Part[] parts = (Part[]) result;
assertThat(parts.length).isEqualTo(2);
assertThat(parts).hasSize(2);
assertThat(part1).isEqualTo(parts[0]);
assertThat(part2).isEqualTo(parts[1]);
}

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

@ -2731,7 +2731,7 @@ public class ServletAnnotationControllerHandlerMethodTests extends AbstractServl
vf.afterPropertiesSet();
binder.setValidator(vf);
assertThat(date).isEqualTo("2007-10-02");
assertThat(date2.length).isEqualTo(1);
assertThat(date2).hasSize(1);
assertThat(date2[0]).isEqualTo("2007-10-02");
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
dateFormat.setLenient(false);

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

@ -61,14 +61,14 @@ public class WebSocketHandlerRegistrationTests {
assertThat(m1.webSocketHandler).isEqualTo(handler);
assertThat(m1.path).isEqualTo("/foo");
assertThat(m1.interceptors).isNotNull();
assertThat(m1.interceptors.length).isEqualTo(1);
assertThat(m1.interceptors).hasSize(1);
assertThat(m1.interceptors[0].getClass()).isEqualTo(OriginHandshakeInterceptor.class);
Mapping m2 = mappings.get(1);
assertThat(m2.webSocketHandler).isEqualTo(handler);
assertThat(m2.path).isEqualTo("/bar");
assertThat(m2.interceptors).isNotNull();
assertThat(m2.interceptors.length).isEqualTo(1);
assertThat(m2.interceptors).hasSize(1);
assertThat(m2.interceptors[0].getClass()).isEqualTo(OriginHandshakeInterceptor.class);
}
@ -86,7 +86,7 @@ public class WebSocketHandlerRegistrationTests {
assertThat(mapping.webSocketHandler).isEqualTo(handler);
assertThat(mapping.path).isEqualTo("/foo");
assertThat(mapping.interceptors).isNotNull();
assertThat(mapping.interceptors.length).isEqualTo(2);
assertThat(mapping.interceptors).hasSize(2);
assertThat(mapping.interceptors[0]).isEqualTo(interceptor);
assertThat(mapping.interceptors[1].getClass()).isEqualTo(OriginHandshakeInterceptor.class);
}
@ -105,7 +105,7 @@ public class WebSocketHandlerRegistrationTests {
assertThat(mapping.webSocketHandler).isEqualTo(handler);
assertThat(mapping.path).isEqualTo("/foo");
assertThat(mapping.interceptors).isNotNull();
assertThat(mapping.interceptors.length).isEqualTo(2);
assertThat(mapping.interceptors).hasSize(2);
assertThat(mapping.interceptors[0]).isEqualTo(interceptor);
assertThat(mapping.interceptors[1].getClass()).isEqualTo(OriginHandshakeInterceptor.class);
}
@ -127,7 +127,7 @@ public class WebSocketHandlerRegistrationTests {
assertThat(mapping.webSocketHandler).isEqualTo(handler);
assertThat(mapping.path).isEqualTo("/foo");
assertThat(mapping.interceptors).isNotNull();
assertThat(mapping.interceptors.length).isEqualTo(2);
assertThat(mapping.interceptors).hasSize(2);
assertThat(mapping.interceptors[0]).isEqualTo(interceptor);
OriginHandshakeInterceptor originInterceptor = (OriginHandshakeInterceptor) mapping.interceptors[1];