admin/spring-projects-spring-framework
1
0
Fork 0
mirror of https://github.com/spring-projects/spring-framework synced 2026-06-08 17:33:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Clean up AssertJ usage after migration

Browse Source 
- Avoid the use of assertThat(Arrays.equals(...))
- Convert assertThat(Boolean.FALSE).isEqualTo(x) to assertThat(x).isEqualTo(Boolean.FALSE)
- Convert assertThat(Boolean.TRUE).isEqualTo(x) to assertThat(x).isEqualTo(Boolean.TRUE)
- Convert assertThat(x.equals(y)).isTrue() to assertThat(x).isEqualTo(y)
- Convert assertThat(x.equals(y)).isFalse() to assertThat(x).isNotEqualTo(y)
- Remove unnecessary parentheses in assertThat() arguments
- Convert assertThat(x instanceof X).isFalse() to assertThat(x).isNotInstanceOf()
- Convert assertThat(x instanceof X).isTrue() to assertThat(x).isInstanceOf()
- Convert assertThat(!x).isTrue() to assertThat(x).isFalse()
- Inline conditions in assertThat() statements

Closes gh-36504

(cherry picked from commit e1e4d52b61)
This commit is contained in:
Sam Brannen
2026-03-20 11:07:42 +01:00
parent 6d6b788b25
commit 506c6f1777
134 changed files with 514 additions and 755 deletions
Download Patch File Download Diff File Expand all files Collapse all files
integration-tests/src/test/java/org/springframework/aop/config/AopNamespaceHandlerScopeIntegrationTests.java
+5 -10
View File
@@ -63,8 +63,7 @@ class AopNamespaceHandlerScopeIntegrationTests {
@Test
void singletonScoping() throws Exception {
assertThat(AopUtils.isAopProxy(singletonScoped)).as("Should be AOP proxy").isTrue();
boolean condition = singletonScoped instanceof TestBean;
assertThat(condition).as("Should be target class proxy").isTrue();
assertThat(singletonScoped).as("Should be target class proxy").isInstanceOf(TestBean.class);
String rob = "Rob Harrop";
String bram = "Bram Smeets";
assertThat(singletonScoped.getName()).isEqualTo(rob);
@@ -82,12 +81,10 @@ class AopNamespaceHandlerScopeIntegrationTests {
RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(oldRequest));
assertThat(AopUtils.isAopProxy(requestScoped)).as("Should be AOP proxy").isTrue();
boolean condition = requestScoped instanceof TestBean;
assertThat(condition).as("Should be target class proxy").isTrue();
assertThat(requestScoped).as("Should be target class proxy").isInstanceOf(TestBean.class);
assertThat(AopUtils.isAopProxy(testBean)).as("Should be AOP proxy").isTrue();
boolean condition1 = testBean instanceof TestBean;
assertThat(condition1).as("Regular bean should be JDK proxy").isFalse();
assertThat(testBean).as("Regular bean should be JDK proxy").isNotInstanceOf(TestBean.class);
String rob = "Rob Harrop";
String bram = "Bram Smeets";
@@ -112,14 +109,12 @@ class AopNamespaceHandlerScopeIntegrationTests {
RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request));
assertThat(AopUtils.isAopProxy(sessionScoped)).as("Should be AOP proxy").isTrue();
boolean condition1 = sessionScoped instanceof TestBean;
assertThat(condition1).as("Should not be target class proxy").isFalse();
assertThat(sessionScoped).as("Should not be target class proxy").isNotInstanceOf(TestBean.class);
assertThat(sessionScopedAlias).isSameAs(sessionScoped);
assertThat(AopUtils.isAopProxy(testBean)).as("Should be AOP proxy").isTrue();
boolean condition = testBean instanceof TestBean;
assertThat(condition).as("Regular bean should be JDK proxy").isFalse();
assertThat(testBean).as("Regular bean should be JDK proxy").isNotInstanceOf(TestBean.class);
String rob = "Rob Harrop";
String bram = "Bram Smeets";
integration-tests/src/test/java/org/springframework/aop/framework/autoproxy/AdvisorAutoProxyCreatorIntegrationTests.java
+1 -2
View File
@@ -169,8 +169,7 @@ class AdvisorAutoProxyCreatorIntegrationTests {
BeanFactory bf = getBeanFactory();
Object bean = bf.getBean(TXMANAGER_BEAN_NAME);
boolean condition = bean instanceof CallCountingTransactionManager;
assertThat(condition).isTrue();
assertThat(bean).isInstanceOf(CallCountingTransactionManager.class);
CallCountingTransactionManager txMan = (CallCountingTransactionManager) bf.getBean(TXMANAGER_BEAN_NAME);
Rollback rb = (Rollback) bf.getBean("rollback");
integration-tests/src/test/java/org/springframework/context/annotation/jsr330/ClassPathBeanDefinitionScannerJsr330ScopeIntegrationTests.java
+5 -10
View File
@@ -185,8 +185,7 @@ class ClassPathBeanDefinitionScannerJsr330ScopeIntegrationTests {
// should be dynamic proxy, implementing both interfaces
assertThat(AopUtils.isJdkDynamicProxy(bean)).isTrue();
boolean condition = bean instanceof AnotherScopeTestInterface;
assertThat(condition).isTrue();
assertThat(bean).isInstanceOf(AnotherScopeTestInterface.class);
assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
bean.setName(MODIFIED_NAME);
@@ -207,8 +206,7 @@ class ClassPathBeanDefinitionScannerJsr330ScopeIntegrationTests {
// should be a class-based proxy
assertThat(AopUtils.isCglibProxy(bean)).isTrue();
boolean condition = bean instanceof RequestScopedTestBean;
assertThat(condition).isTrue();
assertThat(bean).isInstanceOf(RequestScopedTestBean.class);
assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
bean.setName(MODIFIED_NAME);
@@ -250,8 +248,7 @@ class ClassPathBeanDefinitionScannerJsr330ScopeIntegrationTests {
// should be dynamic proxy, implementing both interfaces
assertThat(AopUtils.isJdkDynamicProxy(bean)).isTrue();
boolean condition = bean instanceof AnotherScopeTestInterface;
assertThat(condition).isTrue();
assertThat(bean).isInstanceOf(AnotherScopeTestInterface.class);
assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
bean.setName(MODIFIED_NAME);
@@ -278,10 +275,8 @@ class ClassPathBeanDefinitionScannerJsr330ScopeIntegrationTests {
// should be a class-based proxy
assertThat(AopUtils.isCglibProxy(bean)).isTrue();
boolean condition1 = bean instanceof ScopedTestBean;
assertThat(condition1).isTrue();
boolean condition = bean instanceof SessionScopedTestBean;
assertThat(condition).isTrue();
assertThat(bean).isInstanceOf(ScopedTestBean.class);
assertThat(bean).isInstanceOf(SessionScopedTestBean.class);
assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
bean.setName(MODIFIED_NAME);
integration-tests/src/test/java/org/springframework/context/annotation/scope/ClassPathBeanDefinitionScannerScopeIntegrationTests.java
+5 -10
View File
@@ -166,8 +166,7 @@ class ClassPathBeanDefinitionScannerScopeIntegrationTests {
// should be dynamic proxy, implementing both interfaces
assertThat(AopUtils.isJdkDynamicProxy(bean)).isTrue();
boolean condition = bean instanceof AnotherScopeTestInterface;
assertThat(condition).isTrue();
assertThat(bean).isInstanceOf(AnotherScopeTestInterface.class);
assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
bean.setName(MODIFIED_NAME);
@@ -188,8 +187,7 @@ class ClassPathBeanDefinitionScannerScopeIntegrationTests {
// should be a class-based proxy
assertThat(AopUtils.isCglibProxy(bean)).isTrue();
boolean condition = bean instanceof RequestScopedTestBean;
assertThat(condition).isTrue();
assertThat(bean).isInstanceOf(RequestScopedTestBean.class);
assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
bean.setName(MODIFIED_NAME);
@@ -231,8 +229,7 @@ class ClassPathBeanDefinitionScannerScopeIntegrationTests {
// should be dynamic proxy, implementing both interfaces
assertThat(AopUtils.isJdkDynamicProxy(bean)).isTrue();
boolean condition = bean instanceof AnotherScopeTestInterface;
assertThat(condition).isTrue();
assertThat(bean).isInstanceOf(AnotherScopeTestInterface.class);
assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
bean.setName(MODIFIED_NAME);
@@ -259,10 +256,8 @@ class ClassPathBeanDefinitionScannerScopeIntegrationTests {
// should be a class-based proxy
assertThat(AopUtils.isCglibProxy(bean)).isTrue();
boolean condition1 = bean instanceof ScopedTestBean;
assertThat(condition1).isTrue();
boolean condition = bean instanceof SessionScopedTestBean;
assertThat(condition).isTrue();
assertThat(bean).isInstanceOf(ScopedTestBean.class);
assertThat(bean).isInstanceOf(SessionScopedTestBean.class);
assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
bean.setName(MODIFIED_NAME);
spring-aop/src/test/java/org/springframework/aop/aspectj/MethodInvocationProceedingJoinPointTests.java
+2 -3
View File
@@ -17,7 +17,6 @@
package org.springframework.aop.aspectj;
import java.io.IOException;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicInteger;
import org.aspectj.lang.JoinPoint;
@@ -106,9 +105,9 @@ class MethodInvocationProceedingJoinPointTests {
assertThat(AbstractAspectJAdvice.currentJoinPoint().getSignature()).as("Return same MethodSignature repeatedly").isSameAs(msig);
assertThat(AbstractAspectJAdvice.currentJoinPoint()).as("Return same JoinPoint repeatedly").isSameAs(AbstractAspectJAdvice.currentJoinPoint());
assertThat(msig.getDeclaringType()).isEqualTo(method.getDeclaringClass());
assertThat(Arrays.equals(method.getParameterTypes(), msig.getParameterTypes())).isTrue();
assertThat(method.getParameterTypes()).isEqualTo(msig.getParameterTypes());
assertThat(msig.getReturnType()).isEqualTo(method.getReturnType());
assertThat(Arrays.equals(method.getExceptionTypes(), msig.getExceptionTypes())).isTrue();
assertThat(method.getExceptionTypes()).isEqualTo(msig.getExceptionTypes());
msig.toLongString();
msig.toShortString();
});
spring-aop/src/test/java/org/springframework/aop/aspectj/annotation/AspectJPointcutAdvisorTests.java
+1 -2
View File
@@ -63,8 +63,7 @@ class AspectJPointcutAdvisorTests {
1, "someBean");
assertThat(ajpa.getAspectMetadata().getPerClausePointcut()).isNotSameAs(Pointcut.TRUE);
boolean condition = ajpa.getAspectMetadata().getPerClausePointcut() instanceof AspectJExpressionPointcut;
assertThat(condition).isTrue();
assertThat(ajpa.getAspectMetadata().getPerClausePointcut()).isInstanceOf(AspectJExpressionPointcut.class);
assertThat(ajpa.isPerInstance()).isTrue();
assertThat(ajpa.getAspectMetadata().getPerClausePointcut().getClassFilter().matches(TestBean.class)).isTrue();
spring-aop/src/test/java/org/springframework/aop/interceptor/ExposeBeanNameAdvisorsTests.java
+2 -4
View File
@@ -54,8 +54,7 @@ class ExposeBeanNameAdvisorsTests {
pf.addAdvisor(ExposeBeanNameAdvisors.createAdvisorWithoutIntroduction(beanName));
ITestBean proxy = (ITestBean) pf.getProxy();
boolean condition = proxy instanceof NamedBean;
assertThat(condition).as("No introduction").isFalse();
assertThat(proxy).as("No introduction").isNotInstanceOf(NamedBean.class);
// Requires binding
proxy.getAge();
}
@@ -69,8 +68,7 @@ class ExposeBeanNameAdvisorsTests {
pf.addAdvisor(ExposeBeanNameAdvisors.createAdvisorIntroducingNamedBean(beanName));
ITestBean proxy = (ITestBean) pf.getProxy();
boolean condition = proxy instanceof NamedBean;
assertThat(condition).as("Introduction was made").isTrue();
assertThat(proxy).as("Introduction was made").isInstanceOf(NamedBean.class);
// Requires binding
proxy.getAge();
spring-aop/src/test/java/org/springframework/aop/target/dynamic/RefreshableTargetSourceTests.java
+2 -2
View File
@@ -95,7 +95,7 @@ class RefreshableTargetSourceTests {
Object d = ts.getTarget();
assertThat(d).as("D should not be null").isNotNull();
assertThat(a.equals(d)).as("A and D should not be equal").isFalse();
assertThat(a).as("A and D should not be equal").isNotEqualTo(d);
Object e = ts.getTarget();
assertThat(e).as("D and E should be equal").isEqualTo(d);
@@ -103,7 +103,7 @@ class RefreshableTargetSourceTests {
Thread.sleep(110);
Object f = ts.getTarget();
assertThat(e.equals(f)).as("E and F should be different").isFalse();
assertThat(e).as("E and F should be different").isNotEqualTo(f);
}
spring-beans/src/test/java/org/springframework/beans/AbstractPropertyAccessorTests.java
+13 -13
View File
@@ -599,11 +599,11 @@ abstract class AbstractPropertyAccessorTests {
AbstractPropertyAccessor accessor = createAccessor(target);
accessor.setPropertyValue("bool2", "true");
assertThat(Boolean.TRUE.equals(accessor.getPropertyValue("bool2"))).as("Correct bool2 value").isTrue();
assertThat(accessor.getPropertyValue("bool2")).as("Correct bool2 value").isEqualTo(Boolean.TRUE);
assertThat(target.getBool2()).as("Correct bool2 value").isTrue();
accessor.setPropertyValue("bool2", "false");
assertThat(Boolean.FALSE.equals(accessor.getPropertyValue("bool2"))).as("Correct bool2 value").isTrue();
assertThat(accessor.getPropertyValue("bool2")).as("Correct bool2 value").isEqualTo(Boolean.FALSE);
assertThat(target.getBool2()).as("Correct bool2 value").isFalse();
}
@@ -628,7 +628,7 @@ abstract class AbstractPropertyAccessorTests {
assertThat(new BigInteger("3")).as("Correct bigInteger value").isEqualTo(target.getBigInteger());
assertThat(Float.valueOf("8.1")).as("Correct float2 value").isEqualTo(accessor.getPropertyValue("float2"));
assertThat(Float.valueOf("8.1")).as("Correct float2 value").isEqualTo(target.getFloat2());
assertThat(Double.valueOf("6.1").equals(accessor.getPropertyValue("double2"))).as("Correct double2 value").isTrue();
assertThat(Double.valueOf("6.1")).as("Correct double2 value").isEqualTo(accessor.getPropertyValue("double2"));
assertThat(Double.valueOf("6.1")).as("Correct double2 value").isEqualTo(target.getDouble2());
assertThat(new BigDecimal("4.0")).as("Correct bigDecimal value").isEqualTo(accessor.getPropertyValue("bigDecimal"));
assertThat(new BigDecimal("4.0")).as("Correct bigDecimal value").isEqualTo(target.getBigDecimal());
@@ -651,7 +651,7 @@ abstract class AbstractPropertyAccessorTests {
assertThat(Integer.valueOf("8")).as("Correct int2 value").isEqualTo(target.getInt2());
assertThat(Long.valueOf("6")).as("Correct long2 value").isEqualTo(accessor.getPropertyValue("long2"));
assertThat(Long.valueOf("6")).as("Correct long2 value").isEqualTo(target.getLong2());
assertThat(new BigInteger("3").equals(accessor.getPropertyValue("bigInteger"))).as("Correct bigInteger value").isTrue();
assertThat(new BigInteger("3")).as("Correct bigInteger value").isEqualTo(accessor.getPropertyValue("bigInteger"));
assertThat(new BigInteger("3")).as("Correct bigInteger value").isEqualTo(target.getBigInteger());
assertThat(Float.valueOf("8.1")).as("Correct float2 value").isEqualTo(accessor.getPropertyValue("float2"));
assertThat(Float.valueOf("8.1")).as("Correct float2 value").isEqualTo(target.getFloat2());
@@ -1495,15 +1495,15 @@ abstract class AbstractPropertyAccessorTests {
accessor.setPropertyValues(pvs);
assertThat(target.getArray()[0]).isEqualTo(tb5);
assertThat(target.getArray()[1]).isEqualTo(tb4);
assertThat((target.getList().get(0))).isEqualTo(tb3);
assertThat((target.getList().get(1))).isEqualTo(tb2);
assertThat((target.getList().get(2))).isEqualTo(tb0);
assertThat((target.getList().get(3))).isNull();
assertThat((target.getList().get(4))).isEqualTo(tb1);
assertThat((target.getMap().get("key1"))).isEqualTo(tb1);
assertThat((target.getMap().get("key2"))).isEqualTo(tb0);
assertThat((target.getMap().get("key5"))).isEqualTo(tb4);
assertThat((target.getMap().get("key9"))).isEqualTo(tb5);
assertThat(target.getList().get(0)).isEqualTo(tb3);
assertThat(target.getList().get(1)).isEqualTo(tb2);
assertThat(target.getList().get(2)).isEqualTo(tb0);
assertThat(target.getList().get(3)).isNull();
assertThat(target.getList().get(4)).isEqualTo(tb1);
assertThat(target.getMap().get("key1")).isEqualTo(tb1);
assertThat(target.getMap().get("key2")).isEqualTo(tb0);
assertThat(target.getMap().get("key5")).isEqualTo(tb4);
assertThat(target.getMap().get("key9")).isEqualTo(tb5);
assertThat(accessor.getPropertyValue("array[0]")).isEqualTo(tb5);
assertThat(accessor.getPropertyValue("array[1]")).isEqualTo(tb4);
assertThat(accessor.getPropertyValue("list[0]")).isEqualTo(tb3);
spring-beans/src/test/java/org/springframework/beans/BeanWrapperTests.java
+2 -2
View File
@@ -264,7 +264,7 @@ class BeanWrapperTests extends AbstractPropertyAccessorTests {
accessor.setPropertyValue("object", tb);
assertThat(target.value).isSameAs(tb);
assertThat(target.getObject()).containsSame(tb);
assertThat(((Optional<TestBean>) accessor.getPropertyValue("object"))).containsSame(tb);
assertThat((Optional<TestBean>) accessor.getPropertyValue("object")).containsSame(tb);
assertThat(target.value.getName()).isEqualTo("x");
assertThat(target.getObject().get().getName()).isEqualTo("x");
assertThat(accessor.getPropertyValue("object.name")).isEqualTo("x");
@@ -272,7 +272,7 @@ class BeanWrapperTests extends AbstractPropertyAccessorTests {
accessor.setPropertyValue("object.name", "y");
assertThat(target.value).isSameAs(tb);
assertThat(target.getObject()).containsSame(tb);
assertThat(((Optional<TestBean>) accessor.getPropertyValue("object"))).containsSame(tb);
assertThat((Optional<TestBean>) accessor.getPropertyValue("object")).containsSame(tb);
assertThat(target.value.getName()).isEqualTo("y");
assertThat(target.getObject().get().getName()).isEqualTo("y");
assertThat(accessor.getPropertyValue("object.name")).isEqualTo("y");
spring-beans/src/test/java/org/springframework/beans/factory/BeanFactoryUtilsTests.java
+3 -3
View File
@@ -307,19 +307,19 @@ class BeanFactoryUtilsTests {
@Test
void bDependencies() {
String[] deps = this.dependentBeansFactory.getDependentBeans("b");
assertThat(Arrays.equals(new String[] { "c" }, deps)).isTrue();
assertThat(deps).containsExactly("c");
}
@Test
void cDependencies() {
String[] deps = this.dependentBeansFactory.getDependentBeans("c");
assertThat(Arrays.equals(new String[] { "int", "long" }, deps)).isTrue();
assertThat(deps).containsExactly("int", "long");
}
@Test
void intDependencies() {
String[] deps = this.dependentBeansFactory.getDependentBeans("int");
assertThat(Arrays.equals(new String[] { "buffer" }, deps)).isTrue();
assertThat(deps).containsExactly("buffer");
}
@Test
spring-beans/src/test/java/org/springframework/beans/factory/DefaultListableBeanFactoryTests.java
+2 -2
View File
@@ -516,11 +516,11 @@ class DefaultListableBeanFactoryTests {
String[] names = lbf.getBeanDefinitionNames();
assertThat(names != lbf.getBeanDefinitionNames()).isTrue();
assertThat(names.length == 1).as("Array length == 1").isTrue();
assertThat(names[0].equals("test")).as("0th element == test").isTrue();
assertThat(names[0]).as("0th element == test").isEqualTo("test");
TestBean tb = (TestBean) lbf.getBean("test");
assertThat(tb != null).as("Test is non null").isTrue();
assertThat("Tony".equals(tb.getName())).as("Test bean name is Tony").isTrue();
assertThat("Tony").as("Test bean name is Tony").isEqualTo(tb.getName());
assertThat(tb.getAge() == 48).as("Test bean age is 48").isTrue();
}
spring-beans/src/test/java/org/springframework/beans/factory/config/MethodInvokingFactoryBeanTests.java
+1 -1
View File
@@ -98,7 +98,7 @@ class MethodInvokingFactoryBeanTests {
mcfb.setTargetObject(tc1);
mcfb.setTargetMethod("method1");
mcfb.afterPropertiesSet();
assertThat(int.class.equals(mcfb.getObjectType())).isTrue();
assertThat(int.class).isEqualTo(mcfb.getObjectType());
mcfb = new MethodInvokingFactoryBean();
mcfb.setTargetClass(TestClass1.class);
spring-beans/src/test/java/org/springframework/beans/factory/config/YamlMapFactoryBeanTests.java
+1 -1
View File
@@ -71,7 +71,7 @@ class YamlMapFactoryBeanTests {
new ByteArrayResource("foo:\n spam: bar".getBytes()));
assertThat(this.factory.getObject()).hasSize(1);
assertThat(((Map<String, Object>) this.factory.getObject().get("foo"))).hasSize(2);
assertThat((Map<String, Object>) this.factory.getObject().get("foo")).hasSize(2);
}
@Test
spring-beans/src/test/java/org/springframework/beans/factory/support/BeanDefinitionBuilderTests.java
+1 -2
View File
@@ -16,7 +16,6 @@
package org.springframework.beans.factory.support;
import java.util.Arrays;
import java.util.function.Function;
import org.junit.jupiter.api.Test;
@@ -48,7 +47,7 @@ class BeanDefinitionBuilderTests {
RootBeanDefinition rbd = (RootBeanDefinition) bdb.getBeanDefinition();
assertThat(rbd.isSingleton()).isFalse();
assertThat(rbd.getBeanClass()).isEqualTo(TestBean.class);
assertThat(Arrays.equals(dependsOn, rbd.getDependsOn())).as("Depends on was added").isTrue();
assertThat(rbd.getDependsOn()).as("Depends on was added").isEqualTo(dependsOn);
assertThat(rbd.getPropertyValues().contains("age")).isTrue();
}
spring-beans/src/test/java/org/springframework/beans/factory/xml/CollectionsWithDefaultTypesTests.java
+1 -1
View File
@@ -83,7 +83,7 @@ class CollectionsWithDefaultTypesTests {
MixedCollectionBean jumble = (MixedCollectionBean) this.beanFactory.getBean("jumble");
assertThat(jumble.getJumble()).as("Expected 3 elements, not " + jumble.getJumble().size()).hasSize(3);
List l = (List) jumble.getJumble();
assertThat(l.get(0).equals("literal")).isTrue();
assertThat(l.get(0)).isEqualTo("literal");
Integer[] array1 = (Integer[]) l.get(1);
assertThat(array1[0]).isEqualTo(2);
assertThat(array1[1]).isEqualTo(4);
spring-beans/src/test/java/org/springframework/beans/factory/xml/UtilNamespaceHandlerTests.java
+1 -2
View File
@@ -17,7 +17,6 @@
package org.springframework.beans.factory.xml;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
@@ -213,7 +212,7 @@ class UtilNamespaceHandlerTests {
assertThat(bean.getSomeSet()).singleElement().isEqualTo("bar");
TestBean bean2 = (TestBean) this.beanFactory.getBean("nestedShortcutCollections");
assertThat(Arrays.equals(bean.getStringArray(), bean2.getStringArray())).isTrue();
assertThat(bean.getStringArray()).isEqualTo(bean2.getStringArray());
assertThat(bean.getStringArray()).isNotSameAs(bean2.getStringArray());
assertThat(bean2.getSomeList()).isEqualTo(bean.getSomeList());
assertThat(bean2.getSomeSet()).isEqualTo(bean.getSomeSet());
spring-beans/src/test/java/org/springframework/beans/factory/xml/XmlBeanCollectionTests.java
+27 -27
View File
@@ -162,13 +162,13 @@ class XmlBeanCollectionTests {
MixedCollectionBean jumble = (MixedCollectionBean) this.beanFactory.getBean("jumble");
assertThat(jumble.getJumble()).as("Expected 5 elements, not " + jumble.getJumble()).hasSize(5);
List l = (List) jumble.getJumble();
assertThat(l.get(0).equals(this.beanFactory.getBean("david"))).isTrue();
assertThat(l.get(1).equals("literal")).isTrue();
assertThat(l.get(2).equals(this.beanFactory.getBean("jenny"))).isTrue();
assertThat(l.get(3).equals("rod")).isTrue();
assertThat(l.get(0)).isEqualTo(this.beanFactory.getBean("david"));
assertThat(l.get(1)).isEqualTo("literal");
assertThat(l.get(2)).isEqualTo(this.beanFactory.getBean("jenny"));
assertThat(l.get(3)).isEqualTo("rod");
Object[] array = (Object[]) l.get(4);
assertThat(array[0].equals(this.beanFactory.getBean("david"))).isTrue();
assertThat(array[1].equals("literal2")).isTrue();
assertThat(array[0]).isEqualTo(this.beanFactory.getBean("david"));
assertThat(array[1]).isEqualTo("literal2");
}
@Test
@@ -189,8 +189,8 @@ class XmlBeanCollectionTests {
void mapWithLiteralsOnly() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("literalMap");
assertThat(hasMap.getMap()).hasSize(3);
assertThat(hasMap.getMap().get("foo").equals("bar")).isTrue();
assertThat(hasMap.getMap().get("fi").equals("fum")).isTrue();
assertThat(hasMap.getMap().get("foo")).isEqualTo("bar");
assertThat(hasMap.getMap().get("fi")).isEqualTo("fum");
assertThat(hasMap.getMap().get("fa")).isNull();
}
@@ -201,7 +201,7 @@ class XmlBeanCollectionTests {
assertThat(hasMap.getMap().get("foo")).isEqualTo(10);
TestBean jenny = (TestBean) this.beanFactory.getBean("jenny");
assertThat(hasMap.getMap().get("jenny")).isSameAs(jenny);
assertThat(hasMap.getMap().get(5).equals("david")).isTrue();
assertThat(hasMap.getMap().get(5)).isEqualTo("david");
assertThat(hasMap.getMap().get("bar")).isInstanceOf(Long.class);
assertThat(hasMap.getMap().get("bar")).isEqualTo(100L);
assertThat(hasMap.getMap().get("baz")).isInstanceOf(Integer.class);
@@ -213,13 +213,13 @@ class XmlBeanCollectionTests {
TestBean jenny = (TestBean) this.beanFactory.getBean("pJenny");
HasMap hasMap = (HasMap) this.beanFactory.getBean("pMixedMap");
assertThat(hasMap.getMap()).hasSize(2);
assertThat(hasMap.getMap().get("foo").equals("bar")).isTrue();
assertThat(hasMap.getMap().get("foo")).isEqualTo("bar");
assertThat(hasMap.getMap().get("jenny").toString()).isEqualTo(jenny.toString());
assertThat(hasMap.getMap().get("jenny")).as("Not same instance").isNotSameAs(jenny);
HasMap hasMap2 = (HasMap) this.beanFactory.getBean("pMixedMap");
assertThat(hasMap2.getMap()).hasSize(2);
assertThat(hasMap2.getMap().get("foo").equals("bar")).isTrue();
assertThat(hasMap2.getMap().get("foo")).isEqualTo("bar");
assertThat(hasMap2.getMap().get("jenny").toString()).isEqualTo(jenny.toString());
assertThat(hasMap2.getMap().get("jenny")).as("Not same instance").isNotSameAs(hasMap.getMap().get("jenny"));
}
@@ -228,7 +228,7 @@ class XmlBeanCollectionTests {
void mapWithLiteralsReferencesAndList() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("mixedMapWithList");
assertThat(hasMap.getMap()).hasSize(4);
assertThat(hasMap.getMap().get(null).equals("bar")).isTrue();
assertThat(hasMap.getMap().get(null)).isEqualTo("bar");
TestBean jenny = (TestBean) this.beanFactory.getBean("jenny");
assertThat(hasMap.getMap().get("jenny")).isEqualTo(jenny);
@@ -236,29 +236,29 @@ class XmlBeanCollectionTests {
List l = (List) hasMap.getMap().get("list");
assertThat(l).isNotNull();
assertThat(l).hasSize(4);
assertThat(l.get(0).equals("zero")).isTrue();
assertThat(l.get(0)).isEqualTo("zero");
assertThat(l).element(3).isNull();
// Check nested map in list
Map m = (Map) l.get(1);
assertThat(m).isNotNull();
assertThat(m).hasSize(2);
assertThat(m.get("fo").equals("bar")).isTrue();
assertThat(m.get("jen").equals(jenny)).as("Map element 'jenny' should be equal to jenny bean, not " + m.get("jen")).isTrue();
assertThat(m.get("fo")).isEqualTo("bar");
assertThat(m.get("jen")).as("Map element 'jenny' should be equal to jenny bean, not " + m.get("jen")).isEqualTo(jenny);
// Check nested list in list
l = (List) l.get(2);
assertThat(l).isNotNull();
assertThat(l).hasSize(2);
assertThat(l.get(0)).isEqualTo(jenny);
assertThat(l.get(1).equals("ba")).isTrue();
assertThat(l.get(1)).isEqualTo("ba");
// Check nested map
m = (Map) hasMap.getMap().get("map");
assertThat(m).isNotNull();
assertThat(m).hasSize(2);
assertThat(m.get("foo").equals("bar")).isTrue();
assertThat(m.get("jenny").equals(jenny)).as("Map element 'jenny' should be equal to jenny bean, not " + m.get("jenny")).isTrue();
assertThat(m.get("foo")).isEqualTo("bar");
assertThat(m.get("jenny")).as("Map element 'jenny' should be equal to jenny bean, not " + m.get("jenny")).isEqualTo(jenny);
}
@Test
@@ -311,16 +311,16 @@ class XmlBeanCollectionTests {
void populatedProps() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("props");
assertThat(hasMap.getProps()).hasSize(2);
assertThat(hasMap.getProps().get("foo").equals("bar")).isTrue();
assertThat(hasMap.getProps().get("2").equals("TWO")).isTrue();
assertThat(hasMap.getProps().get("foo")).isEqualTo("bar");
assertThat(hasMap.getProps().get("2")).isEqualTo("TWO");
}
@Test
void objectArray() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("objectArray");
assertThat(hasMap.getObjectArray().length).isEqualTo(2);
assertThat(hasMap.getObjectArray()[0].equals("one")).isTrue();
assertThat(hasMap.getObjectArray()[1].equals(this.beanFactory.getBean("jenny"))).isTrue();
assertThat(hasMap.getObjectArray()[0]).isEqualTo("one");
assertThat(hasMap.getObjectArray()[1]).isEqualTo(this.beanFactory.getBean("jenny"));
}
@Test
@@ -336,16 +336,16 @@ class XmlBeanCollectionTests {
void classArray() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("classArray");
assertThat(hasMap.getClassArray().length).isEqualTo(2);
assertThat(hasMap.getClassArray()[0].equals(String.class)).isTrue();
assertThat(hasMap.getClassArray()[1].equals(Exception.class)).isTrue();
assertThat(hasMap.getClassArray()[0]).isEqualTo(String.class);
assertThat(hasMap.getClassArray()[1]).isEqualTo(Exception.class);
}
@Test
void classList() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("classList");
assertThat(hasMap.getClassList()).hasSize(2);
assertThat(hasMap.getClassList().get(0).equals(String.class)).isTrue();
assertThat(hasMap.getClassList().get(1).equals(Exception.class)).isTrue();
assertThat(hasMap.getClassList().get(0)).isEqualTo(String.class);
assertThat(hasMap.getClassList().get(1)).isEqualTo(Exception.class);
}
@Test
@@ -402,7 +402,7 @@ class XmlBeanCollectionTests {
@Test
void choiceBetweenSetAndMap() {
MapAndSet sam = (MapAndSet) this.beanFactory.getBean("setAndMap");
assertThat(sam.getObject() instanceof Map).as("Didn't choose constructor with Map argument").isTrue();
assertThat(sam.getObject()).as("Didn't choose constructor with Map argument").isInstanceOf(Map.class);
Map map = (Map) sam.getObject();
assertThat(map).containsOnly(entry("key1", "val1"), entry("key2", "val2"), entry("key3", "val3"));
}
spring-beans/src/test/java/org/springframework/beans/propertyeditors/CustomEditorTests.java
+9 -9
View File
@@ -187,11 +187,11 @@ class CustomEditorTests {
BeanWrapper bw = new BeanWrapperImpl(tb);
bw.setPropertyValue("bool1", "true");
assertThat(Boolean.TRUE.equals(bw.getPropertyValue("bool1"))).as("Correct bool1 value").isTrue();
assertThat(bw.getPropertyValue("bool1")).as("Correct bool1 value").isEqualTo(Boolean.TRUE);
assertThat(tb.isBool1()).as("Correct bool1 value").isTrue();
bw.setPropertyValue("bool1", "false");
assertThat(Boolean.FALSE.equals(bw.getPropertyValue("bool1"))).as("Correct bool1 value").isTrue();
assertThat(bw.getPropertyValue("bool1")).as("Correct bool1 value").isEqualTo(Boolean.FALSE);
assertThat(tb.isBool1()).as("Correct bool1 value").isFalse();
bw.setPropertyValue("bool1", " true ");
@@ -228,11 +228,11 @@ class CustomEditorTests {
BeanWrapper bw = new BeanWrapperImpl(tb);
bw.setPropertyValue("bool2", "true");
assertThat(Boolean.TRUE.equals(bw.getPropertyValue("bool2"))).as("Correct bool2 value").isTrue();
assertThat(bw.getPropertyValue("bool2")).as("Correct bool2 value").isEqualTo(Boolean.TRUE);
assertThat(tb.getBool2().booleanValue()).as("Correct bool2 value").isTrue();
bw.setPropertyValue("bool2", "false");
assertThat(Boolean.FALSE.equals(bw.getPropertyValue("bool2"))).as("Correct bool2 value").isTrue();
assertThat(bw.getPropertyValue("bool2")).as("Correct bool2 value").isEqualTo(Boolean.FALSE);
assertThat(tb.getBool2()).as("Correct bool2 value").isFalse();
bw.setPropertyValue("bool2", "on");
@@ -264,11 +264,11 @@ class CustomEditorTests {
bw.registerCustomEditor(Boolean.class, new CustomBooleanEditor(true));
bw.setPropertyValue("bool2", "true");
assertThat(Boolean.TRUE.equals(bw.getPropertyValue("bool2"))).as("Correct bool2 value").isTrue();
assertThat(bw.getPropertyValue("bool2")).as("Correct bool2 value").isEqualTo(Boolean.TRUE);
assertThat(tb.getBool2().booleanValue()).as("Correct bool2 value").isTrue();
bw.setPropertyValue("bool2", "false");
assertThat(Boolean.FALSE.equals(bw.getPropertyValue("bool2"))).as("Correct bool2 value").isTrue();
assertThat(bw.getPropertyValue("bool2")).as("Correct bool2 value").isEqualTo(Boolean.FALSE);
assertThat(tb.getBool2()).as("Correct bool2 value").isFalse();
bw.setPropertyValue("bool2", "on");
@@ -429,10 +429,10 @@ class CustomEditorTests {
bw.setPropertyValue("long1", "5");
bw.setPropertyValue("long2", "6");
assertThat(Long.valueOf("5").equals(bw.getPropertyValue("long1"))).as("Correct long1 value").isTrue();
assertThat(Long.valueOf("5")).as("Correct long1 value").isEqualTo(bw.getPropertyValue("long1"));
assertThat(tb.getLong1()).as("Correct long1 value").isEqualTo(5);
assertThat(Long.valueOf("6").equals(bw.getPropertyValue("long2"))).as("Correct long2 value").isTrue();
assertThat(Long.valueOf("6").equals(tb.getLong2())).as("Correct long2 value").isTrue();
assertThat(Long.valueOf("6")).as("Correct long2 value").isEqualTo(bw.getPropertyValue("long2"));
assertThat(Long.valueOf("6")).as("Correct long2 value").isEqualTo(tb.getLong2());
bw.setPropertyValue("long2", "");
assertThat(bw.getPropertyValue("long2")).as("Correct long2 value").isNull();
spring-beans/src/test/java/org/springframework/beans/propertyeditors/PropertiesEditorTests.java
+13 -13
View File
@@ -42,7 +42,7 @@ class PropertiesEditorTests {
pe.setAsText(s);
Properties p = (Properties) pe.getValue();
assertThat(p.entrySet().size()).as("contains one entry").isEqualTo(1);
assertThat(p.get("foo").equals("bar")).as("foo=bar").isTrue();
assertThat(p.get("foo")).as("foo=bar").isEqualTo("bar");
}
@Test
@@ -53,8 +53,8 @@ class PropertiesEditorTests {
pe.setAsText(s);
Properties p = (Properties) pe.getValue();
assertThat(p.entrySet().size()).as("contains two entries").isEqualTo(2);
assertThat(p.get("foo").equals("bar with whitespace")).as("foo=bar with whitespace").isTrue();
assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
assertThat(p.get("foo")).as("foo=bar with whitespace").isEqualTo("bar with whitespace");
assertThat(p.get("me")).as("me=mi").isEqualTo("mi");
}
@Test
@@ -67,9 +67,9 @@ class PropertiesEditorTests {
pe.setAsText(s);
Properties p = (Properties) pe.getValue();
assertThat(p.entrySet().size()).as("contains two entries").isEqualTo(3);
assertThat(p.get("foo").equals("bar")).as("foo=bar").isTrue();
assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
assertThat(p.get("x").equals("y=z")).as("x='y=z'").isTrue();
assertThat(p.get("foo")).as("foo=bar").isEqualTo("bar");
assertThat(p.get("me")).as("me=mi").isEqualTo("mi");
assertThat(p.get("x")).as("x='y=z'").isEqualTo("y=z");
}
@Test
@@ -79,9 +79,9 @@ class PropertiesEditorTests {
pe.setAsText(s);
Properties p = (Properties) pe.getValue();
assertThat(p.entrySet().size()).as("contains two entries").isEqualTo(3);
assertThat(p.get("foo").equals("bar")).as("foo=bar").isTrue();
assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
assertThat(p.get("x").equals("")).as("x='y=z'").isTrue();
assertThat(p.get("foo")).as("foo=bar").isEqualTo("bar");
assertThat(p.get("me")).as("me=mi").isEqualTo("mi");
assertThat(p.get("x")).as("x='y=z'").isEqualTo("");
}
@Test
@@ -91,8 +91,8 @@ class PropertiesEditorTests {
pe.setAsText(s);
Properties p = (Properties) pe.getValue();
assertThat(p.entrySet().size()).as("contains three entries").isEqualTo(3);
assertThat(p.get("foo").equals("")).as("foo is empty").isTrue();
assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
assertThat(p.get("foo")).as("foo is empty").isEqualTo("");
assertThat(p.get("me")).as("me=mi").isEqualTo("mi");
}
/**
@@ -112,8 +112,8 @@ class PropertiesEditorTests {
pe.setAsText(s);
Properties p = (Properties) pe.getValue();
assertThat(p.entrySet().size()).as("contains three entries").isEqualTo(3);
assertThat(p.get("foo").equals("bar")).as("foo is bar").isTrue();
assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
assertThat(p.get("foo")).as("foo is bar").isEqualTo("bar");
assertThat(p.get("me")).as("me=mi").isEqualTo("mi");
}
/**
spring-beans/src/test/java/org/springframework/beans/propertyeditors/ResourceBundleEditorTests.java
+5 -5
View File
@@ -42,7 +42,7 @@ class ResourceBundleEditorTests {
editor.setAsText(BASE_NAME);
Object value = editor.getValue();
assertThat(value).as("Returned ResourceBundle was null (must not be for valid setAsText(..) call).").isNotNull();
assertThat(value instanceof ResourceBundle).as("Returned object was not a ResourceBundle (must be for valid setAsText(..) call).").isTrue();
assertThat(value).as("Returned object was not a ResourceBundle (must be for valid setAsText(..) call).").isInstanceOf(ResourceBundle.class);
ResourceBundle bundle = (ResourceBundle) value;
String string = bundle.getString(MESSAGE_KEY);
assertThat(string).isEqualTo(MESSAGE_KEY);
@@ -54,7 +54,7 @@ class ResourceBundleEditorTests {
editor.setAsText(BASE_NAME + "_");
Object value = editor.getValue();
assertThat(value).as("Returned ResourceBundle was null (must not be for valid setAsText(..) call).").isNotNull();
assertThat(value instanceof ResourceBundle).as("Returned object was not a ResourceBundle (must be for valid setAsText(..) call).").isTrue();
assertThat(value).as("Returned object was not a ResourceBundle (must be for valid setAsText(..) call).").isInstanceOf(ResourceBundle.class);
ResourceBundle bundle = (ResourceBundle) value;
String string = bundle.getString(MESSAGE_KEY);
assertThat(string).isEqualTo(MESSAGE_KEY);
@@ -66,7 +66,7 @@ class ResourceBundleEditorTests {
editor.setAsText(BASE_NAME + "Lang" + "_en");
Object value = editor.getValue();
assertThat(value).as("Returned ResourceBundle was null (must not be for valid setAsText(..) call).").isNotNull();
assertThat(value instanceof ResourceBundle).as("Returned object was not a ResourceBundle (must be for valid setAsText(..) call).").isTrue();
assertThat(value).as("Returned object was not a ResourceBundle (must be for valid setAsText(..) call).").isInstanceOf(ResourceBundle.class);
ResourceBundle bundle = (ResourceBundle) value;
String string = bundle.getString(MESSAGE_KEY);
assertThat(string).isEqualTo("yob");
@@ -78,7 +78,7 @@ class ResourceBundleEditorTests {
editor.setAsText(BASE_NAME + "LangCountry" + "_en_GB");
Object value = editor.getValue();
assertThat(value).as("Returned ResourceBundle was null (must not be for valid setAsText(..) call).").isNotNull();
assertThat(value instanceof ResourceBundle).as("Returned object was not a ResourceBundle (must be for valid setAsText(..) call).").isTrue();
assertThat(value).as("Returned object was not a ResourceBundle (must be for valid setAsText(..) call).").isInstanceOf(ResourceBundle.class);
ResourceBundle bundle = (ResourceBundle) value;
String string = bundle.getString(MESSAGE_KEY);
assertThat(string).isEqualTo("chav");
@@ -90,7 +90,7 @@ class ResourceBundleEditorTests {
editor.setAsText(BASE_NAME + "LangCountryDialect" + "_en_GB_GLASGOW");
Object value = editor.getValue();
assertThat(value).as("Returned ResourceBundle was null (must not be for valid setAsText(..) call).").isNotNull();
assertThat(value instanceof ResourceBundle).as("Returned object was not a ResourceBundle (must be for valid setAsText(..) call).").isTrue();
assertThat(value).as("Returned object was not a ResourceBundle (must be for valid setAsText(..) call).").isInstanceOf(ResourceBundle.class);
ResourceBundle bundle = (ResourceBundle) value;
String string = bundle.getString(MESSAGE_KEY);
assertThat(string).isEqualTo("ned");
spring-beans/src/testFixtures/java/org/springframework/beans/testfixture/factory/xml/AbstractBeanFactoryTests.java
+8 -10
View File
@@ -56,9 +56,9 @@ public abstract class AbstractBeanFactoryTests {
TestBean rod = (TestBean) getBeanFactory().getBean("rod");
TestBean roderick = (TestBean) getBeanFactory().getBean("roderick");
assertThat(rod).as("not == ").isNotSameAs(roderick);
assertThat(rod.getName().equals("Rod")).as("rod.name is Rod").isTrue();
assertThat(rod.getName()).as("rod.name is Rod").isEqualTo("Rod");
assertThat(rod.getAge()).as("rod.age is 31").isEqualTo(31);
assertThat(roderick.getName().equals("Roderick")).as("roderick.name is Roderick").isTrue();
assertThat(roderick.getName()).as("roderick.name is Roderick").isEqualTo("Roderick");
assertThat(roderick.getAge()).as("roderick.age was inherited").isEqualTo(rod.getAge());
}
@@ -90,15 +90,14 @@ public abstract class AbstractBeanFactoryTests {
// The dummy business method will throw an exception if the
// necessary callbacks weren't invoked in the right order.
lb.businessMethod();
boolean condition = !lb.isDestroyed();
assertThat(condition).as("Not destroyed").isTrue();
assertThat(lb.isDestroyed()).as("Not destroyed").isFalse();
}
@Test
protected void findsValidInstance() {
Object o = getBeanFactory().getBean("rod");
assertThat(o).isInstanceOfSatisfying(TestBean.class, rod -> {
assertThat(rod.getName().equals("Rod")).as("rod.name is Rod").isTrue();
assertThat(rod.getName()).as("rod.name is Rod").isEqualTo("Rod");
assertThat(rod.getAge()).as("rod.age is 31").isEqualTo(31);
});
}
@@ -156,13 +155,12 @@ public abstract class AbstractBeanFactoryTests {
TestBean tb1 = (TestBean) getBeanFactory().getBean("kathy");
TestBean tb2 = (TestBean) getBeanFactory().getBean("kathy");
assertThat(tb1).as("ref equal DOES NOT apply").isNotSameAs(tb2);
assertThat(tb1.equals(tb2)).as("object equal true").isTrue();
assertThat(tb1).as("object equal true").isEqualTo(tb2);
tb1.setAge(1);
tb2.setAge(2);
assertThat(tb1.getAge()).as("1 age independent = 1").isEqualTo(1);
assertThat(tb2.getAge()).as("2 age independent = 2").isEqualTo(2);
boolean condition = !tb1.equals(tb2);
assertThat(condition).as("object equal now false").isTrue();
assertThat(tb1).as("object equal now false").isNotEqualTo(tb2);
}
@Test
@@ -192,7 +190,7 @@ public abstract class AbstractBeanFactoryTests {
@Test
protected void grandparentDefinitionFoundInBeanFactory() {
TestBean dad = (TestBean) getBeanFactory().getBean("father");
assertThat(dad.getName().equals("Albert")).as("Dad has correct name").isTrue();
assertThat(dad.getName()).as("Dad has correct name").isEqualTo("Albert");
}
@Test
@@ -200,7 +198,7 @@ public abstract class AbstractBeanFactoryTests {
assertThat(getBeanFactory().isSingleton("&singletonFactory")).isTrue();
assertThat(getBeanFactory().isSingleton("singletonFactory")).isTrue();
TestBean tb = (TestBean) getBeanFactory().getBean("singletonFactory");
assertThat(tb.getName().equals(DummyFactory.SINGLETON_NAME)).as("Singleton from factory has correct name, not " + tb.getName()).isTrue();
assertThat(tb.getName()).as("Singleton from factory has correct name, not " + tb.getName()).isEqualTo(DummyFactory.SINGLETON_NAME);
DummyFactory factory = (DummyFactory) getBeanFactory().getBean("&singletonFactory");
TestBean tb2 = (TestBean) getBeanFactory().getBean("singletonFactory");
assertThat(tb).as("Singleton references ==").isSameAs(tb2);
spring-context-support/src/test/java/org/springframework/mail/SimpleMailMessageTests.java
+2 -4
View File
@@ -133,12 +133,10 @@ class SimpleMailMessageTests {
// Null object is not equal
message1 = new SimpleMailMessage();
message2 = null;
boolean condition1 = !(message1.equals(message2));
assertThat(condition1).isTrue();
assertThat(message1).isNotEqualTo(message2);
// Different class is not equal
boolean condition = !(message1.equals(new Object()));
assertThat(condition).isTrue();
assertThat(message1).isNotEqualTo(new Object());
// Equal values are equal
message1 = new SimpleMailMessage();
spring-context/src/test/java/org/springframework/aop/aspectj/BeanNamePointcutAtAspectTests.java
+3 -6
View File
@@ -66,8 +66,7 @@ class BeanNamePointcutAtAspectTests {
@Test
void matchingBeanName() {
boolean condition = testBean1 instanceof Advised;
assertThat(condition).as("Expected a proxy").isTrue();
assertThat(testBean1).as("Expected a proxy").isInstanceOf(Advised.class);
// Call two methods to test for SPR-3953-like condition
testBean1.setAge(20);
@@ -77,8 +76,7 @@ class BeanNamePointcutAtAspectTests {
@Test
void nonMatchingBeanName() {
boolean condition = testBean3 instanceof Advised;
assertThat(condition).as("Didn't expect a proxy").isFalse();
assertThat(testBean3).as("Didn't expect a proxy").isNotInstanceOf(Advised.class);
testBean3.setAge(20);
assertThat(counterAspect.count).isEqualTo(0);
@@ -96,8 +94,7 @@ class BeanNamePointcutAtAspectTests {
ITestBean proxyTestBean = factory.getProxy();
boolean condition = proxyTestBean instanceof Advised;
assertThat(condition).as("Expected a proxy").isTrue();
assertThat(proxyTestBean).as("Expected a proxy").isInstanceOf(Advised.class);
proxyTestBean.setAge(20);
assertThat(myCounterAspect.count).as("Programmatically created proxy shouldn't match bean()").isEqualTo(0);
}
spring-context/src/test/java/org/springframework/aop/aspectj/BeanNamePointcutTests.java
+9 -18
View File
@@ -75,8 +75,7 @@ class BeanNamePointcutTests {
@Test
void matchingBeanName() {
boolean condition = this.testBean1 instanceof Advised;
assertThat(condition).as("Matching bean must be advised (proxied)").isTrue();
assertThat(this.testBean1).as("Matching bean must be advised (proxied)").isInstanceOf(Advised.class);
// Call two methods to test for SPR-3953-like condition
this.testBean1.setAge(20);
this.testBean1.setName("");
@@ -85,37 +84,31 @@ class BeanNamePointcutTests {
@Test
void nonMatchingBeanName() {
boolean condition = this.testBean2 instanceof Advised;
assertThat(condition).as("Non-matching bean must *not* be advised (proxied)").isFalse();
assertThat(this.testBean2).as("Non-matching bean must *not* be advised (proxied)").isNotInstanceOf(Advised.class);
this.testBean2.setAge(20);
assertThat(this.counterAspect.getCount()).as("Advice must *not* have been executed").isEqualTo(0);
}
@Test
void nonMatchingNestedBeanName() {
boolean condition = this.testBeanContainingNestedBean.getDoctor() instanceof Advised;
assertThat(condition).as("Non-matching bean must *not* be advised (proxied)").isFalse();
assertThat(this.testBeanContainingNestedBean.getDoctor()).as("Non-matching bean must *not* be advised (proxied)").isNotInstanceOf(Advised.class);
}
@Test
void matchingFactoryBeanObject() {
boolean condition1 = this.testFactoryBean1 instanceof Advised;
assertThat(condition1).as("Matching bean must be advised (proxied)").isTrue();
assertThat(this.testFactoryBean1).as("Matching bean must be advised (proxied)").isInstanceOf(Advised.class);
assertThat(this.testFactoryBean1.get("myKey")).isEqualTo("myValue");
assertThat(this.testFactoryBean1.get("myKey")).isEqualTo("myValue");
assertThat(this.counterAspect.getCount()).as("Advice not executed: must have been").isEqualTo(2);
FactoryBean<?> fb = (FactoryBean<?>) ctx.getBean("&testFactoryBean1");
boolean condition = !(fb instanceof Advised);
assertThat(condition).as("FactoryBean itself must *not* be advised").isTrue();
assertThat(fb).as("FactoryBean itself must *not* be advised").isNotInstanceOf(Advised.class);
}
@Test
void matchingFactoryBeanItself() {
boolean condition1 = !(this.testFactoryBean2 instanceof Advised);
assertThat(condition1).as("Matching bean must *not* be advised (proxied)").isTrue();
assertThat(this.testFactoryBean2).as("Matching bean must *not* be advised (proxied)").isNotInstanceOf(Advised.class);
FactoryBean<?> fb = (FactoryBean<?>) ctx.getBean("&testFactoryBean2");
boolean condition = fb instanceof Advised;
assertThat(condition).as("FactoryBean itself must be advised").isTrue();
assertThat(fb).as("FactoryBean itself must be advised").isInstanceOf(Advised.class);
assertThat(Map.class.isAssignableFrom(fb.getObjectType())).isTrue();
assertThat(Map.class.isAssignableFrom(fb.getObjectType())).isTrue();
assertThat(this.counterAspect.getCount()).as("Advice not executed: must have been").isEqualTo(2);
@@ -123,10 +116,8 @@ class BeanNamePointcutTests {
@Test
void pointcutAdvisorCombination() {
boolean condition = this.interceptThis instanceof Advised;
assertThat(condition).as("Matching bean must be advised (proxied)").isTrue();
boolean condition1 = this.dontInterceptThis instanceof Advised;
assertThat(condition1).as("Non-matching bean must *not* be advised (proxied)").isFalse();
assertThat(this.interceptThis).as("Matching bean must be advised (proxied)").isInstanceOf(Advised.class);
assertThat(this.dontInterceptThis).as("Non-matching bean must *not* be advised (proxied)").isNotInstanceOf(Advised.class);
interceptThis.setAge(20);
assertThat(testInterceptor.interceptionCount).isEqualTo(1);
dontInterceptThis.setAge(20);
spring-context/src/test/java/org/springframework/aop/aspectj/PropertyDependentAspectTests.java
+2 -4
View File
@@ -61,8 +61,7 @@ class PropertyDependentAspectTests {
private void checkXmlAspect(String appContextFile) {
ApplicationContext context = new ClassPathXmlApplicationContext(appContextFile, getClass());
ICounter counter = (ICounter) context.getBean("counter");
boolean condition = counter instanceof Advised;
assertThat(condition).as("Proxy didn't get created").isTrue();
assertThat(counter).as("Proxy didn't get created").isInstanceOf(Advised.class);
counter.increment();
JoinPointMonitorAspect callCountingAspect = (JoinPointMonitorAspect)context.getBean("monitoringAspect");
@@ -73,8 +72,7 @@ class PropertyDependentAspectTests {
private void checkAtAspectJAspect(String appContextFile) {
ApplicationContext context = new ClassPathXmlApplicationContext(appContextFile, getClass());
ICounter counter = (ICounter) context.getBean("counter");
boolean condition = counter instanceof Advised;
assertThat(condition).as("Proxy didn't get created").isTrue();
assertThat(counter).as("Proxy didn't get created").isInstanceOf(Advised.class);
counter.increment();
JoinPointMonitorAtAspectJAspect callCountingAspect = (JoinPointMonitorAtAspectJAspect)context.getBean("monitoringAspect");
spring-context/src/test/java/org/springframework/aop/config/MethodLocatingFactoryBeanTests.java
+1 -2
View File
@@ -97,8 +97,7 @@ class MethodLocatingFactoryBeanTests {
factory.setBeanFactory(beanFactory);
Object result = factory.getObject();
assertThat(result).isNotNull();
boolean condition = result instanceof Method;
assertThat(condition).isTrue();
assertThat(result).isInstanceOf(Method.class);
Method method = (Method) result;
assertThat(method.invoke("Bingo")).isEqualTo("Bingo");
}
spring-context/src/test/java/org/springframework/aop/framework/AbstractAopProxyTests.java
+1 -2
View File
@@ -855,8 +855,7 @@ abstract class AbstractAopProxyTests {
assertThat(proxied.getAge()).isEqualTo(10);
assertThat(mba.getCalls()).isEqualTo(1);
boolean condition = proxied instanceof Advised;
assertThat(condition).as("Cannot be cast to Advised").isFalse();
assertThat(proxied).as("Cannot be cast to Advised").isNotInstanceOf(Advised.class);
}
@Test
spring-context/src/test/java/org/springframework/aop/target/CommonsPool2TargetSourceTests.java
+4 -8
View File
@@ -121,13 +121,11 @@ class CommonsPool2TargetSourceTests {
void proxySerializableWithoutConfigMixin() throws Exception {
Person pooled = (Person) beanFactory.getBean("pooledPerson");
boolean condition1 = ((Advised) pooled).getTargetSource() instanceof CommonsPool2TargetSource;
assertThat(condition1).isTrue();
assertThat(((Advised) pooled).getTargetSource()).isInstanceOf(CommonsPool2TargetSource.class);
//((Advised) pooled).setTargetSource(new SingletonTargetSource(new SerializablePerson()));
Person serialized = SerializationTestUtils.serializeAndDeserialize(pooled);
boolean condition = ((Advised) serialized).getTargetSource() instanceof SingletonTargetSource;
assertThat(condition).isTrue();
assertThat(((Advised) serialized).getTargetSource()).isInstanceOf(SingletonTargetSource.class);
serialized.setAge(25);
assertThat(serialized.getAge()).isEqualTo(25);
}
@@ -206,10 +204,8 @@ class CommonsPool2TargetSourceTests {
Object first = targetSource.getTarget();
Object second = targetSource.getTarget();
boolean condition1 = first instanceof SerializablePerson;
assertThat(condition1).isTrue();
boolean condition = second instanceof SerializablePerson;
assertThat(condition).isTrue();
assertThat(first).isInstanceOf(SerializablePerson.class);
assertThat(second).isInstanceOf(SerializablePerson.class);
assertThat(second).isEqualTo(first);
targetSource.releaseTarget(first);
spring-context/src/test/java/org/springframework/beans/factory/xml/XmlBeanFactoryTests.java
+6 -6
View File
@@ -152,8 +152,8 @@ class XmlBeanFactoryTests {
assertThat(emmasJenks.getName()).as("Emmas jenks has right name").isEqualTo("Andrew");
assertThat(emmasJenks).as("Emmas doesn't equal new ref").isNotSameAs(xbf.getBean("jenks"));
assertThat(georgiasJenks.getName()).as("Georgias jenks has right name").isEqualTo("Andrew");
assertThat(emmasJenks.equals(georgiasJenks)).as("They are object equal").isTrue();
assertThat(emmasJenks.equals(xbf.getBean("jenks"))).as("They object equal direct ref").isTrue();
assertThat(emmasJenks).as("They are object equal").isEqualTo(georgiasJenks);
assertThat(emmasJenks).as("They object equal direct ref").isEqualTo(xbf.getBean("jenks"));
}
@Test
@@ -1526,7 +1526,7 @@ class XmlBeanFactoryTests {
new XmlBeanDefinitionReader(xbf).loadBeanDefinitions(CONSTRUCTOR_ARG_CONTEXT);
ConstructorArrayTestBean bean = (ConstructorArrayTestBean) xbf.getBean("constructorArray");
assertThat(bean.array).isInstanceOf(int[].class);
assertThat(((int[]) bean.array)).hasSize(1);
assertThat((int[]) bean.array).hasSize(1);
assertThat(((int[]) bean.array)[0]).isEqualTo(1);
}
@@ -1536,7 +1536,7 @@ class XmlBeanFactoryTests {
new XmlBeanDefinitionReader(xbf).loadBeanDefinitions(CONSTRUCTOR_ARG_CONTEXT);
ConstructorArrayTestBean bean = (ConstructorArrayTestBean) xbf.getBean("indexedConstructorArray");
assertThat(bean.array).isInstanceOf(int[].class);
assertThat(((int[]) bean.array)).hasSize(1);
assertThat((int[]) bean.array).hasSize(1);
assertThat(((int[]) bean.array)[0]).isEqualTo(1);
}
@@ -1546,7 +1546,7 @@ class XmlBeanFactoryTests {
new XmlBeanDefinitionReader(xbf).loadBeanDefinitions(CONSTRUCTOR_ARG_CONTEXT);
ConstructorArrayTestBean bean = (ConstructorArrayTestBean) xbf.getBean("constructorArrayNoType");
assertThat(bean.array).isInstanceOf(String[].class);
assertThat(((String[]) bean.array)).isEmpty();
assertThat((String[]) bean.array).isEmpty();
}
@Test
@@ -1557,7 +1557,7 @@ class XmlBeanFactoryTests {
bd.setLenientConstructorResolution(false);
ConstructorArrayTestBean bean = (ConstructorArrayTestBean) xbf.getBean("constructorArrayNoType");
assertThat(bean.array).isInstanceOf(String[].class);
assertThat(((String[]) bean.array)).isEmpty();
assertThat((String[]) bean.array).isEmpty();
}
@Test
spring-context/src/test/java/org/springframework/context/annotation/ClassPathBeanDefinitionScannerTests.java
+1 -1
View File
@@ -472,7 +472,7 @@ class ClassPathBeanDefinitionScannerTests {
int initialBeanCount = context.getBeanDefinitionCount();
int scannedBeanCount = scanner.scan(BASE_PACKAGE);
assertThat(scannedBeanCount).isGreaterThanOrEqualTo(12);
assertThat((context.getBeanDefinitionCount() - initialBeanCount)).isEqualTo(scannedBeanCount);
assertThat(context.getBeanDefinitionCount() - initialBeanCount).isEqualTo(scannedBeanCount);
int addedBeanCount = scanner.scan("org.springframework.aop.aspectj.annotation");
assertThat(context.getBeanDefinitionCount()).isEqualTo((initialBeanCount + scannedBeanCount + addedBeanCount));
}
spring-context/src/test/java/org/springframework/context/annotation/ClassPathFactoryBeanDefinitionScannerTests.java
+1 -2
View File
@@ -79,8 +79,7 @@ class ClassPathFactoryBeanDefinitionScannerTests {
Object bean = context.getBean("requestScopedInstance"); //5
assertThat(AopUtils.isCglibProxy(bean)).isTrue();
boolean condition = bean instanceof ScopedObject;
assertThat(condition).isTrue();
assertThat(bean).isInstanceOf(ScopedObject.class);
QualifiedClientBean clientBean = context.getBean("clientBean", QualifiedClientBean.class);
assertThat(clientBean.testBean).isSameAs(context.getBean("publicInstance"));
spring-context/src/test/java/org/springframework/context/annotation/CommonAnnotationBeanPostProcessorTests.java
+1 -2
View File
@@ -431,8 +431,7 @@ class CommonAnnotationBeanPostProcessorTests {
bf.getBean("annotatedBean2");
}
catch (BeanCreationException ex) {
boolean condition = ex.getRootCause() instanceof NoSuchBeanDefinitionException;
assertThat(condition).isTrue();
assertThat(ex.getRootCause()).isInstanceOf(NoSuchBeanDefinitionException.class);
NoSuchBeanDefinitionException innerEx = (NoSuchBeanDefinitionException) ex.getRootCause();
assertThat(innerEx.getBeanName()).isEqualTo("testBean9");
}
spring-context/src/test/java/org/springframework/context/annotation/ConfigurationClassPostProcessorTests.java
+5 -10
View File
@@ -444,8 +444,7 @@ class ConfigurationClassPostProcessorTests {
pp.postProcessBeanFactory(beanFactory);
Foo foo = beanFactory.getBean(Foo.class);
boolean condition = foo instanceof ExtendedFoo;
assertThat(condition).isTrue();
assertThat(foo).isInstanceOf(ExtendedFoo.class);
Bar bar = beanFactory.getBean(Bar.class);
assertThat(bar.foo).isSameAs(foo);
}
@@ -460,8 +459,7 @@ class ConfigurationClassPostProcessorTests {
pp.postProcessBeanFactory(beanFactory);
Foo foo = beanFactory.getBean(Foo.class);
boolean condition = foo instanceof ExtendedAgainFoo;
assertThat(condition).isTrue();
assertThat(foo).isInstanceOf(ExtendedAgainFoo.class);
Bar bar = beanFactory.getBean(Bar.class);
assertThat(bar.foo).isSameAs(foo);
}
@@ -491,8 +489,7 @@ class ConfigurationClassPostProcessorTests {
pp.postProcessBeanFactory(beanFactory);
Foo foo = beanFactory.getBean(Foo.class);
boolean condition = foo instanceof ExtendedFoo;
assertThat(condition).isTrue();
assertThat(foo).isInstanceOf(ExtendedFoo.class);
Bar bar = beanFactory.getBean(Bar.class);
assertThat(bar.foo).isSameAs(foo);
}
@@ -506,8 +503,7 @@ class ConfigurationClassPostProcessorTests {
beanFactory.addBeanPostProcessor(new AutowiredAnnotationBeanPostProcessor());
Foo foo = beanFactory.getBean(Foo.class);
boolean condition = foo instanceof ExtendedFoo;
assertThat(condition).isTrue();
assertThat(foo).isInstanceOf(ExtendedFoo.class);
Bar bar = beanFactory.getBean(Bar.class);
assertThat(bar.foo).isSameAs(foo);
}
@@ -523,8 +519,7 @@ class ConfigurationClassPostProcessorTests {
pp.postProcessBeanFactory(beanFactory);
ITestBean injected = beanFactory.getBean("consumer", ScopedProxyConsumer.class).testBean;
boolean condition = injected instanceof ScopedObject;
assertThat(condition).isTrue();
assertThat(injected).isInstanceOf(ScopedObject.class);
assertThat(injected).isSameAs(beanFactory.getBean("scopedClass"));
assertThat(injected).isSameAs(beanFactory.getBean(ITestBean.class));
}
spring-context/src/test/java/org/springframework/context/annotation/LazyAutowiredAnnotationBeanPostProcessorTests.java
+1 -1
View File
@@ -91,7 +91,7 @@ class LazyAutowiredAnnotationBeanPostProcessorTests {
tb.setName("tb");
assertThat(bean.getTestBean().getName()).isSameAs("tb");
assertThat(bean.getTestBeans() instanceof Advised).isTrue();
assertThat(bean.getTestBeans()).isInstanceOf(Advised.class);
TargetSource targetSource = ((Advised) bean.getTestBeans()).getTargetSource();
assertThat(targetSource.getTarget()).isSameAs(targetSource.getTarget());
spring-context/src/test/java/org/springframework/context/annotation/SimpleConfigTests.java
+1 -2
View File
@@ -44,8 +44,7 @@ class SimpleConfigTests {
assertThat(value).isEqualTo("bar");
Future<?> future = fooService.asyncFoo(1);
boolean condition = future instanceof FutureTask;
assertThat(condition).isTrue();
assertThat(future).isInstanceOf(FutureTask.class);
assertThat(future.get()).isEqualTo("bar");
assertThat(serviceInvocationCounter.getCount()).isEqualTo(2);
spring-context/src/test/java/org/springframework/context/annotation/configuration/ScopingTests.java
+3 -6
View File
@@ -153,16 +153,14 @@ class ScopingTests {
// get hidden bean
Object bean = ctx.getBean("scopedTarget." + beanName);
boolean condition = bean instanceof ScopedObject;
assertThat(condition).isFalse();
assertThat(bean).isNotInstanceOf(ScopedObject.class);
}
@Test
void scopedProxyConfiguration() {
TestBean singleton = (TestBean) ctx.getBean("singletonWithScopedInterfaceDep");
ITestBean spouse = singleton.getSpouse();
boolean condition = spouse instanceof ScopedObject;
assertThat(condition).as("scoped bean is not wrapped by the scoped-proxy").isTrue();
assertThat(spouse).as("scoped bean is not wrapped by the scoped-proxy").isInstanceOf(ScopedObject.class);
String beanName = "scopedProxyInterface";
@@ -194,8 +192,7 @@ class ScopingTests {
void scopedProxyConfigurationWithClasses() {
TestBean singleton = (TestBean) ctx.getBean("singletonWithScopedClassDep");
ITestBean spouse = singleton.getSpouse();
boolean condition = spouse instanceof ScopedObject;
assertThat(condition).as("scoped bean is not wrapped by the scoped-proxy").isTrue();
assertThat(spouse).as("scoped bean is not wrapped by the scoped-proxy").isInstanceOf(ScopedObject.class);
String beanName = "scopedProxyClass";
spring-context/src/test/java/org/springframework/context/i18n/LocaleContextHolderTests.java
+10 -20
View File
@@ -67,15 +67,13 @@ class LocaleContextHolderTests {
LocaleContextHolder.setLocale(Locale.GERMAN);
assertThat(LocaleContextHolder.getLocale()).isEqualTo(Locale.GERMAN);
assertThat(LocaleContextHolder.getTimeZone()).isEqualTo(TimeZone.getDefault());
boolean condition1 = LocaleContextHolder.getLocaleContext() instanceof TimeZoneAwareLocaleContext;
assertThat(condition1).isFalse();
assertThat(LocaleContextHolder.getLocaleContext()).isNotInstanceOf(TimeZoneAwareLocaleContext.class);
assertThat(LocaleContextHolder.getLocaleContext().getLocale()).isEqualTo(Locale.GERMAN);
LocaleContextHolder.setLocale(Locale.GERMANY);
assertThat(LocaleContextHolder.getLocale()).isEqualTo(Locale.GERMANY);
assertThat(LocaleContextHolder.getTimeZone()).isEqualTo(TimeZone.getDefault());
boolean condition = LocaleContextHolder.getLocaleContext() instanceof TimeZoneAwareLocaleContext;
assertThat(condition).isFalse();
assertThat(LocaleContextHolder.getLocaleContext()).isNotInstanceOf(TimeZoneAwareLocaleContext.class);
assertThat(LocaleContextHolder.getLocaleContext().getLocale()).isEqualTo(Locale.GERMANY);
LocaleContextHolder.setLocale(null);
@@ -94,16 +92,14 @@ class LocaleContextHolderTests {
LocaleContextHolder.setTimeZone(TimeZone.getTimeZone("GMT+1"));
assertThat(LocaleContextHolder.getLocale()).isEqualTo(Locale.getDefault());
assertThat(LocaleContextHolder.getTimeZone()).isEqualTo(TimeZone.getTimeZone("GMT+1"));
boolean condition1 = LocaleContextHolder.getLocaleContext() instanceof TimeZoneAwareLocaleContext;
assertThat(condition1).isTrue();
assertThat(LocaleContextHolder.getLocaleContext()).isInstanceOf(TimeZoneAwareLocaleContext.class);
assertThat(LocaleContextHolder.getLocaleContext().getLocale()).isNull();
assertThat(((TimeZoneAwareLocaleContext) LocaleContextHolder.getLocaleContext()).getTimeZone()).isEqualTo(TimeZone.getTimeZone("GMT+1"));
LocaleContextHolder.setTimeZone(TimeZone.getTimeZone("GMT+2"));
assertThat(LocaleContextHolder.getLocale()).isEqualTo(Locale.getDefault());
assertThat(LocaleContextHolder.getTimeZone()).isEqualTo(TimeZone.getTimeZone("GMT+2"));
boolean condition = LocaleContextHolder.getLocaleContext() instanceof TimeZoneAwareLocaleContext;
assertThat(condition).isTrue();
assertThat(LocaleContextHolder.getLocaleContext()).isInstanceOf(TimeZoneAwareLocaleContext.class);
assertThat(LocaleContextHolder.getLocaleContext().getLocale()).isNull();
assertThat(((TimeZoneAwareLocaleContext) LocaleContextHolder.getLocaleContext()).getTimeZone()).isEqualTo(TimeZone.getTimeZone("GMT+2"));
@@ -123,46 +119,40 @@ class LocaleContextHolderTests {
LocaleContextHolder.setLocale(Locale.GERMANY);
assertThat(LocaleContextHolder.getLocale()).isEqualTo(Locale.GERMANY);
assertThat(LocaleContextHolder.getTimeZone()).isEqualTo(TimeZone.getDefault());
boolean condition5 = LocaleContextHolder.getLocaleContext() instanceof TimeZoneAwareLocaleContext;
assertThat(condition5).isFalse();
assertThat(LocaleContextHolder.getLocaleContext()).isNotInstanceOf(TimeZoneAwareLocaleContext.class);
assertThat(LocaleContextHolder.getLocaleContext().getLocale()).isEqualTo(Locale.GERMANY);
LocaleContextHolder.setTimeZone(TimeZone.getTimeZone("GMT+1"));
assertThat(LocaleContextHolder.getLocale()).isEqualTo(Locale.GERMANY);
assertThat(LocaleContextHolder.getTimeZone()).isEqualTo(TimeZone.getTimeZone("GMT+1"));
boolean condition3 = LocaleContextHolder.getLocaleContext() instanceof TimeZoneAwareLocaleContext;
assertThat(condition3).isTrue();
assertThat(LocaleContextHolder.getLocaleContext()).isInstanceOf(TimeZoneAwareLocaleContext.class);
assertThat(LocaleContextHolder.getLocaleContext().getLocale()).isEqualTo(Locale.GERMANY);
assertThat(((TimeZoneAwareLocaleContext) LocaleContextHolder.getLocaleContext()).getTimeZone()).isEqualTo(TimeZone.getTimeZone("GMT+1"));
LocaleContextHolder.setLocale(Locale.GERMAN);
assertThat(LocaleContextHolder.getLocale()).isEqualTo(Locale.GERMAN);
assertThat(LocaleContextHolder.getTimeZone()).isEqualTo(TimeZone.getTimeZone("GMT+1"));
boolean condition2 = LocaleContextHolder.getLocaleContext() instanceof TimeZoneAwareLocaleContext;
assertThat(condition2).isTrue();
assertThat(LocaleContextHolder.getLocaleContext()).isInstanceOf(TimeZoneAwareLocaleContext.class);
assertThat(LocaleContextHolder.getLocaleContext().getLocale()).isEqualTo(Locale.GERMAN);
assertThat(((TimeZoneAwareLocaleContext) LocaleContextHolder.getLocaleContext()).getTimeZone()).isEqualTo(TimeZone.getTimeZone("GMT+1"));
LocaleContextHolder.setTimeZone(null);
assertThat(LocaleContextHolder.getLocale()).isEqualTo(Locale.GERMAN);
assertThat(LocaleContextHolder.getTimeZone()).isEqualTo(TimeZone.getDefault());
boolean condition4 = LocaleContextHolder.getLocaleContext() instanceof TimeZoneAwareLocaleContext;
assertThat(condition4).isFalse();
assertThat(LocaleContextHolder.getLocaleContext()).isNotInstanceOf(TimeZoneAwareLocaleContext.class);
assertThat(LocaleContextHolder.getLocaleContext().getLocale()).isEqualTo(Locale.GERMAN);
LocaleContextHolder.setTimeZone(TimeZone.getTimeZone("GMT+2"));
assertThat(LocaleContextHolder.getLocale()).isEqualTo(Locale.GERMAN);
assertThat(LocaleContextHolder.getTimeZone()).isEqualTo(TimeZone.getTimeZone("GMT+2"));
boolean condition1 = LocaleContextHolder.getLocaleContext() instanceof TimeZoneAwareLocaleContext;
assertThat(condition1).isTrue();
assertThat(LocaleContextHolder.getLocaleContext()).isInstanceOf(TimeZoneAwareLocaleContext.class);
assertThat(LocaleContextHolder.getLocaleContext().getLocale()).isEqualTo(Locale.GERMAN);
assertThat(((TimeZoneAwareLocaleContext) LocaleContextHolder.getLocaleContext()).getTimeZone()).isEqualTo(TimeZone.getTimeZone("GMT+2"));
LocaleContextHolder.setLocale(null);
assertThat(LocaleContextHolder.getLocale()).isEqualTo(Locale.getDefault());
assertThat(LocaleContextHolder.getTimeZone()).isEqualTo(TimeZone.getTimeZone("GMT+2"));
boolean condition = LocaleContextHolder.getLocaleContext() instanceof TimeZoneAwareLocaleContext;
assertThat(condition).isTrue();
assertThat(LocaleContextHolder.getLocaleContext()).isInstanceOf(TimeZoneAwareLocaleContext.class);
assertThat(LocaleContextHolder.getLocaleContext().getLocale()).isNull();
assertThat(((TimeZoneAwareLocaleContext) LocaleContextHolder.getLocaleContext()).getTimeZone()).isEqualTo(TimeZone.getTimeZone("GMT+2"));
spring-context/src/test/java/org/springframework/ejb/config/JeeNamespaceHandlerEventTests.java
+3 -6
View File
@@ -53,22 +53,19 @@ class JeeNamespaceHandlerEventTests {
@Test
void jndiLookupComponentEventReceived() {
ComponentDefinition component = this.eventListener.getComponentDefinition("simple");
boolean condition = component instanceof BeanComponentDefinition;
assertThat(condition).isTrue();
assertThat(component).isInstanceOf(BeanComponentDefinition.class);
}
@Test
void localSlsbComponentEventReceived() {
ComponentDefinition component = this.eventListener.getComponentDefinition("simpleLocalEjb");
boolean condition = component instanceof BeanComponentDefinition;
assertThat(condition).isTrue();
assertThat(component).isInstanceOf(BeanComponentDefinition.class);
}
@Test
void remoteSlsbComponentEventReceived() {
ComponentDefinition component = this.eventListener.getComponentDefinition("simpleRemoteEjb");
boolean condition = component instanceof BeanComponentDefinition;
assertThat(condition).isTrue();
assertThat(component).isInstanceOf(BeanComponentDefinition.class);
}
}
spring-context/src/test/java/org/springframework/jmx/export/notification/ModelMBeanNotificationPublisherTests.java
+2 -4
View File
@@ -86,8 +86,7 @@ class ModelMBeanNotificationPublisherTests {
publisher.sendNotification(notification);
assertThat(mbean.getActualNotification()).isNotNull();
boolean condition = mbean.getActualNotification() instanceof AttributeChangeNotification;
assertThat(condition).isTrue();
assertThat(mbean.getActualNotification()).isInstanceOf(AttributeChangeNotification.class);
assertThat(mbean.getActualNotification()).as("The exact same Notification is not being passed through from the publisher to the mbean.").isSameAs(notification);
assertThat(mbean.getActualNotification().getSource()).as("The 'source' property of the Notification is not being set to the ObjectName of the associated MBean.").isSameAs(objectName);
}
@@ -102,8 +101,7 @@ class ModelMBeanNotificationPublisherTests {
publisher.sendNotification(notification);
assertThat(mbean.getActualNotification()).isNotNull();
boolean condition = mbean.getActualNotification() instanceof AttributeChangeNotification;
assertThat(condition).isTrue();
assertThat(mbean.getActualNotification()).isInstanceOf(AttributeChangeNotification.class);
assertThat(mbean.getActualNotification()).as("The exact same Notification is not being passed through from the publisher to the mbean.").isSameAs(notification);
assertThat(mbean.getActualNotification().getSource()).as("The 'source' property of the Notification is *wrongly* being set to the ObjectName of the associated MBean.").isSameAs(this);
}
spring-context/src/test/java/org/springframework/jndi/JndiObjectFactoryBeanTests.java
+6 -12
View File
@@ -210,8 +210,7 @@ class JndiObjectFactoryBeanTests {
jof.setJndiName("foo");
jof.setProxyInterface(ITestBean.class);
jof.afterPropertiesSet();
boolean condition = jof.getObject() instanceof ITestBean;
assertThat(condition).isTrue();
assertThat(jof.getObject()).isInstanceOf(ITestBean.class);
ITestBean proxy = (ITestBean) jof.getObject();
assertThat(tb.getAge()).isEqualTo(0);
proxy.setAge(99);
@@ -247,8 +246,7 @@ class JndiObjectFactoryBeanTests {
jof.setProxyInterface(ITestBean.class);
jof.setLookupOnStartup(false);
jof.afterPropertiesSet();
boolean condition = jof.getObject() instanceof ITestBean;
assertThat(condition).isTrue();
assertThat(jof.getObject()).isInstanceOf(ITestBean.class);
ITestBean proxy = (ITestBean) jof.getObject();
assertThat(tb.getName()).isNull();
assertThat(tb.getAge()).isEqualTo(0);
@@ -276,8 +274,7 @@ class JndiObjectFactoryBeanTests {
jof.setProxyInterface(ITestBean.class);
jof.setCache(false);
jof.afterPropertiesSet();
boolean condition = jof.getObject() instanceof ITestBean;
assertThat(condition).isTrue();
assertThat(jof.getObject()).isInstanceOf(ITestBean.class);
ITestBean proxy = (ITestBean) jof.getObject();
assertThat(tb.getName()).isEqualTo("tb");
assertThat(tb.getAge()).isEqualTo(1);
@@ -307,8 +304,7 @@ class JndiObjectFactoryBeanTests {
jof.setLookupOnStartup(false);
jof.setCache(false);
jof.afterPropertiesSet();
boolean condition = jof.getObject() instanceof ITestBean;
assertThat(condition).isTrue();
assertThat(jof.getObject()).isInstanceOf(ITestBean.class);
ITestBean proxy = (ITestBean) jof.getObject();
assertThat(tb.getName()).isNull();
assertThat(tb.getAge()).isEqualTo(0);
@@ -347,8 +343,7 @@ class JndiObjectFactoryBeanTests {
jof.setExpectedType(TestBean.class);
jof.setProxyInterface(ITestBean.class);
jof.afterPropertiesSet();
boolean condition = jof.getObject() instanceof ITestBean;
assertThat(condition).isTrue();
assertThat(jof.getObject()).isInstanceOf(ITestBean.class);
ITestBean proxy = (ITestBean) jof.getObject();
assertThat(tb.getAge()).isEqualTo(0);
proxy.setAge(99);
@@ -384,8 +379,7 @@ class JndiObjectFactoryBeanTests {
jof.setProxyInterface(ITestBean.class);
jof.setExposeAccessContext(true);
jof.afterPropertiesSet();
boolean condition = jof.getObject() instanceof ITestBean;
assertThat(condition).isTrue();
assertThat(jof.getObject()).isInstanceOf(ITestBean.class);
ITestBean proxy = (ITestBean) jof.getObject();
assertThat(tb.getAge()).isEqualTo(0);
proxy.setAge(99);
spring-context/src/test/java/org/springframework/scheduling/annotation/ScheduledAnnotationBeanPostProcessorTests.java
+1 -2
View File
@@ -335,8 +335,7 @@ class ScheduledAnnotationBeanPostProcessorTests {
assertThat(task.getExpression()).isEqualTo("0 0 0-4,6-23 * * ?");
Trigger trigger = task.getTrigger();
assertThat(trigger).isNotNull();
boolean condition = trigger instanceof CronTrigger;
assertThat(condition).isTrue();
assertThat(trigger).isInstanceOf(CronTrigger.class);
CronTrigger cronTrigger = (CronTrigger) trigger;
ZonedDateTime dateTime = ZonedDateTime.of(2013, 4, 15, 4, 0, 0, 0, ZoneId.of("GMT+10"));
Instant lastScheduledExecution = dateTime.toInstant();
spring-context/src/test/java/org/springframework/scheduling/support/BitsCronFieldTests.java
+2 -2
View File
@@ -106,9 +106,9 @@ class BitsCronFieldTests {
@Test
void names() {
assertThat(((BitsCronField)CronField.parseMonth("JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC")))
assertThat((BitsCronField)CronField.parseMonth("JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC"))
.has(clear(0)).has(setRange(1, 12));
assertThat(((BitsCronField)CronField.parseDaysOfWeek("SUN,MON,TUE,WED,THU,FRI,SAT")))
assertThat((BitsCronField)CronField.parseDaysOfWeek("SUN,MON,TUE,WED,THU,FRI,SAT"))
.has(clear(0)).has(setRange(1, 7));
}
spring-context/src/test/java/org/springframework/scripting/groovy/GroovyScriptFactoryTests.java
+19 -19
View File
@@ -78,8 +78,8 @@ class GroovyScriptFactoryTests {
assertThat(AopUtils.isAopProxy(calc)).as("Shouldn't get proxy when refresh is disabled").isFalse();
assertThat(AopUtils.isAopProxy(messenger)).as("Shouldn't get proxy when refresh is disabled").isFalse();
assertThat(calc instanceof Refreshable).as("Scripted object should not be instance of Refreshable").isFalse();
assertThat(messenger instanceof Refreshable).as("Scripted object should not be instance of Refreshable").isFalse();
assertThat(calc).as("Scripted object should not be instance of Refreshable").isNotInstanceOf(Refreshable.class);
assertThat(messenger).as("Scripted object should not be instance of Refreshable").isNotInstanceOf(Refreshable.class);
assertThat(calc).isEqualTo(calc);
assertThat(messenger).isEqualTo(messenger);
@@ -107,8 +107,8 @@ class GroovyScriptFactoryTests {
assertThat(AopUtils.isAopProxy(calc)).as("Shouldn't get proxy when refresh is disabled").isFalse();
assertThat(AopUtils.isAopProxy(messenger)).as("Shouldn't get proxy when refresh is disabled").isFalse();
assertThat(calc instanceof Refreshable).as("Scripted object should not be instance of Refreshable").isFalse();
assertThat(messenger instanceof Refreshable).as("Scripted object should not be instance of Refreshable").isFalse();
assertThat(calc).as("Scripted object should not be instance of Refreshable").isNotInstanceOf(Refreshable.class);
assertThat(messenger).as("Scripted object should not be instance of Refreshable").isNotInstanceOf(Refreshable.class);
assertThat(calc).isEqualTo(calc);
assertThat(messenger).isEqualTo(messenger);
@@ -130,7 +130,7 @@ class GroovyScriptFactoryTests {
ConfigurableMessenger messenger2 = (ConfigurableMessenger) ctx.getBean("messengerPrototype");
assertThat(AopUtils.isAopProxy(messenger)).as("Shouldn't get proxy when refresh is disabled").isFalse();
assertThat(messenger instanceof Refreshable).as("Scripted object should not be instance of Refreshable").isFalse();
assertThat(messenger).as("Scripted object should not be instance of Refreshable").isNotInstanceOf(Refreshable.class);
assertThat(messenger2).isNotSameAs(messenger);
assertThat(messenger2.getClass()).isSameAs(messenger.getClass());
@@ -149,7 +149,7 @@ class GroovyScriptFactoryTests {
ConfigurableMessenger messenger2 = (ConfigurableMessenger) ctx.getBean("messengerPrototype");
assertThat(AopUtils.isAopProxy(messenger)).as("Shouldn't get proxy when refresh is disabled").isFalse();
assertThat(messenger instanceof Refreshable).as("Scripted object should not be instance of Refreshable").isFalse();
assertThat(messenger).as("Scripted object should not be instance of Refreshable").isNotInstanceOf(Refreshable.class);
assertThat(messenger2).isNotSameAs(messenger);
assertThat(messenger2.getClass()).isSameAs(messenger.getClass());
@@ -168,7 +168,7 @@ class GroovyScriptFactoryTests {
Messenger messenger = (Messenger) ctx.getBean("messengerInstance");
assertThat(AopUtils.isAopProxy(messenger)).as("Shouldn't get proxy when refresh is disabled").isFalse();
assertThat(messenger instanceof Refreshable).as("Scripted object should not be instance of Refreshable").isFalse();
assertThat(messenger).as("Scripted object should not be instance of Refreshable").isNotInstanceOf(Refreshable.class);
String desiredMessage = "Hello World!";
assertThat(messenger.getMessage()).as("Message is incorrect").isEqualTo(desiredMessage);
@@ -182,7 +182,7 @@ class GroovyScriptFactoryTests {
Messenger messenger = (Messenger) ctx.getBean("messengerInstance");
assertThat(AopUtils.isAopProxy(messenger)).as("Shouldn't get proxy when refresh is disabled").isFalse();
assertThat(messenger instanceof Refreshable).as("Scripted object should not be instance of Refreshable").isFalse();
assertThat(messenger).as("Scripted object should not be instance of Refreshable").isNotInstanceOf(Refreshable.class);
String desiredMessage = "Hello World!";
assertThat(messenger.getMessage()).as("Message is incorrect").isEqualTo(desiredMessage);
@@ -196,7 +196,7 @@ class GroovyScriptFactoryTests {
Messenger messenger = (Messenger) ctx.getBean("messengerInstanceInline");
assertThat(AopUtils.isAopProxy(messenger)).as("Shouldn't get proxy when refresh is disabled").isFalse();
assertThat(messenger instanceof Refreshable).as("Scripted object should not be instance of Refreshable").isFalse();
assertThat(messenger).as("Scripted object should not be instance of Refreshable").isNotInstanceOf(Refreshable.class);
String desiredMessage = "Hello World!";
assertThat(messenger.getMessage()).as("Message is incorrect").isEqualTo(desiredMessage);
@@ -210,7 +210,7 @@ class GroovyScriptFactoryTests {
Messenger messenger = (Messenger) ctx.getBean("messengerInstanceInline");
assertThat(AopUtils.isAopProxy(messenger)).as("Shouldn't get proxy when refresh is disabled").isFalse();
assertThat(messenger instanceof Refreshable).as("Scripted object should not be instance of Refreshable").isFalse();
assertThat(messenger).as("Scripted object should not be instance of Refreshable").isNotInstanceOf(Refreshable.class);
String desiredMessage = "Hello World!";
assertThat(messenger.getMessage()).as("Message is incorrect").isEqualTo(desiredMessage);
@@ -223,7 +223,7 @@ class GroovyScriptFactoryTests {
Messenger messenger = (Messenger) ctx.getBean("messenger");
assertThat(AopUtils.isAopProxy(messenger)).as("Should be a proxy for refreshable scripts").isTrue();
assertThat(messenger instanceof Refreshable).as("Should be an instance of Refreshable").isTrue();
assertThat(messenger).as("Should be an instance of Refreshable").isInstanceOf(Refreshable.class);
String desiredMessage = "Hello World!";
assertThat(messenger.getMessage()).as("Message is incorrect").isEqualTo(desiredMessage);
@@ -242,7 +242,7 @@ class GroovyScriptFactoryTests {
ConfigurableMessenger messenger2 = (ConfigurableMessenger) ctx.getBean("messengerPrototype");
assertThat(AopUtils.isAopProxy(messenger)).as("Should be a proxy for refreshable scripts").isTrue();
assertThat(messenger instanceof Refreshable).as("Should be an instance of Refreshable").isTrue();
assertThat(messenger).as("Should be an instance of Refreshable").isInstanceOf(Refreshable.class);
assertThat(messenger.getMessage()).isEqualTo("Hello World!");
assertThat(messenger2.getMessage()).isEqualTo("Hello World!");
@@ -355,7 +355,7 @@ class GroovyScriptFactoryTests {
CallCounter countingAspect = (CallCounter) ctx.getBean("getMessageAspect");
assertThat(AopUtils.isAopProxy(messenger)).isTrue();
assertThat(messenger instanceof Refreshable).isFalse();
assertThat(messenger).isNotInstanceOf(Refreshable.class);
assertThat(countingAspect.getCalls()).isEqualTo(0);
assertThat(messenger.getMessage()).isEqualTo("Hello World!");
assertThat(countingAspect.getCalls()).isEqualTo(1);
@@ -387,7 +387,7 @@ class GroovyScriptFactoryTests {
assertThat(ObjectUtils.containsElement(bd.getDependsOn(), "messenger")).isTrue();
Calculator calculator = (Calculator) ctx.getBean("calculator");
assertThat(calculator).isNotNull();
assertThat(calculator instanceof Refreshable).isFalse();
assertThat(calculator).isNotInstanceOf(Refreshable.class);
}
@Test
@@ -399,7 +399,7 @@ class GroovyScriptFactoryTests {
CallCounter countingAspect = (CallCounter) ctx.getBean("getMessageAspect");
assertThat(AopUtils.isAopProxy(messenger)).isTrue();
assertThat(messenger instanceof Refreshable).isTrue();
assertThat(messenger).isInstanceOf(Refreshable.class);
assertThat(countingAspect.getCalls()).isEqualTo(0);
assertThat(messenger.getMessage()).isEqualTo("Hello World!");
assertThat(countingAspect.getCalls()).isEqualTo(1);
@@ -416,7 +416,7 @@ class GroovyScriptFactoryTests {
Messenger messenger = (Messenger) ctx.getBean("refreshableMessenger");
assertThat(AopUtils.isAopProxy(messenger)).isTrue();
assertThat(messenger instanceof Refreshable).isTrue();
assertThat(messenger).isInstanceOf(Refreshable.class);
assertThat(messenger.getMessage()).isEqualTo("Hello World!");
assertThat(ctx.getBeansOfType(ConcreteMessenger.class)).containsValue((ConcreteMessenger) messenger);
@@ -467,7 +467,7 @@ class GroovyScriptFactoryTests {
assertThat(Arrays.asList(ctx.getBeanNamesForType(Messenger.class))).contains("refreshableMessenger");
Messenger messenger = (Messenger) ctx.getBean("refreshableMessenger");
assertThat(AopUtils.isAopProxy(messenger)).isTrue();
assertThat(messenger instanceof Refreshable).isTrue();
assertThat(messenger).isInstanceOf(Refreshable.class);
assertThat(messenger.getMessage()).isEqualTo("Hello World!");
}
@@ -530,7 +530,7 @@ class GroovyScriptFactoryTests {
void factoryBean() {
ApplicationContext context = new ClassPathXmlApplicationContext("groovyContext.xml", getClass());
Object factory = context.getBean("&factory");
assertThat(factory instanceof FactoryBean).isTrue();
assertThat(factory).isInstanceOf(FactoryBean.class);
Object result = context.getBean("factory");
assertThat(result).isEqualTo("test");
}
@@ -539,7 +539,7 @@ class GroovyScriptFactoryTests {
void refreshableFactoryBean() {
ApplicationContext context = new ClassPathXmlApplicationContext("groovyContext.xml", getClass());
Object factory = context.getBean("&refreshableFactory");
assertThat(factory instanceof FactoryBean).isTrue();
assertThat(factory).isInstanceOf(FactoryBean.class);
Object result = context.getBean("refreshableFactory");
assertThat(result).isEqualTo("test");
}
spring-context/src/test/java/org/springframework/validation/DataBinderFieldAccessTests.java
+1 -1
View File
@@ -58,7 +58,7 @@ class DataBinderFieldAccessTests {
Map<?, ?> m = binder.getBindingResult().getModel();
assertThat(m).as("There is one element in map").hasSize(2);
FieldAccessBean tb = (FieldAccessBean) m.get("person");
assertThat(tb.equals(rod)).as("Same object").isTrue();
assertThat(tb).as("Same object").isEqualTo(rod);
}
@Test
spring-context/src/test/java/org/springframework/validation/DataBinderTests.java
+2 -2
View File
@@ -113,7 +113,7 @@ class DataBinderTests {
Map<?, ?> map = binder.getBindingResult().getModel();
assertThat(map).as("There is one element in map").hasSize(2);
TestBean tb = (TestBean) map.get("person");
assertThat(tb.equals(rod)).as("Same object").isTrue();
assertThat(tb).as("Same object").isEqualTo(rod);
BindingResult other = new DataBinder(rod, "person").getBindingResult();
assertThat(binder.getBindingResult()).isEqualTo(other);
@@ -793,7 +793,7 @@ class DataBinderTests {
Map<?,?> m = binder.getBindingResult().getModel();
assertThat(m).as("There is one element in map").hasSize(2);
TestBean tb = (TestBean) m.get("person");
assertThat(tb.equals(rod)).as("Same object").isTrue();
assertThat(tb).as("Same object").isEqualTo(rod);
}
@Test
spring-context/src/testFixtures/java/org/springframework/context/testfixture/AbstractApplicationContextTests.java
+5 -7
View File
@@ -93,8 +93,7 @@ public abstract class AbstractApplicationContextTests extends AbstractListableBe
assertThat(aca.getApplicationContext()).as("has had context set").isSameAs(applicationContext);
Object aca2 = applicationContext.getBean("aca-prototype");
assertThat(aca).as("NOT Same instance").isNotSameAs(aca2);
boolean condition = !applicationContext.isSingleton("aca-prototype");
assertThat(condition).as("Says is prototype").isTrue();
assertThat(applicationContext.isSingleton("aca-prototype")).as("Says is prototype").isFalse();
}
@Test
@@ -110,26 +109,25 @@ public abstract class AbstractApplicationContextTests extends AbstractListableBe
@Test
protected void overrideWorked() {
TestBean rod = (TestBean) applicationContext.getParent().getBean("rod");
assertThat(rod.getName().equals("Roderick")).as("Parent's name differs").isTrue();
assertThat(rod.getName()).as("Parent's name differs").isEqualTo("Roderick");
}
@Test
protected void grandparentDefinitionFound() {
TestBean dad = (TestBean) applicationContext.getBean("father");
assertThat(dad.getName().equals("Albert")).as("Dad has correct name").isTrue();
assertThat(dad.getName()).as("Dad has correct name").isEqualTo("Albert");
}
@Test
protected void grandparentTypedDefinitionFound() {
TestBean dad = applicationContext.getBean("father", TestBean.class);
assertThat(dad.getName().equals("Albert")).as("Dad has correct name").isTrue();
assertThat(dad.getName()).as("Dad has correct name").isEqualTo("Albert");
}
@Test
protected void closeTriggersDestroy() {
LifecycleBean lb = (LifecycleBean) applicationContext.getBean("lifecycle");
boolean condition = !lb.isDestroyed();
assertThat(condition).as("Not destroyed").isTrue();
assertThat(lb.isDestroyed()).as("Not destroyed").isFalse();
applicationContext.close();
if (applicationContext.getParent() != null) {
((ConfigurableApplicationContext) applicationContext.getParent()).close();
spring-core/src/test/java/org/springframework/core/PrioritizedParameterNameDiscovererTests.java
+8 -9
View File
@@ -18,7 +18,6 @@ package org.springframework.core;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Arrays;
import org.junit.jupiter.api.Test;
@@ -71,22 +70,22 @@ class PrioritizedParameterNameDiscovererTests {
void orderedParameterDiscoverers1() {
PrioritizedParameterNameDiscoverer pnd = new PrioritizedParameterNameDiscoverer();
pnd.addDiscoverer(returnsFooBar);
assertThat(Arrays.equals(FOO_BAR, pnd.getParameterNames(anyMethod))).isTrue();
assertThat(Arrays.equals(FOO_BAR, pnd.getParameterNames((Constructor<?>) null))).isTrue();
assertThat(pnd.getParameterNames(anyMethod)).containsExactly(FOO_BAR);
assertThat(pnd.getParameterNames((Constructor<?>) null)).containsExactly(FOO_BAR);
pnd.addDiscoverer(returnsSomethingElse);
assertThat(Arrays.equals(FOO_BAR, pnd.getParameterNames(anyMethod))).isTrue();
assertThat(Arrays.equals(FOO_BAR, pnd.getParameterNames((Constructor<?>) null))).isTrue();
assertThat(pnd.getParameterNames(anyMethod)).containsExactly(FOO_BAR);
assertThat(pnd.getParameterNames((Constructor<?>) null)).containsExactly(FOO_BAR);
}
@Test
void orderedParameterDiscoverers2() {
PrioritizedParameterNameDiscoverer pnd = new PrioritizedParameterNameDiscoverer();
pnd.addDiscoverer(returnsSomethingElse);
assertThat(Arrays.equals(SOMETHING_ELSE, pnd.getParameterNames(anyMethod))).isTrue();
assertThat(Arrays.equals(SOMETHING_ELSE, pnd.getParameterNames((Constructor<?>) null))).isTrue();
assertThat(pnd.getParameterNames(anyMethod)).containsExactly(SOMETHING_ELSE);
assertThat(pnd.getParameterNames((Constructor<?>) null)).containsExactly(SOMETHING_ELSE);
pnd.addDiscoverer(returnsFooBar);
assertThat(Arrays.equals(SOMETHING_ELSE, pnd.getParameterNames(anyMethod))).isTrue();
assertThat(Arrays.equals(SOMETHING_ELSE, pnd.getParameterNames((Constructor<?>) null))).isTrue();
assertThat(pnd.getParameterNames(anyMethod)).containsExactly(SOMETHING_ELSE);
assertThat(pnd.getParameterNames((Constructor<?>) null)).containsExactly(SOMETHING_ELSE);
}
}
spring-core/src/test/java/org/springframework/core/ResolvableTypeTests.java
+3 -3
View File
@@ -1256,9 +1256,9 @@ class ResolvableTypeTests {
ResolvableType arg1 = ResolvableType.forMethodParameter(method, 1, ClassArguments.class);
ResolvableType arg2 = ResolvableType.forMethodParameter(method, 2, ClassArguments.class);
assertThat(returnType.getType().equals(arg0.as(Class.class).getGeneric(0).getType())).isTrue();
assertThat(returnType.getType().equals(arg1.as(Class.class).getGeneric(0).getType())).isFalse();
assertThat(returnType.getType().equals(arg2.as(Class.class).getGeneric(0).getType())).isFalse();
assertThat(returnType.getType()).isEqualTo(arg0.as(Class.class).getGeneric(0).getType());
assertThat(returnType.getType()).isNotEqualTo(arg1.as(Class.class).getGeneric(0).getType());
assertThat(returnType.getType()).isNotEqualTo(arg2.as(Class.class).getGeneric(0).getType());
}
@Test
spring-core/src/test/java/org/springframework/core/annotation/AnnotatedElementUtilsTests.java
+1 -2
View File
@@ -663,8 +663,7 @@ class AnnotatedElementUtilsTests {
}
}
assertThat(bridgeMethod != null && bridgeMethod.isBridge()).isTrue();
boolean condition = bridgedMethod != null && !bridgedMethod.isBridge();
assertThat(condition).isTrue();
assertThat(bridgedMethod != null && !bridgedMethod.isBridge()).isTrue();
AnnotationAttributes attributes = findMergedAnnotationAttributes(bridgeMethod, Order.class);
assertThat(attributes).as("Should find @Order on StringGenericParameter.getFor() bridge method").isNotNull();
spring-core/src/test/java/org/springframework/core/annotation/AnnotationAttributesTests.java
+1 -1
View File
@@ -63,7 +63,7 @@ class AnnotationAttributesTests {
assertThat(attributes.getBoolean("bool1")).isTrue();
assertThat(attributes.getBoolean("bool2")).isFalse();
assertThat(attributes.<Color>getEnum("color")).isEqualTo(Color.RED);
assertThat(attributes.getClass("class").equals(Integer.class)).isTrue();
assertThat(attributes.getClass("class")).isEqualTo(Integer.class);
assertThat(attributes.getClassArray("classes")).isEqualTo(new Class<?>[] {Number.class, Short.class, Integer.class});
assertThat(attributes.<Integer>getNumber("number")).isEqualTo(42);
assertThat(attributes.getAnnotation("anno").<Integer>getNumber("value")).isEqualTo(10);
spring-core/src/test/java/org/springframework/core/convert/support/CollectionToCollectionConverterTests.java
+6 -6
View File
@@ -40,6 +40,7 @@ import org.springframework.core.io.Resource;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.InstanceOfAssertFactories.LIST;
/**
* @author Keith Donald
@@ -181,12 +182,11 @@ class CollectionToCollectionConverterTests {
}
@SuppressWarnings("rawtypes")
private void testCollectionConversionToArrayList(Collection<String> aSource) {
Object myConverted = (new CollectionToCollectionConverter(new GenericConversionService())).convert(
aSource, TypeDescriptor.forObject(aSource), TypeDescriptor.forObject(new ArrayList()));
boolean condition = myConverted instanceof ArrayList<?>;
assertThat(condition).isTrue();
assertThat(((ArrayList<?>) myConverted)).hasSameSizeAs(aSource);
private void testCollectionConversionToArrayList(Collection<String> source) {
CollectionToCollectionConverter converter = new CollectionToCollectionConverter(new GenericConversionService());
Object convertedValue = converter.convert(
source, TypeDescriptor.forObject(source), TypeDescriptor.forObject(new ArrayList()));
assertThat(convertedValue).asInstanceOf(LIST).hasSameSizeAs(source);
}
@Test
spring-core/src/test/java/org/springframework/core/convert/support/GenericConversionServiceTests.java
+1 -1
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))).isEmpty();
assertThat((String[]) conversionService.convert(list, sourceType, targetType)).isEmpty();
}
@Test
spring-core/src/test/java/org/springframework/core/type/AnnotationMetadataTests.java
+6 -6
View File
@@ -433,33 +433,33 @@ class AnnotationMetadataTests {
AnnotationAttributes specialAttrs = (AnnotationAttributes) metadata.getAnnotationAttributes(SpecialAttr.class.getName());
assertThat(specialAttrs).hasSize(6);
assertThat(String.class.isAssignableFrom(specialAttrs.getClass("clazz"))).isTrue();
assertThat(specialAttrs.getEnum("state").equals(Thread.State.NEW)).isTrue();
assertThat((Enum<?>) specialAttrs.getEnum("state")).isEqualTo(Thread.State.NEW);
AnnotationAttributes nestedAnno = specialAttrs.getAnnotation("nestedAnno");
assertThat(nestedAnno.getString("value")).isEqualTo("na");
assertThat(nestedAnno.getEnum("anEnum").equals(SomeEnum.LABEL1)).isTrue();
assertThat((Enum<?>) nestedAnno.getEnum("anEnum")).isEqualTo(SomeEnum.LABEL1);
assertThat((Class<?>[]) nestedAnno.get("classArray")).isEqualTo(new Class<?>[] {String.class});
AnnotationAttributes[] nestedAnnoArray = specialAttrs.getAnnotationArray("nestedAnnoArray");
assertThat(nestedAnnoArray).hasSize(2);
assertThat(nestedAnnoArray[0].getString("value")).isEqualTo("default");
assertThat(nestedAnnoArray[0].getEnum("anEnum").equals(SomeEnum.DEFAULT)).isTrue();
assertThat((Enum<?>) nestedAnnoArray[0].getEnum("anEnum")).isEqualTo(SomeEnum.DEFAULT);
assertThat((Class<?>[]) nestedAnnoArray[0].get("classArray")).isEqualTo(new Class<?>[] {Void.class});
assertThat(nestedAnnoArray[1].getString("value")).isEqualTo("na1");
assertThat(nestedAnnoArray[1].getEnum("anEnum").equals(SomeEnum.LABEL2)).isTrue();
assertThat((Enum<?>) nestedAnnoArray[1].getEnum("anEnum")).isEqualTo(SomeEnum.LABEL2);
assertThat((Class<?>[]) nestedAnnoArray[1].get("classArray")).isEqualTo(new Class<?>[] {Number.class});
assertThat(nestedAnnoArray[1].getClassArray("classArray")).isEqualTo(new Class<?>[] {Number.class});
AnnotationAttributes optional = specialAttrs.getAnnotation("optional");
assertThat(optional.getString("value")).isEqualTo("optional");
assertThat(optional.getEnum("anEnum").equals(SomeEnum.DEFAULT)).isTrue();
assertThat((Enum<?>) optional.getEnum("anEnum")).isEqualTo(SomeEnum.DEFAULT);
assertThat((Class<?>[]) optional.get("classArray")).isEqualTo(new Class<?>[] {Void.class});
assertThat(optional.getClassArray("classArray")).isEqualTo(new Class<?>[] {Void.class});
AnnotationAttributes[] optionalArray = specialAttrs.getAnnotationArray("optionalArray");
assertThat(optionalArray).hasSize(1);
assertThat(optionalArray[0].getString("value")).isEqualTo("optional");
assertThat(optionalArray[0].getEnum("anEnum").equals(SomeEnum.DEFAULT)).isTrue();
assertThat((Enum<?>) optionalArray[0].getEnum("anEnum")).isEqualTo(SomeEnum.DEFAULT);
assertThat((Class<?>[]) optionalArray[0].get("classArray")).isEqualTo(new Class<?>[] {Void.class});
assertThat(optionalArray[0].getClassArray("classArray")).isEqualTo(new Class<?>[] {Void.class});
spring-core/src/test/java/org/springframework/util/AutoPopulatingListTests.java
+5 -10
View File
@@ -57,8 +57,7 @@ class AutoPopulatingListTests {
for (int x = 0; x < 10; x++) {
Object element = list.get(x);
assertThat(list.get(x)).as("Element is null").isNotNull();
boolean condition = element instanceof TestObject;
assertThat(condition).as("Element is incorrect type").isTrue();
assertThat(element).as("Element is incorrect type").isInstanceOf(TestObject.class);
assertThat(element).isNotSameAs(lastElement);
lastElement = element;
}
@@ -68,14 +67,10 @@ class AutoPopulatingListTests {
list.add(11, helloWorld);
assertThat(list).element(11, InstanceOfAssertFactories.STRING).isEqualTo(helloWorld);
boolean condition3 = list.get(10) instanceof TestObject;
assertThat(condition3).isTrue();
boolean condition2 = list.get(12) instanceof TestObject;
assertThat(condition2).isTrue();
boolean condition1 = list.get(13) instanceof TestObject;
assertThat(condition1).isTrue();
boolean condition = list.get(20) instanceof TestObject;
assertThat(condition).isTrue();
assertThat(list.get(10)).isInstanceOf(TestObject.class);
assertThat(list.get(12)).isInstanceOf(TestObject.class);
assertThat(list.get(13)).isInstanceOf(TestObject.class);
assertThat(list.get(20)).isInstanceOf(TestObject.class);
}
private void doTestWithElementFactory(AutoPopulatingList<Object> list) {
spring-core/src/test/java/org/springframework/util/ClassUtilsTests.java
+2 -2
View File
@@ -944,11 +944,11 @@ class ClassUtilsTests {
}
private static void assertNotPublic(Member member) {
assertThat(!isPublic(member)).as("%s must be not be public", member).isTrue();
assertThat(isPublic(member)).as("%s must be not be public", member).isFalse();
}
private static void assertNotPublic(Class<?> clazz) {
assertThat(!isPublic(clazz)).as("%s must be not be public", clazz).isTrue();
assertThat(isPublic(clazz)).as("%s must be not be public", clazz).isFalse();
}
private static boolean isPublic(Class<?> clazz) {
spring-core/src/test/java/org/springframework/util/CompositeSetTests.java
+4 -4
View File
@@ -38,10 +38,10 @@ class CompositeSetTests {
Set<String> all = new HashSet<>(first);
all.addAll(second);
assertThat(composite.equals(all)).isTrue();
assertThat(composite.equals(first)).isFalse();
assertThat(composite.equals(second)).isFalse();
assertThat(composite.equals(Collections.emptySet())).isFalse();
assertThat(composite).isEqualTo(all);
assertThat(composite).isNotEqualTo(first);
assertThat(composite).isNotEqualTo(second);
assertThat(composite).isNotEqualTo(Collections.emptySet());
}
}
spring-core/src/test/java/org/springframework/util/FileCopyUtilsTests.java
+3 -4
View File
@@ -21,7 +21,6 @@ import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.Arrays;
import org.junit.jupiter.api.Test;
@@ -42,7 +41,7 @@ class FileCopyUtilsTests {
ByteArrayOutputStream out = new ByteArrayOutputStream(content.length);
int count = FileCopyUtils.copy(in, out);
assertThat(count).isEqualTo(content.length);
assertThat(Arrays.equals(content, out.toByteArray())).isTrue();
assertThat(out.toByteArray()).isEqualTo(content);
}
@Test
@@ -50,7 +49,7 @@ class FileCopyUtilsTests {
byte[] content = "content".getBytes();
ByteArrayOutputStream out = new ByteArrayOutputStream(content.length);
FileCopyUtils.copy(content, out);
assertThat(Arrays.equals(content, out.toByteArray())).isTrue();
assertThat(out.toByteArray()).isEqualTo(content);
}
@Test
@@ -58,7 +57,7 @@ class FileCopyUtilsTests {
byte[] content = "content".getBytes();
ByteArrayInputStream in = new ByteArrayInputStream(content);
byte[] result = FileCopyUtils.copyToByteArray(in);
assertThat(Arrays.equals(content, result)).isTrue();
assertThat(result).isEqualTo(content);
}
@Test
spring-core/src/test/java/org/springframework/util/FilteredSetTests.java
+3 -3
View File
@@ -35,8 +35,8 @@ class FilteredSetTests {
Set<String> expected = Set.of("foo", "baz");
assertThat(filtered.equals(expected)).isTrue();
assertThat(filtered.equals(set)).isFalse();
assertThat(filtered.equals(Collections.emptySet())).isFalse();
assertThat(filtered).isEqualTo(expected);
assertThat(filtered).isNotEqualTo(set);
assertThat(filtered).isNotEqualTo(Collections.emptySet());
}
}
spring-core/src/test/java/org/springframework/util/StringUtilsTests.java
+44 -62
View File
@@ -16,7 +16,6 @@
package org.springframework.util;
import java.util.Arrays;
import java.util.Collections;
import java.util.Locale;
import java.util.Properties;
@@ -515,120 +514,106 @@ class StringUtilsTests {
@Test
void tokenizeToStringArray() {
String[] sa = StringUtils.tokenizeToStringArray("a,b , ,c", ",");
assertThat(sa).hasSize(3);
assertThat(sa[0].equals("a") && sa[1].equals("b") && sa[2].equals("c")).as("components are correct").isTrue();
String[] array = StringUtils.tokenizeToStringArray("a,b , ,c", ",");
assertThat(array).containsExactly("a", "b", "c");
}
@Test
void tokenizeToStringArrayWithNotIgnoreEmptyTokens() {
String[] sa = StringUtils.tokenizeToStringArray("a,b , ,c", ",", true, false);
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();
String[] array = StringUtils.tokenizeToStringArray("a,b , ,c", ",", true, false);
assertThat(array).containsExactly("a", "b", "", "c");
}
@Test
void tokenizeToStringArrayWithNotTrimTokens() {
String[] sa = StringUtils.tokenizeToStringArray("a,b ,c", ",", false, true);
assertThat(sa).hasSize(3);
assertThat(sa[0].equals("a") && sa[1].equals("b ") && sa[2].equals("c")).as("components are correct").isTrue();
String[] array = StringUtils.tokenizeToStringArray("a,b ,c", ",", false, true);
assertThat(array).containsExactly("a", "b ", "c");
}
@Test
void commaDelimitedListToStringArrayWithNullProducesEmptyArray() {
String[] sa = StringUtils.commaDelimitedListToStringArray(null);
assertThat(sa).as("String array isn't null with null input").isNotNull();
assertThat(sa.length).as("String array length == 0 with null input").isEqualTo(0);
String[] array = StringUtils.commaDelimitedListToStringArray(null);
assertThat(array).isEmpty();
}
@Test
void commaDelimitedListToStringArrayWithEmptyStringProducesEmptyArray() {
String[] sa = StringUtils.commaDelimitedListToStringArray("");
assertThat(sa).as("String array isn't null with null input").isNotNull();
assertThat(sa.length).as("String array length == 0 with null input").isEqualTo(0);
String[] array = StringUtils.commaDelimitedListToStringArray("");
assertThat(array).isEmpty();
}
@Test
void delimitedListToStringArrayWithComma() {
String[] sa = StringUtils.delimitedListToStringArray("a,b", ",");
assertThat(sa).hasSize(2);
assertThat(sa[0]).isEqualTo("a");
assertThat(sa[1]).isEqualTo("b");
String[] array = StringUtils.delimitedListToStringArray("a,b", ",");
assertThat(array).containsExactly("a", "b");
}
@Test
void delimitedListToStringArrayWithSemicolon() {
String[] sa = StringUtils.delimitedListToStringArray("a;b", ";");
assertThat(sa).hasSize(2);
assertThat(sa[0]).isEqualTo("a");
assertThat(sa[1]).isEqualTo("b");
String[] array = StringUtils.delimitedListToStringArray("a;b", ";");
assertThat(array).containsExactly("a", "b");
}
@Test
void delimitedListToStringArrayWithEmptyDelimiter() {
String[] sa = StringUtils.delimitedListToStringArray("a,b", "");
assertThat(sa).hasSize(3);
assertThat(sa[0]).isEqualTo("a");
assertThat(sa[1]).isEqualTo(",");
assertThat(sa[2]).isEqualTo("b");
String[] array = StringUtils.delimitedListToStringArray("a,b", "");
assertThat(array).containsExactly("a", ",", "b");
}
@Test
void delimitedListToStringArrayWithNullDelimiter() {
String[] sa = StringUtils.delimitedListToStringArray("a,b", null);
assertThat(sa).hasSize(1);
assertThat(sa[0]).isEqualTo("a,b");
String[] array = StringUtils.delimitedListToStringArray("a,b", null);
assertThat(array).containsExactly("a,b");
}
@Test
void delimitedListToStringArrayWithCharacterToDelete() {
String[] sa = StringUtils.delimitedListToStringArray("a,b,c", ",", "a");
assertThat(sa).containsExactly("", "b", "c");
String[] array = StringUtils.delimitedListToStringArray("a,b,c", ",", "a");
assertThat(array).containsExactly("", "b", "c");
}
@Test
void delimitedListToStringArrayWithCharacterToDeleteEqualsToDelimiter() {
String[] sa = StringUtils.delimitedListToStringArray("a,b,c", ",", ",");
assertThat(sa).containsExactly("a", "b", "c");
String[] array = StringUtils.delimitedListToStringArray("a,b,c", ",", ",");
assertThat(array).containsExactly("a", "b", "c");
}
@Test
void commaDelimitedListToStringArrayMatchWords() {
// Could read these from files
String[] sa = new String[] {"foo", "bar", "big"};
doTestCommaDelimitedListToStringArrayLegalMatch(sa);
doTestStringArrayReverseTransformationMatches(sa);
String[] array = new String[] {"foo", "bar", "big"};
doTestCommaDelimitedListToStringArrayLegalMatch(array);
doTestStringArrayReverseTransformationMatches(array);
sa = new String[] {"a", "b", "c"};
doTestCommaDelimitedListToStringArrayLegalMatch(sa);
doTestStringArrayReverseTransformationMatches(sa);
array = new String[] {"a", "b", "c"};
doTestCommaDelimitedListToStringArrayLegalMatch(array);
doTestStringArrayReverseTransformationMatches(array);
// Test same words
sa = new String[] {"AA", "AA", "AA", "AA", "AA"};
doTestCommaDelimitedListToStringArrayLegalMatch(sa);
doTestStringArrayReverseTransformationMatches(sa);
array = new String[] {"AA", "AA", "AA", "AA", "AA"};
doTestCommaDelimitedListToStringArrayLegalMatch(array);
doTestStringArrayReverseTransformationMatches(array);
}
private void doTestStringArrayReverseTransformationMatches(String[] sa) {
private void doTestStringArrayReverseTransformationMatches(String[] array) {
String[] reverse =
StringUtils.commaDelimitedListToStringArray(StringUtils.arrayToCommaDelimitedString(sa));
assertThat(Arrays.asList(reverse)).as("Reverse transformation is equal").isEqualTo(Arrays.asList(sa));
StringUtils.commaDelimitedListToStringArray(StringUtils.arrayToCommaDelimitedString(array));
assertThat(reverse).as("Reverse transformation is equal").isEqualTo(array);
}
@Test
void commaDelimitedListToStringArraySingleString() {
// Could read these from files
String s = "woeirqupoiewuropqiewuorpqiwueopriquwopeiurqopwieur";
String[] sa = StringUtils.commaDelimitedListToStringArray(s);
assertThat(sa.length).as("Found one String with no delimiters").isEqualTo(1);
assertThat(sa[0]).as("Single array entry matches input String with no delimiters").isEqualTo(s);
String[] array = StringUtils.commaDelimitedListToStringArray(s);
assertThat(array).as("Single array entry matches input String with no delimiters").containsExactly(s);
}
@Test
void commaDelimitedListToStringArrayWithOtherPunctuation() {
// Could read these from files
String[] sa = new String[] {"xcvwert4456346&*.", "///", ".!", ".", ";"};
doTestCommaDelimitedListToStringArrayLegalMatch(sa);
String[] array = new String[] {"xcvwert4456346&*.", "///", ".!", ".", ";"};
doTestCommaDelimitedListToStringArrayLegalMatch(array);
}
/**
@@ -637,20 +622,17 @@ class StringUtilsTests {
@Test
void commaDelimitedListToStringArrayEmptyStrings() {
// Could read these from files
String[] sa = StringUtils.commaDelimitedListToStringArray("a,,b");
assertThat(sa.length).as("a,,b produces array length 3").isEqualTo(3);
assertThat(sa[0].equals("a") && sa[1].isEmpty() && sa[2].equals("b")).as("components are correct").isTrue();
String[] array = StringUtils.commaDelimitedListToStringArray("a,,b");
assertThat(array).containsExactly("a", "", "b");
sa = new String[] {"", "", "a", ""};
doTestCommaDelimitedListToStringArrayLegalMatch(sa);
array = new String[] {"", "", "a", ""};
doTestCommaDelimitedListToStringArrayLegalMatch(array);
}
private void doTestCommaDelimitedListToStringArrayLegalMatch(String[] components) {
String sb = String.join(String.valueOf(','), components);
String[] sa = StringUtils.commaDelimitedListToStringArray(sb);
assertThat(sa).as("String array isn't null with legal match").isNotNull();
assertThat(sa.length).as("String array length is correct with legal match").isEqualTo(components.length);
assertThat(Arrays.equals(sa, components)).as("Output equals input").isTrue();
String[] array = StringUtils.commaDelimitedListToStringArray(sb);
assertThat(array).as("Output equals input").isEqualTo(components);
}
spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java
+14 -14
View File
@@ -886,10 +886,10 @@ class EvaluationTests extends AbstractExpressionTests {
// BigDecimal
e = parser.parseExpression("bd++");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("2")).isEqualTo(helper.bd);
BigDecimal return_bd = e.getValue(ctx, BigDecimal.class);
assertThat(new BigDecimal("2")).isEqualTo(return_bd);
assertThat(new BigDecimal("3").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("3")).isEqualTo(helper.bd);
// double
e = parser.parseExpression("ddd++");
@@ -939,10 +939,10 @@ class EvaluationTests extends AbstractExpressionTests {
// BigDecimal
e = parser.parseExpression("++bd");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("2")).isEqualTo(helper.bd);
BigDecimal return_bd = e.getValue(ctx, BigDecimal.class);
assertThat(new BigDecimal("3")).isEqualTo(return_bd);
assertThat(new BigDecimal("3").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("3")).isEqualTo(helper.bd);
// double
e = parser.parseExpression("++ddd");
@@ -1036,10 +1036,10 @@ class EvaluationTests extends AbstractExpressionTests {
// BigDecimal
e = parser.parseExpression("bd--");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("2")).isEqualTo(helper.bd);
BigDecimal return_bd = e.getValue(ctx,BigDecimal.class);
assertThat(new BigDecimal("2")).isEqualTo(return_bd);
assertThat(new BigDecimal("1").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("1")).isEqualTo(helper.bd);
// double
e = parser.parseExpression("ddd--");
@@ -1089,10 +1089,10 @@ class EvaluationTests extends AbstractExpressionTests {
// BigDecimal
e = parser.parseExpression("--bd");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("2")).isEqualTo(helper.bd);
BigDecimal return_bd = e.getValue(ctx,BigDecimal.class);
assertThat(new BigDecimal("1")).isEqualTo(return_bd);
assertThat(new BigDecimal("1").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("1")).isEqualTo(helper.bd);
// double
e = parser.parseExpression("--ddd");
@@ -1439,22 +1439,22 @@ class EvaluationTests extends AbstractExpressionTests {
ctx.setVariable("wobble", 3);
e = parser.parseExpression("#wobble++");
assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(3);
assertThat((Integer) ctx.lookupVariable("wobble")).isEqualTo(3);
int r = e.getValue(ctx, int.class);
assertThat(r).isEqualTo(3);
assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(4);
assertThat((Integer) ctx.lookupVariable("wobble")).isEqualTo(4);
e = parser.parseExpression("--#wobble");
assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(4);
assertThat((Integer) ctx.lookupVariable("wobble")).isEqualTo(4);
r = e.getValue(ctx, int.class);
assertThat(r).isEqualTo(3);
assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(3);
assertThat((Integer) ctx.lookupVariable("wobble")).isEqualTo(3);
e = parser.parseExpression("#wobble=34");
assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(3);
assertThat((Integer) ctx.lookupVariable("wobble")).isEqualTo(3);
r = e.getValue(ctx, int.class);
assertThat(r).isEqualTo(34);
assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(34);
assertThat((Integer) ctx.lookupVariable("wobble")).isEqualTo(34);
// Projection
expectFailNotIncrementable(parser, ctx, "({1,2,3}.![#isEven(#this)])++"); // projection would be {false,true,false}
spring-jdbc/src/test/java/org/springframework/jdbc/core/JdbcTemplateQueryTests.java
+7 -7
View File
@@ -87,8 +87,8 @@ class JdbcTemplateQueryTests {
given(this.resultSet.getObject(1)).willReturn(11, 12);
List<Map<String, Object>> li = this.template.queryForList(sql);
assertThat(li).as("All rows returned").hasSize(2);
assertThat(((Integer) li.get(0).get("age"))).as("First row is Integer").isEqualTo(11);
assertThat(((Integer) li.get(1).get("age"))).as("Second row is Integer").isEqualTo(12);
assertThat((Integer) li.get(0).get("age")).as("First row is Integer").isEqualTo(11);
assertThat((Integer) li.get(1).get("age")).as("Second row is Integer").isEqualTo(12);
verify(this.resultSet).close();
verify(this.statement).close();
verify(this.connection).close();
@@ -112,7 +112,7 @@ class JdbcTemplateQueryTests {
given(this.resultSet.getObject(1)).willReturn(11);
List<Map<String, Object>> li = this.template.queryForList(sql);
assertThat(li).as("All rows returned").hasSize(1);
assertThat(((Integer) li.get(0).get("age"))).as("First row is Integer").isEqualTo(11);
assertThat((Integer) li.get(0).get("age")).as("First row is Integer").isEqualTo(11);
verify(this.resultSet).close();
verify(this.statement).close();
verify(this.connection).close();
@@ -303,8 +303,8 @@ class JdbcTemplateQueryTests {
given(this.resultSet.getObject(1)).willReturn(11, 12);
List<Map<String, Object>> li = this.template.queryForList(sql, 3);
assertThat(li).as("All rows returned").hasSize(2);
assertThat(((Integer) li.get(0).get("age"))).as("First row is Integer").isEqualTo(11);
assertThat(((Integer) li.get(1).get("age"))).as("Second row is Integer").isEqualTo(12);
assertThat((Integer) li.get(0).get("age")).as("First row is Integer").isEqualTo(11);
assertThat((Integer) li.get(1).get("age")).as("Second row is Integer").isEqualTo(12);
verify(this.preparedStatement).setObject(1, 3);
verify(this.resultSet).close();
verify(this.preparedStatement).close();
@@ -330,7 +330,7 @@ class JdbcTemplateQueryTests {
given(this.resultSet.getObject(1)).willReturn(11);
List<Map<String, Object>> li = this.template.queryForList(sql, 3);
assertThat(li).as("All rows returned").hasSize(1);
assertThat(((Integer) li.get(0).get("age"))).as("First row is Integer").isEqualTo(11);
assertThat((Integer) li.get(0).get("age")).as("First row is Integer").isEqualTo(11);
verify(this.preparedStatement).setObject(1, 3);
verify(this.resultSet).close();
verify(this.preparedStatement).close();
@@ -356,7 +356,7 @@ class JdbcTemplateQueryTests {
given(this.resultSet.next()).willReturn(true, false);
given(this.resultSet.getObject(1)).willReturn(11);
Map<String, Object> map = this.template.queryForMap(sql, 3);
assertThat(((Integer) map.get("age"))).as("Row is Integer").isEqualTo(11);
assertThat((Integer) map.get("age")).as("Row is Integer").isEqualTo(11);
verify(this.preparedStatement).setObject(1, 3);
verify(this.resultSet).close();
verify(this.preparedStatement).close();
spring-jdbc/src/test/java/org/springframework/jdbc/core/JdbcTemplateTests.java
+2 -4
View File
@@ -114,8 +114,7 @@ class JdbcTemplateTests {
assertThat(this.template.getDataSource()).as("datasource ok").isSameAs(this.dataSource);
assertThat(this.template.isIgnoreWarnings()).as("ignores warnings by default").isTrue();
this.template.setIgnoreWarnings(false);
boolean condition = !this.template.isIgnoreWarnings();
assertThat(condition).as("can set NOT to ignore warnings").isTrue();
assertThat(this.template.isIgnoreWarnings()).as("can set NOT to ignore warnings").isFalse();
}
@Test
@@ -1123,8 +1122,7 @@ class JdbcTemplateTests {
given(this.callableStatement.getUpdateCount()).willReturn(-1);
given(this.callableStatement.getObject(1)).willReturn("X");
boolean condition = !this.template.isResultsMapCaseInsensitive();
assertThat(condition).as("default should have been NOT case insensitive").isTrue();
assertThat(this.template.isResultsMapCaseInsensitive()).as("default should have been NOT case insensitive").isFalse();
this.template.setResultsMapCaseInsensitive(true);
assertThat(this.template.isResultsMapCaseInsensitive()).as("now it should have been set to case insensitive").isTrue();
spring-jdbc/src/test/java/org/springframework/jdbc/core/simple/CallMetaDataContextTests.java
+1 -2
View File
@@ -94,8 +94,7 @@ class CallMetaDataContextTests {
assertThat(inParameters).as("Wrong number of matched in parameter values").hasSize(2);
assertThat(inParameters.containsKey("id")).as("in parameter value missing").isTrue();
assertThat(inParameters.containsKey("name")).as("in out parameter value missing").isTrue();
boolean condition = !inParameters.containsKey("customer_no");
assertThat(condition).as("out parameter value matched").isTrue();
assertThat(inParameters.containsKey("customer_no")).as("out parameter value matched").isFalse();
List<String> names = context.getOutParameterNames();
assertThat(names).as("Wrong number of out parameters").hasSize(2);
spring-jdbc/src/test/java/org/springframework/jdbc/core/simple/TableMetaDataContextTests.java
+4 -8
View File
@@ -104,14 +104,10 @@ class TableMetaDataContextTests {
List<Object> values = context.matchInParameterValuesWithInsertColumns(map);
assertThat(values.size()).as("wrong number of parameters: ").isEqualTo(4);
boolean condition3 = values.get(0) instanceof Number;
assertThat(condition3).as("id not wrapped with type info").isTrue();
boolean condition2 = values.get(1) instanceof String;
assertThat(condition2).as("name not wrapped with type info").isTrue();
boolean condition1 = values.get(2) instanceof SqlParameterValue;
assertThat(condition1).as("date wrapped with type info").isTrue();
boolean condition = values.get(3) instanceof SqlParameterValue;
assertThat(condition).as("version wrapped with type info").isTrue();
assertThat(values.get(0)).as("id not wrapped with type info").isInstanceOf(Number.class);
assertThat(values.get(1)).as("name not wrapped with type info").isInstanceOf(String.class);
assertThat(values.get(2)).as("date wrapped with type info").isInstanceOf(SqlParameterValue.class);
assertThat(values.get(3)).as("version wrapped with type info").isInstanceOf(SqlParameterValue.class);
verify(metaDataResultSet, atLeastOnce()).next();
verify(columnsResultSet, atLeastOnce()).next();
verify(metaDataResultSet).close();
spring-jms/src/test/java/org/springframework/jms/annotation/JmsListenerAnnotationBeanPostProcessorTests.java
+2 -4
View File
@@ -107,8 +107,7 @@ class JmsListenerAnnotationBeanPostProcessorTests {
assertThat(endpoint.getClass()).as("Wrong endpoint type").isEqualTo(MethodJmsListenerEndpoint.class);
MethodJmsListenerEndpoint methodEndpoint = (MethodJmsListenerEndpoint) endpoint;
assertThat(AopUtils.isJdkDynamicProxy(methodEndpoint.getBean())).isTrue();
boolean condition = methodEndpoint.getBean() instanceof SimpleService;
assertThat(condition).isTrue();
assertThat(methodEndpoint.getBean()).isInstanceOf(SimpleService.class);
assertThat(methodEndpoint.getMethod()).isEqualTo(SimpleService.class.getMethod("handleIt", String.class, String.class));
assertThat(methodEndpoint.getMostSpecificMethod()).isEqualTo(InterfaceProxyTestBean.class.getMethod("handleIt", String.class, String.class));
@@ -129,8 +128,7 @@ class JmsListenerAnnotationBeanPostProcessorTests {
assertThat(endpoint.getClass()).as("Wrong endpoint type").isEqualTo(MethodJmsListenerEndpoint.class);
MethodJmsListenerEndpoint methodEndpoint = (MethodJmsListenerEndpoint) endpoint;
assertThat(AopUtils.isCglibProxy(methodEndpoint.getBean())).isTrue();
boolean condition = methodEndpoint.getBean() instanceof ClassProxyTestBean;
assertThat(condition).isTrue();
assertThat(methodEndpoint.getBean()).isInstanceOf(ClassProxyTestBean.class);
assertThat(methodEndpoint.getMethod()).isEqualTo(ClassProxyTestBean.class.getMethod("handleIt", String.class, String.class));
assertThat(methodEndpoint.getMostSpecificMethod()).isEqualTo(ClassProxyTestBean.class.getMethod("handleIt", String.class, String.class));
spring-jms/src/test/java/org/springframework/jms/config/MethodJmsListenerEndpointTests.java
+1 -1
View File
@@ -474,7 +474,7 @@ class MethodJmsListenerEndpointTests {
private Method getListenerMethod(String methodName, Class<?>... parameterTypes) {
Method method = ReflectionUtils.findMethod(JmsEndpointSampleBean.class, methodName, parameterTypes);
assertThat(("no method found with name " + methodName + " and parameters " + Arrays.toString(parameterTypes))).isNotNull();
assertThat("no method found with name " + methodName + " and parameters " + Arrays.toString(parameterTypes)).isNotNull();
return method;
}
spring-jms/src/test/java/org/springframework/jms/listener/adapter/MessageListenerAdapterTests.java
+2 -4
View File
@@ -170,8 +170,7 @@ class MessageListenerAdapterTests {
@Override
protected void handleListenerException(Throwable ex) {
assertThat(ex).as("The Throwable passed to the handleListenerException(..) method must never be null.").isNotNull();
boolean condition = ex instanceof ListenerExecutionFailedException;
assertThat(condition).as("The Throwable passed to the handleListenerException(..) method must be of type [ListenerExecutionFailedException].").isTrue();
assertThat(ex).as("The Throwable passed to the handleListenerException(..) method must be of type [ListenerExecutionFailedException].").isInstanceOf(ListenerExecutionFailedException.class);
ListenerExecutionFailedException lefx = (ListenerExecutionFailedException) ex;
Throwable cause = lefx.getCause();
assertThat(cause).as("The cause of a ListenerExecutionFailedException must be preserved.").isNotNull();
@@ -187,8 +186,7 @@ class MessageListenerAdapterTests {
void thatTheDefaultMessageConverterisIndeedTheSimpleMessageConverter() {
MessageListenerAdapter adapter = new MessageListenerAdapter();
assertThat(adapter.getMessageConverter()).as("The default [MessageConverter] must never be null.").isNotNull();
boolean condition = adapter.getMessageConverter() instanceof SimpleMessageConverter;
assertThat(condition).as("The default [MessageConverter] must be of the type [SimpleMessageConverter]").isTrue();
assertThat(adapter.getMessageConverter()).as("The default [MessageConverter] must be of the type [SimpleMessageConverter]").isInstanceOf(SimpleMessageConverter.class);
}
@Test
spring-jms/src/test/java/org/springframework/jms/support/SimpleMessageConverterTests.java
+1 -1
View File
@@ -78,7 +78,7 @@ class SimpleMessageConverterTests {
SimpleMessageConverter converter = new SimpleMessageConverter();
Message msg = converter.toMessage(content, session);
assertThat(((byte[]) converter.fromMessage(msg))).hasSize(content.length);
assertThat((byte[]) converter.fromMessage(msg)).hasSize(content.length);
verify(message).writeBytes(content);
}
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/support/DefaultMessageHandlerMethodFactoryTests.java
+1 -1
View File
@@ -190,7 +190,7 @@ class DefaultMessageHandlerMethodFactoryTests {
private Method getListenerMethod(String methodName, Class<?>... parameterTypes) {
Method method = ReflectionUtils.findMethod(SampleBean.class, methodName, parameterTypes);
assertThat(("no method found with name " + methodName + " and parameters " + Arrays.toString(parameterTypes))).isNotNull();
assertThat("no method found with name " + methodName + " and parameters " + Arrays.toString(parameterTypes)).isNotNull();
return method;
}
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/support/HeadersMethodArgumentResolverTests.java
+4 -8
View File
@@ -67,8 +67,7 @@ class HeadersMethodArgumentResolverTests {
MethodParameter param = this.resolvable.annotPresent(Headers.class).arg(Map.class, String.class, Object.class);
Object resolved = this.resolver.resolveArgument(param, this.message);
boolean condition = resolved instanceof Map;
assertThat(condition).isTrue();
assertThat(resolved).isInstanceOf(Map.class);
@SuppressWarnings("unchecked")
Map<String, Object> headers = (Map<String, Object>) resolved;
assertThat(headers.get("foo")).isEqualTo("bar");
@@ -84,8 +83,7 @@ class HeadersMethodArgumentResolverTests {
void resolveArgumentMessageHeaders() throws Exception {
Object resolved = this.resolver.resolveArgument(this.resolvable.arg(MessageHeaders.class), this.message);
boolean condition = resolved instanceof MessageHeaders;
assertThat(condition).isTrue();
assertThat(resolved).isInstanceOf(MessageHeaders.class);
MessageHeaders headers = (MessageHeaders) resolved;
assertThat(headers.get("foo")).isEqualTo("bar");
}
@@ -95,8 +93,7 @@ class HeadersMethodArgumentResolverTests {
MethodParameter param = this.resolvable.arg(MessageHeaderAccessor.class);
Object resolved = this.resolver.resolveArgument(param, this.message);
boolean condition = resolved instanceof MessageHeaderAccessor;
assertThat(condition).isTrue();
assertThat(resolved).isInstanceOf(MessageHeaderAccessor.class);
MessageHeaderAccessor headers = (MessageHeaderAccessor) resolved;
assertThat(headers.getHeader("foo")).isEqualTo("bar");
}
@@ -106,8 +103,7 @@ class HeadersMethodArgumentResolverTests {
MethodParameter param = this.resolvable.arg(TestMessageHeaderAccessor.class);
Object resolved = this.resolver.resolveArgument(param, this.message);
boolean condition = resolved instanceof TestMessageHeaderAccessor;
assertThat(condition).isTrue();
assertThat(resolved).isInstanceOf(TestMessageHeaderAccessor.class);
TestMessageHeaderAccessor headers = (TestMessageHeaderAccessor) resolved;
assertThat(headers.getHeader("foo")).isEqualTo("bar");
}
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/support/MessageMethodArgumentResolverTests.java
+2 -4
View File
@@ -225,11 +225,9 @@ class MessageMethodArgumentResolverTests {
this.resolver = new MessageMethodArgumentResolver(new MappingJackson2MessageConverter());
Object actual = this.resolver.resolveArgument(parameter, inMessage);
boolean condition1 = actual instanceof Message;
assertThat(condition1).isTrue();
assertThat(actual).isInstanceOf(Message.class);
Message<?> outMessage = (Message<?>) actual;
boolean condition = outMessage.getPayload() instanceof Foo;
assertThat(condition).isTrue();
assertThat(outMessage.getPayload()).isInstanceOf(Foo.class);
assertThat(((Foo) outMessage.getPayload()).getFoo()).isEqualTo("bar");
}
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/support/PayloadMethodArgumentResolverTests.java
+1 -1
View File
@@ -133,7 +133,7 @@ class PayloadMethodArgumentResolverTests {
Message<?> emptyStringMessage = MessageBuilder.withPayload(" ").build();
assertThat(this.resolver.resolveArgument(this.paramAnnotatedNotRequired, emptyStringMessage)).isNull();
assertThat(((Optional<?>) this.resolver.resolveArgument(this.paramOptional, emptyStringMessage))).isEmpty();
assertThat((Optional<?>) this.resolver.resolveArgument(this.paramOptional, emptyStringMessage)).isEmpty();
Message<?> emptyOptionalMessage = MessageBuilder.withPayload(Optional.empty()).build();
assertThat(this.resolver.resolveArgument(this.paramAnnotatedNotRequired, emptyOptionalMessage)).isNull();
spring-orm/src/test/java/org/springframework/orm/jpa/AbstractEntityManagerFactoryBeanTests.java
+1 -1
View File
@@ -56,7 +56,7 @@ public abstract class AbstractEntityManagerFactoryBeanTests {
protected void checkInvariants(AbstractEntityManagerFactoryBean emfb) {
assertThat(EntityManagerFactory.class.isAssignableFrom(emfb.getObjectType())).isTrue();
EntityManagerFactory emf = emfb.getObject();
assertThat(emf instanceof EntityManagerFactoryInfo).as("Object created by factory implements EntityManagerFactoryInfo").isTrue();
assertThat(emf).as("Object created by factory implements EntityManagerFactoryInfo").isInstanceOf(EntityManagerFactoryInfo.class);
EntityManagerFactoryInfo emfi = (EntityManagerFactoryInfo) emf;
assertThat(emfb.getObject()).as("Successive invocations of getObject() return same object").isSameAs(emfi);
assertThat(emfb.getObject()).isSameAs(emfi);
spring-oxm/src/test/java/org/springframework/oxm/AbstractMarshallerTests.java
+1 -2
View File
@@ -96,8 +96,7 @@ public abstract class AbstractMarshallerTests<M extends Marshaller> {
DocumentBuilder builder = documentBuilderFactory.newDocumentBuilder();
DOMResult domResult = new DOMResult();
marshaller.marshal(flights, domResult);
boolean condition = domResult.getNode() instanceof Document;
assertThat(condition).as("DOMResult does not contain a Document").isTrue();
assertThat(domResult.getNode()).as("DOMResult does not contain a Document").isInstanceOf(Document.class);
Document result = (Document) domResult.getNode();
Document expected = builder.newDocument();
Element flightsElement = expected.createElementNS("http://samples.springframework.org/flight", "tns:flights");
spring-test/src/test/java/org/springframework/mock/web/MockHttpServletRequestTests.java
+1 -1
View File
@@ -356,7 +356,7 @@ class MockHttpServletRequestTests {
Locale.setDefault(newDefaultLocale);
// Create the request after changing the default locale.
MockHttpServletRequest request = new MockHttpServletRequest();
assertThat(newDefaultLocale.equals(request.getLocale())).isFalse();
assertThat(newDefaultLocale).isNotEqualTo(request.getLocale());
assertThat(request.getLocale()).isEqualTo(Locale.ENGLISH);
}
finally {
spring-test/src/test/java/org/springframework/test/context/bean/override/BeanOverrideHandlerTests.java
+1 -2
View File
@@ -21,7 +21,6 @@ import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.function.Consumer;
@@ -180,7 +179,7 @@ class BeanOverrideHandlerTests {
Field field2 = field(ConfigB.class, "qualifiedDummyBean");
// Prerequisite
assertThat(Arrays.equals(field1.getAnnotations(), field2.getAnnotations())).isFalse();
assertThat(field1.getAnnotations()).isNotEqualTo(field2.getAnnotations());
BeanOverrideHandler handler1 = createBeanOverrideHandler(field1);
BeanOverrideHandler handler2 = createBeanOverrideHandler(field2);
spring-tx/src/test/java/org/springframework/transaction/JndiJtaTransactionManagerTests.java
+6 -12
View File
@@ -92,15 +92,13 @@ class JndiJtaTransactionManagerTests {
assertThat(ptm.getUserTransaction()).isEqualTo(ut);
}
else {
boolean condition = ptm.getUserTransaction() instanceof UserTransactionAdapter;
assertThat(condition).isTrue();
assertThat(ptm.getUserTransaction()).isInstanceOf(UserTransactionAdapter.class);
UserTransactionAdapter uta = (UserTransactionAdapter) ptm.getUserTransaction();
assertThat(uta.getTransactionManager()).isEqualTo(tm);
}
TransactionTemplate tt = new TransactionTemplate(ptm);
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -110,8 +108,7 @@ class JndiJtaTransactionManagerTests {
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
});
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
@@ -146,8 +143,7 @@ class JndiJtaTransactionManagerTests {
assertThat(ptm.getTransactionManager()).isEqualTo(tm);
TransactionTemplate tt = new TransactionTemplate(ptm);
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -157,8 +153,7 @@ class JndiJtaTransactionManagerTests {
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
});
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
verify(ut).begin();
@@ -182,8 +177,7 @@ class JndiJtaTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(ptm);
assertThat(ptm.getTransactionSynchronization()).isEqualTo(JtaTransactionManager.SYNCHRONIZATION_ALWAYS);
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
spring-tx/src/test/java/org/springframework/transaction/interceptor/TransactionInterceptorTests.java
+4 -4
View File
@@ -116,11 +116,11 @@ class TransactionInterceptorTests extends AbstractTransactionAspectTests {
ti.setTransactionManager(ptm);
ti = SerializationTestUtils.serializeAndDeserialize(ti);
assertThat(ti.getTransactionManager() instanceof SerializableTransactionManager).isTrue();
assertThat(ti.getTransactionAttributeSource() instanceof CompositeTransactionAttributeSource).isTrue();
assertThat(ti.getTransactionManager()).isInstanceOf(SerializableTransactionManager.class);
assertThat(ti.getTransactionAttributeSource()).isInstanceOf(CompositeTransactionAttributeSource.class);
CompositeTransactionAttributeSource ctas = (CompositeTransactionAttributeSource) ti.getTransactionAttributeSource();
assertThat(ctas.getTransactionAttributeSources()[0] instanceof NameMatchTransactionAttributeSource).isTrue();
assertThat(ctas.getTransactionAttributeSources()[1] instanceof NameMatchTransactionAttributeSource).isTrue();
assertThat(ctas.getTransactionAttributeSources()[0]).isInstanceOf(NameMatchTransactionAttributeSource.class);
assertThat(ctas.getTransactionAttributeSources()[1]).isInstanceOf(NameMatchTransactionAttributeSource.class);
}
@Test
spring-web/src/test/java/org/springframework/http/HttpEntityTests.java
+14 -14
View File
@@ -68,25 +68,25 @@ class HttpEntityTests {
@Test
void equals() {
MultiValueMap<String, String> map1 = new LinkedMultiValueMap<>();
map1.set("Content-Type", "text/plain");
MultiValueMap<String, String> headers1 = new LinkedMultiValueMap<>();
headers1.set("Content-Type", "text/plain");
MultiValueMap<String, String> map2 = new LinkedMultiValueMap<>();
map2.set("Content-Type", "application/json");
MultiValueMap<String, String> headers2 = new LinkedMultiValueMap<>();
headers2.set("Content-Type", "application/json");
assertThat(new HttpEntity<>().equals(new HttpEntity<>())).isTrue();
assertThat(new HttpEntity<>(map1).equals(new HttpEntity<>())).isFalse();
assertThat(new HttpEntity<>().equals(new HttpEntity<>(map2))).isFalse();
assertThat(new HttpEntity<>()).isEqualTo(new HttpEntity<>());
assertThat(new HttpEntity<>(headers1)).isNotEqualTo(new HttpEntity<>());
assertThat(new HttpEntity<>()).isNotEqualTo(new HttpEntity<>(headers2));
assertThat(new HttpEntity<>(map1).equals(new HttpEntity<>(map1))).isTrue();
assertThat(new HttpEntity<>(map1).equals(new HttpEntity<>(map2))).isFalse();
assertThat(new HttpEntity<>(headers1)).isEqualTo(new HttpEntity<>(headers1));
assertThat(new HttpEntity<>(headers1)).isNotEqualTo(new HttpEntity<>(headers2));
assertThat(new HttpEntity<String>(null, null).equals(new HttpEntity<>(null, null))).isTrue();
assertThat(new HttpEntity<>("foo", null).equals(new HttpEntity<>(null, null))).isFalse();
assertThat(new HttpEntity<String>(null, null).equals(new HttpEntity<>("bar", null))).isFalse();
assertThat(new HttpEntity<String>(null, (HttpHeaders) null).equals(new HttpEntity<>(null, (HttpHeaders) null))).isTrue();
assertThat(new HttpEntity<>("foo", (HttpHeaders) null)).isNotEqualTo(new HttpEntity<>(null, (HttpHeaders) null));
assertThat(new HttpEntity<String>(null, (HttpHeaders) null)).isNotEqualTo(new HttpEntity<>("bar", (HttpHeaders) null));
assertThat(new HttpEntity<>("foo", map1).equals(new HttpEntity<>("foo", map1))).isTrue();
assertThat(new HttpEntity<>("foo", map1).equals(new HttpEntity<>("bar", map1))).isFalse();
assertThat(new HttpEntity<>("foo", headers1)).isEqualTo(new HttpEntity<>("foo", headers1));
assertThat(new HttpEntity<>("foo", headers1)).isNotEqualTo(new HttpEntity<>("bar", headers1));
}
@Test
spring-web/src/test/java/org/springframework/http/client/AbstractHttpRequestFactoryTests.java
+1 -1
View File
@@ -102,7 +102,7 @@ abstract class AbstractHttpRequestFactoryTests extends AbstractMockWebServerTest
assertThat(response.getHeaders()).as("Header value not found")
.containsEntry(headerName, Arrays.asList(headerValue1, headerValue2));
byte[] result = FileCopyUtils.copyToByteArray(response.getBody());
assertThat(Arrays.equals(body, result)).as("Invalid body").isTrue();
assertThat(result).as("Invalid body").isEqualTo(body);
}
}
spring-web/src/test/java/org/springframework/http/client/InterceptingClientHttpRequestFactoryTests.java
+2 -2
View File
@@ -19,7 +19,6 @@ package org.springframework.http.client;
import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
@@ -203,7 +202,8 @@ class InterceptingClientHttpRequestFactoryTests {
ClientHttpRequest request = requestFactory.createRequest(URI.create("https://example.com"), HttpMethod.GET);
request.execute();
assertThat(Arrays.equals(changedBody, requestMock.getBodyAsBytes())).isTrue();
assertThat(requestMock.getBodyAsBytes()).isEqualTo(changedBody);
assertThat(requestMock.getHeaders().getContentLength()).isEqualTo(changedBody.length);
}
spring-web/src/test/java/org/springframework/http/converter/ResourceHttpMessageConverterTests.java
+1 -2
View File
@@ -19,7 +19,6 @@ package org.springframework.http.converter;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import org.junit.jupiter.api.Test;
@@ -119,7 +118,7 @@ class ResourceHttpMessageConverterTests {
Resource body = new ByteArrayResource(byteArray);
converter.write(body, null, outputMessage);
assertThat(Arrays.equals(byteArray, outputMessage.getBodyAsBytes())).isTrue();
assertThat(outputMessage.getBodyAsBytes()).isEqualTo(byteArray);
}
@Test // SPR-12999
spring-web/src/test/java/org/springframework/web/bind/EscapedErrorsTests.java
+1 -1
View File
@@ -85,7 +85,7 @@ class EscapedErrorsTests {
FieldError ageError = errors.getFieldError("age");
assertThat(ageError.getDefaultMessage()).as("Age error message escaped").isEqualTo("message: &lt;tag&gt;");
assertThat(ageError.getCode()).as("Age error code not escaped").isEqualTo("AGE_NOT_SET <tag>");
assertThat((Integer.valueOf(0))).as("Age value not escaped").isEqualTo(errors.getFieldValue("age"));
assertThat(Integer.valueOf(0)).as("Age value not escaped").isEqualTo(errors.getFieldValue("age"));
FieldError ageErrorInList = errors.getFieldErrors("age").get(0);
assertThat(ageError.getDefaultMessage()).as("Same name error in list")
.isEqualTo(ageErrorInList.getDefaultMessage());
spring-web/src/test/java/org/springframework/web/bind/ServletRequestDataBinderTests.java
+5 -9
View File
@@ -204,8 +204,7 @@ class ServletRequestDataBinderTests {
request.addParameter("test_age", "" + 50);
ServletRequestParameterPropertyValues pvs = new ServletRequestParameterPropertyValues(request);
boolean condition = !pvs.contains("forname");
assertThat(condition).as("Didn't find normal when given prefix").isTrue();
assertThat(pvs.contains("forname")).as("Didn't find normal when given prefix").isFalse();
assertThat(pvs.contains("test_forname")).as("Did treat prefix as normal when not given prefix").isTrue();
pvs = new ServletRequestParameterPropertyValues(request, "test");
@@ -227,8 +226,7 @@ class ServletRequestDataBinderTests {
ServletRequestParameterPropertyValues pvs = new ServletRequestParameterPropertyValues(request);
assertThat(pvs.getPropertyValues().length).as("Found 1 parameter").isEqualTo(1);
boolean condition = pvs.getPropertyValue("forname").getValue() instanceof String[];
assertThat(condition).as("Found array value").isTrue();
assertThat(pvs.getPropertyValue("forname").getValue()).as("Found array value").isInstanceOf(String[].class);
String[] values = (String[]) pvs.getPropertyValue("forname").getValue();
assertThat(Arrays.asList(original)).as("Correct values").isEqualTo(Arrays.asList(values));
}
@@ -241,8 +239,7 @@ class ServletRequestDataBinderTests {
assertThat(pvs.contains("forname")).as("Contains forname").isTrue();
assertThat(pvs.contains("surname")).as("Contains surname").isTrue();
assertThat(pvs.contains("age")).as("Contains age").isTrue();
boolean condition1 = !pvs.contains("tory");
assertThat(condition1).as("Doesn't contain tory").isTrue();
assertThat(pvs.contains("tory")).as("Doesn't contain tory").isFalse();
PropertyValue[] ps = pvs.getPropertyValues();
Map<String, String> m = new HashMap<>();
@@ -252,9 +249,8 @@ class ServletRequestDataBinderTests {
for (PropertyValue element : ps) {
Object val = m.get(element.getName());
assertThat(val).as("Can't have unexpected value").isNotNull();
boolean condition = val instanceof String;
assertThat(condition).as("Val i string").isTrue();
assertThat(val.equals(element.getValue())).as("val matches expected").isTrue();
assertThat(val).as("Val i string").isInstanceOf(String.class);
assertThat(val).as("val matches expected").isEqualTo(element.getValue());
m.remove(element.getName());
}
assertThat(m.size()).as("Map size is 0").isEqualTo(0);
spring-web/src/test/java/org/springframework/web/bind/ServletRequestUtilsTests.java
+1 -1
View File
@@ -205,7 +205,7 @@ class ServletRequestUtilsTests {
request.addParameter("param5", "1");
request.addParameter("paramEmpty", "");
assertThat(ServletRequestUtils.getBooleanParameter(request, "param1").equals(Boolean.TRUE)).isTrue();
assertThat(ServletRequestUtils.getBooleanParameter(request, "param1")).isEqualTo(Boolean.TRUE);
assertThat(ServletRequestUtils.getBooleanParameter(request, "param1", false)).isTrue();
assertThat(ServletRequestUtils.getRequiredBooleanParameter(request, "param1")).isTrue();
spring-web/src/test/java/org/springframework/web/bind/support/WebRequestDataBinderTests.java
+5 -9
View File
@@ -307,8 +307,7 @@ class WebRequestDataBinderTests {
request.addParameter("test_age", "" + 50);
ServletRequestParameterPropertyValues pvs = new ServletRequestParameterPropertyValues(request);
boolean condition = !pvs.contains("forname");
assertThat(condition).as("Didn't find normal when given prefix").isTrue();
assertThat(pvs.contains("forname")).as("Didn't find normal when given prefix").isFalse();
assertThat(pvs.contains("test_forname")).as("Did treat prefix as normal when not given prefix").isTrue();
pvs = new ServletRequestParameterPropertyValues(request, "test");
@@ -323,8 +322,7 @@ class WebRequestDataBinderTests {
assertThat(pvs.contains("forname")).as("Contains forname").isTrue();
assertThat(pvs.contains("surname")).as("Contains surname").isTrue();
assertThat(pvs.contains("age")).as("Contains age").isTrue();
boolean condition1 = !pvs.contains("tory");
assertThat(condition1).as("Doesn't contain tory").isTrue();
assertThat(pvs.contains("tory")).as("Doesn't contain tory").isFalse();
PropertyValue[] pvArray = pvs.getPropertyValues();
Map<String, String> m = new HashMap<>();
@@ -334,9 +332,8 @@ class WebRequestDataBinderTests {
for (PropertyValue pv : pvArray) {
Object val = m.get(pv.getName());
assertThat(val).as("Can't have unexpected value").isNotNull();
boolean condition = val instanceof String;
assertThat(condition).as("Val i string").isTrue();
assertThat(val.equals(pv.getValue())).as("val matches expected").isTrue();
assertThat(val).as("Val i string").isInstanceOf(String.class);
assertThat(val).as("val matches expected").isEqualTo(pv.getValue());
m.remove(pv.getName());
}
assertThat(m.size()).as("Map size is 0").isEqualTo(0);
@@ -357,8 +354,7 @@ class WebRequestDataBinderTests {
ServletRequestParameterPropertyValues pvs = new ServletRequestParameterPropertyValues(request);
assertThat(pvs.getPropertyValues().length).as("Found 1 parameter").isEqualTo(1);
boolean condition = pvs.getPropertyValue("forname").getValue() instanceof String[];
assertThat(condition).as("Found array value").isTrue();
assertThat(pvs.getPropertyValue("forname").getValue()).as("Found array value").isInstanceOf(String[].class);
String[] values = (String[]) pvs.getPropertyValue("forname").getValue();
assertThat(Arrays.asList(original)).as("Correct values").isEqualTo(Arrays.asList(values));
}
spring-web/src/test/java/org/springframework/web/context/ContextLoaderInitializerTests.java
+2 -4
View File
@@ -55,8 +55,7 @@ class ContextLoaderInitializerTests {
void register() throws ServletException {
initializer.onStartup(servletContext);
boolean condition1 = eventListener instanceof ContextLoaderListener;
assertThat(condition1).isTrue();
assertThat(eventListener).isInstanceOf(ContextLoaderListener.class);
ContextLoaderListener cll = (ContextLoaderListener) eventListener;
cll.contextInitialized(new ServletContextEvent(servletContext));
@@ -64,8 +63,7 @@ class ContextLoaderInitializerTests {
.getRequiredWebApplicationContext(servletContext);
assertThat(applicationContext.containsBean(BEAN_NAME)).isTrue();
boolean condition = applicationContext.getBean(BEAN_NAME) instanceof MyBean;
assertThat(condition).isTrue();
assertThat(applicationContext.getBean(BEAN_NAME)).isInstanceOf(MyBean.class);
}
private class MyMockServletContext extends MockServletContext {
spring-web/src/test/java/org/springframework/web/context/request/RequestScopeTests.java
+1 -2
View File
@@ -104,8 +104,7 @@ class RequestScopeTests {
String name = "requestScopedFactoryBean";
assertThat(request.getAttribute(name)).isNull();
TestBean bean = (TestBean) this.beanFactory.getBean(name);
boolean condition = request.getAttribute(name) instanceof FactoryBean;
assertThat(condition).isTrue();
assertThat(request.getAttribute(name)).isInstanceOf(FactoryBean.class);
assertThat(this.beanFactory.getBean(name)).isSameAs(bean);
}
spring-web/src/test/java/org/springframework/web/context/support/SpringBeanAutowiringSupportTests.java
+1 -2
View File
@@ -50,8 +50,7 @@ class SpringBeanAutowiringSupportTests {
InjectionTarget target = new InjectionTarget();
SpringBeanAutowiringSupport.processInjectionBasedOnServletContext(target, sc);
boolean condition = target.testBean instanceof TestBean;
assertThat(condition).isTrue();
assertThat(target.testBean).isInstanceOf(TestBean.class);
assertThat(target.name).isEqualTo("tb");
}
spring-web/src/test/java/org/springframework/web/method/annotation/CookieValueMethodArgumentResolverTests.java
+1 -2
View File
@@ -80,8 +80,7 @@ class CookieValueMethodArgumentResolverTests {
void resolveCookieDefaultValue() throws Exception {
Object result = resolver.resolveArgument(paramNamedDefaultValueString, null, webRequest, null);
boolean condition = result instanceof String;
assertThat(condition).isTrue();
assertThat(result).isInstanceOf(String.class);
assertThat(result).as("Invalid result").isEqualTo("bar");
}
spring-web/src/test/java/org/springframework/web/method/annotation/RequestHeaderMapMethodArgumentResolverTests.java
+3 -6
View File
@@ -91,8 +91,7 @@ class RequestHeaderMapMethodArgumentResolverTests {
Object result = resolver.resolveArgument(paramMap, null, webRequest, null);
boolean condition = result instanceof Map;
assertThat(condition).isTrue();
assertThat(result).isInstanceOf(Map.class);
assertThat(result).as("Invalid result").isEqualTo(expected);
}
@@ -111,8 +110,7 @@ class RequestHeaderMapMethodArgumentResolverTests {
Object result = resolver.resolveArgument(paramMultiValueMap, null, webRequest, null);
boolean condition = result instanceof MultiValueMap;
assertThat(condition).isTrue();
assertThat(result).isInstanceOf(MultiValueMap.class);
assertThat(result).as("Invalid result").isEqualTo(expected);
}
@@ -131,8 +129,7 @@ class RequestHeaderMapMethodArgumentResolverTests {
Object result = resolver.resolveArgument(paramHttpHeaders, null, webRequest, null);
boolean condition = result instanceof HttpHeaders;
assertThat(condition).isTrue();
assertThat(result).isInstanceOf(HttpHeaders.class);
assertThat(result).as("Invalid result").isEqualTo(expected);
}
spring-web/src/test/java/org/springframework/web/method/annotation/RequestParamMapMethodArgumentResolverTests.java
+6 -12
View File
@@ -82,8 +82,7 @@ class RequestParamMapMethodArgumentResolverTests {
MethodParameter param = this.testMethod.annot(requestParam().noName()).arg(Map.class, String.class, String.class);
Object result = resolver.resolveArgument(param, null, webRequest, null);
boolean condition = result instanceof Map;
assertThat(condition).isTrue();
assertThat(result).isInstanceOf(Map.class);
assertThat(result).as("Invalid result").isEqualTo(expected);
}
@@ -101,8 +100,7 @@ class RequestParamMapMethodArgumentResolverTests {
MethodParameter param = this.testMethod.annotPresent(RequestParam.class).arg(MultiValueMap.class, String.class, String.class);
Object result = resolver.resolveArgument(param, null, webRequest, null);
boolean condition = result instanceof MultiValueMap;
assertThat(condition).isTrue();
assertThat(result).isInstanceOf(MultiValueMap.class);
assertThat(result).as("Invalid result").isEqualTo(expected);
}
@@ -119,8 +117,7 @@ class RequestParamMapMethodArgumentResolverTests {
MethodParameter param = this.testMethod.annot(requestParam().noName()).arg(Map.class, String.class, MultipartFile.class);
Object result = resolver.resolveArgument(param, null, webRequest, null);
boolean condition = result instanceof Map;
assertThat(condition).isTrue();
assertThat(result).isInstanceOf(Map.class);
Map<String, MultipartFile> resultMap = (Map<String, MultipartFile>) result;
assertThat(resultMap).hasSize(2);
assertThat(resultMap.get("mfile")).isEqualTo(expected1);
@@ -142,8 +139,7 @@ class RequestParamMapMethodArgumentResolverTests {
MethodParameter param = this.testMethod.annot(requestParam().noName()).arg(MultiValueMap.class, String.class, MultipartFile.class);
Object result = resolver.resolveArgument(param, null, webRequest, null);
boolean condition = result instanceof MultiValueMap;
assertThat(condition).isTrue();
assertThat(result).isInstanceOf(MultiValueMap.class);
MultiValueMap<String, MultipartFile> resultMap = (MultiValueMap<String, MultipartFile>) result;
assertThat(resultMap).hasSize(2);
assertThat(resultMap.get("mfilelist")).containsExactly(expected1, expected2);
@@ -164,8 +160,7 @@ class RequestParamMapMethodArgumentResolverTests {
MethodParameter param = this.testMethod.annot(requestParam().noName()).arg(Map.class, String.class, Part.class);
Object result = resolver.resolveArgument(param, null, webRequest, null);
boolean condition = result instanceof Map;
assertThat(condition).isTrue();
assertThat(result).isInstanceOf(Map.class);
Map<String, Part> resultMap = (Map<String, Part>) result;
assertThat(resultMap).hasSize(2);
assertThat(resultMap.get("mfile")).isEqualTo(expected1);
@@ -188,8 +183,7 @@ class RequestParamMapMethodArgumentResolverTests {
MethodParameter param = this.testMethod.annot(requestParam().noName()).arg(MultiValueMap.class, String.class, Part.class);
Object result = resolver.resolveArgument(param, null, webRequest, null);
boolean condition = result instanceof MultiValueMap;
assertThat(condition).isTrue();
assertThat(result).isInstanceOf(MultiValueMap.class);
MultiValueMap<String, Part> resultMap = (MultiValueMap<String, Part>) result;
assertThat(resultMap).hasSize(2);
assertThat(resultMap.get("mfilelist")).containsExactly(expected1, expected2);
spring-web/src/test/java/org/springframework/web/method/annotation/RequestParamMethodArgumentResolverTests.java
+5 -5
View File
@@ -538,7 +538,7 @@ class RequestParamMethodArgumentResolverTests {
request.addParameter("name", "123");
result = resolver.resolveArgument(param, null, webRequest, binderFactory);
assertThat(result.getClass()).isEqualTo(Optional.class);
assertThat(((Optional) result)).contains(123);
assertThat((Optional) result).contains(123);
}
@Test
@@ -554,7 +554,7 @@ class RequestParamMethodArgumentResolverTests {
result = resolver.resolveArgument(param, null, webRequest, binderFactory);
assertThat(result.getClass()).isEqualTo(Optional.class);
assertThat(((Optional) result)).isNotPresent();
assertThat((Optional) result).isNotPresent();
}
@Test
@@ -587,7 +587,7 @@ class RequestParamMethodArgumentResolverTests {
result = resolver.resolveArgument(param, null, webRequest, binderFactory);
assertThat(result.getClass()).isEqualTo(Optional.class);
assertThat(((Optional) result)).isNotPresent();
assertThat((Optional) result).isNotPresent();
}
@Test
@@ -604,7 +604,7 @@ class RequestParamMethodArgumentResolverTests {
request.addParameter("name", "123", "456");
result = resolver.resolveArgument(param, null, webRequest, binderFactory);
assertThat(result.getClass()).isEqualTo(Optional.class);
assertThat(((Optional) result)).contains(Arrays.asList("123", "456"));
assertThat((Optional) result).contains(Arrays.asList("123", "456"));
}
@Test
@@ -620,7 +620,7 @@ class RequestParamMethodArgumentResolverTests {
result = resolver.resolveArgument(param, null, webRequest, binderFactory);
assertThat(result.getClass()).isEqualTo(Optional.class);
assertThat(((Optional) result)).isNotPresent();
assertThat((Optional) result).isNotPresent();
}
@Test
spring-web/src/test/java/org/springframework/web/method/annotation/SessionAttributesHandlerTests.java
+1 -2
View File
@@ -104,8 +104,7 @@ class SessionAttributesHandlerTests {
assertThat(sessionAttributeStore.retrieveAttribute(request, "attr1")).isEqualTo("value1");
assertThat(sessionAttributeStore.retrieveAttribute(request, "attr2")).isEqualTo("value2");
boolean condition = sessionAttributeStore.retrieveAttribute(request, "attr3") instanceof TestBean;
assertThat(condition).isTrue();
assertThat(sessionAttributeStore.retrieveAttribute(request, "attr3")).isInstanceOf(TestBean.class);
}
spring-web/src/test/java/org/springframework/web/server/adapter/WebHttpHandlerBuilderTests.java
+1 -2
View File
@@ -66,8 +66,7 @@ class WebHttpHandlerBuilderTests {
context.refresh();
HttpHandler httpHandler = WebHttpHandlerBuilder.applicationContext(context).build();
boolean condition = httpHandler instanceof HttpWebHandlerAdapter;
assertThat(condition).isTrue();
assertThat(httpHandler).isInstanceOf(HttpWebHandlerAdapter.class);
assertThat(((HttpWebHandlerAdapter) httpHandler).getApplicationContext()).isSameAs(context);
MockServerHttpRequest request = MockServerHttpRequest.get("/").build();
spring-webflux/src/test/java/org/springframework/web/reactive/config/DelegatingWebFluxConfigurationTests.java
+1 -2
View File
@@ -113,8 +113,7 @@ class DelegatingWebFluxConfigurationTests {
verify(webFluxConfigurer).configureArgumentResolvers(any());
assertThat(initializer).isNotNull();
boolean condition = initializer.getValidator() instanceof LocalValidatorFactoryBean;
assertThat(condition).isTrue();
assertThat(initializer.getValidator()).isInstanceOf(LocalValidatorFactoryBean.class);
assertThat(initializer.getConversionService()).isSameAs(formatterRegistry.getValue());
assertThat(codecsConfigurer.getValue().getReaders()).hasSize(17);
}
spring-webflux/src/test/java/org/springframework/web/reactive/function/server/ResourceHandlerFunctionTests.java
+2 -4
View File
@@ -79,8 +79,7 @@ class ResourceHandlerFunctionTests {
Mono<Void> result = responseMono.flatMap(response -> {
assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
boolean condition = response instanceof EntityResponse;
assertThat(condition).isTrue();
assertThat(response).isInstanceOf(EntityResponse.class);
@SuppressWarnings("unchecked")
EntityResponse<Resource> entityResponse = (EntityResponse<Resource>) response;
assertThat(entityResponse.entity()).isEqualTo(this.resource);
@@ -116,8 +115,7 @@ class ResourceHandlerFunctionTests {
Mono<Void> result = responseMono.flatMap(response -> {
assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
boolean condition = response instanceof EntityResponse;
assertThat(condition).isTrue();
assertThat(response).isInstanceOf(EntityResponse.class);
@SuppressWarnings("unchecked")
EntityResponse<Resource> entityResponse = (EntityResponse<Resource>) response;
assertThat(entityResponse.entity().getFilename()).isEqualTo(this.resource.getFilename());
spring-webflux/src/test/java/org/springframework/web/reactive/resource/EncodedResourceResolverTests.java
+4 -8
View File
@@ -85,8 +85,7 @@ class EncodedResourceResolverTests {
assertThat(actual.getDescription()).isEqualTo(getResource(file + ".gz").getDescription());
assertThat(actual.getFilename()).isEqualTo(getResource(file).getFilename());
boolean condition = actual instanceof HttpResource;
assertThat(condition).isTrue();
assertThat(actual).isInstanceOf(HttpResource.class);
HttpHeaders headers = ((HttpResource) actual).getResponseHeaders();
assertThat(headers.getFirst(HttpHeaders.CONTENT_ENCODING)).isEqualTo("gzip");
assertThat(headers.getFirst(HttpHeaders.VARY)).isEqualTo("Accept-Encoding");
@@ -103,8 +102,7 @@ class EncodedResourceResolverTests {
assertThat(actual.getDescription()).isEqualTo(getResource("foo.css.gz").getDescription());
assertThat(actual.getFilename()).isEqualTo(getResource("foo.css").getFilename());
boolean condition = actual instanceof HttpResource;
assertThat(condition).isTrue();
assertThat(actual).isInstanceOf(HttpResource.class);
}
@Test
@@ -121,8 +119,7 @@ class EncodedResourceResolverTests {
assertThat(resolved.getDescription()).isEqualTo(getResource(file + ".gz").getDescription());
assertThat(resolved.getFilename()).isEqualTo(getResource(file).getFilename());
boolean condition = resolved instanceof HttpResource;
assertThat(condition).isTrue();
assertThat(resolved).isInstanceOf(HttpResource.class);
// 2. Resolve unencoded resource
@@ -131,8 +128,7 @@ class EncodedResourceResolverTests {
assertThat(resolved.getDescription()).isEqualTo(getResource(file).getDescription());
assertThat(resolved.getFilename()).isEqualTo(getResource(file).getFilename());
boolean condition1 = resolved instanceof HttpResource;
assertThat(condition1).isFalse();
assertThat(resolved).isNotInstanceOf(HttpResource.class);
}
@Test // SPR-13149
spring-webflux/src/test/java/org/springframework/web/reactive/result/condition/HeadersRequestConditionTests.java
+1 -4
View File
@@ -16,8 +16,6 @@
package org.springframework.web.reactive.result.condition;
import java.util.Collection;
import org.junit.jupiter.api.Test;
import org.springframework.web.server.ServerWebExchange;
@@ -147,8 +145,7 @@ class HeadersRequestConditionTests {
HeadersRequestCondition condition2 = new HeadersRequestCondition("foo=baz");
HeadersRequestCondition result = condition1.combine(condition2);
Collection<?> conditions = result.getContent();
assertThat(conditions).hasSize(2);
assertThat(result.getContent()).hasSize(2);
}
@Test

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