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

Replace assertThat(x.equals(y)) with assertThat(x).isEqualTo(y) 

Search for   : assertThat\((.+)\.equals\((\w+)\)\)\.isTrue\(\)
Replace with : assertThat($1).isEqualTo($2)

Search for   : assertThat\((.+)\.equals\((\w+)\)\)\.isFalse\(\)
Replace with : assertThat($1).isNotEqualTo($2)

Closes gh-31763
This commit is contained in:
Yanming Zhou 2023-12-06 14:44:43 +08:00 committed by Brian Clozel
parent e2852e7355
commit 7b16ef90f1
30 changed files with 151 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -141,7 +141,7 @@ public class ComposablePointcutTests {
pc1.intersection(GETTER_METHOD_MATCHER); pc1.intersection(GETTER_METHOD_MATCHER);
assertThat(pc1.equals(pc2)).isFalse(); assertThat(pc1).isNotEqualTo(pc2);
assertThat(pc1.hashCode()).isNotEqualTo(pc2.hashCode()); assertThat(pc1.hashCode()).isNotEqualTo(pc2.hashCode());
pc2.intersection(GETTER_METHOD_MATCHER); pc2.intersection(GETTER_METHOD_MATCHER);

4
spring-aop/src/test/java/org/springframework/aop/support/MethodMatchersTests.java
View File

@ -110,8 +110,8 @@ public class MethodMatchersTests {
public void testUnionEquals() { public void testUnionEquals() {
MethodMatcher first = MethodMatchers.union(MethodMatcher.TRUE, MethodMatcher.TRUE); MethodMatcher first = MethodMatchers.union(MethodMatcher.TRUE, MethodMatcher.TRUE);
MethodMatcher second = new ComposablePointcut(MethodMatcher.TRUE).union(new ComposablePointcut(MethodMatcher.TRUE)).getMethodMatcher(); MethodMatcher second = new ComposablePointcut(MethodMatcher.TRUE).union(new ComposablePointcut(MethodMatcher.TRUE)).getMethodMatcher();
assertThat(first.equals(second)).isTrue(); assertThat(first).isEqualTo(second);
assertThat(second.equals(first)).isTrue(); assertThat(second).isEqualTo(first);
} }
@Test @Test

2
spring-aspects/src/test/java/org/springframework/cache/aspectj/AbstractCacheAnnotationTests.java vendored
View File

@ -543,7 +543,7 @@ public abstract class AbstractCacheAnnotationTests {
Object r1 = service.multiConditionalCacheAndEvict(key); Object r1 = service.multiConditionalCacheAndEvict(key);
Object r3 = service.multiConditionalCacheAndEvict(key); Object r3 = service.multiConditionalCacheAndEvict(key);
assertThat(r1.equals(r3)).isFalse(); assertThat(r1).isNotEqualTo(r3);
assertThat(primary.get(key)).isNull(); assertThat(primary.get(key)).isNull();
Object key2 = 3; Object key2 = 3;

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

@ -35,13 +35,13 @@ public class BeanDefinitionTests {
bd.setLazyInit(true); bd.setLazyInit(true);
bd.setScope("request"); bd.setScope("request");
RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class); RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class);
assertThat(bd.equals(otherBd)).isFalse(); assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isFalse(); assertThat(otherBd).isNotEqualTo(bd);
otherBd.setAbstract(true); otherBd.setAbstract(true);
otherBd.setLazyInit(true); otherBd.setLazyInit(true);
otherBd.setScope("request"); otherBd.setScope("request");
assertThat(bd.equals(otherBd)).isTrue(); assertThat(bd).isEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isTrue(); assertThat(otherBd).isEqualTo(bd);
assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode()); assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode());
} }
@ -52,14 +52,14 @@ public class BeanDefinitionTests {
bd.getPropertyValues().add("age", "99"); bd.getPropertyValues().add("age", "99");
RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class); RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class);
otherBd.getPropertyValues().add("name", "myName"); otherBd.getPropertyValues().add("name", "myName");
assertThat(bd.equals(otherBd)).isFalse(); assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isFalse(); assertThat(otherBd).isNotEqualTo(bd);
otherBd.getPropertyValues().add("age", "11"); otherBd.getPropertyValues().add("age", "11");
assertThat(bd.equals(otherBd)).isFalse(); assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isFalse(); assertThat(otherBd).isNotEqualTo(bd);
otherBd.getPropertyValues().add("age", "99"); otherBd.getPropertyValues().add("age", "99");
assertThat(bd.equals(otherBd)).isTrue(); assertThat(bd).isEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isTrue(); assertThat(otherBd).isEqualTo(bd);
assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode()); assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode());
} }
@ -70,14 +70,14 @@ public class BeanDefinitionTests {
bd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5); bd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5);
RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class); RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class);
otherBd.getConstructorArgumentValues().addGenericArgumentValue("test"); otherBd.getConstructorArgumentValues().addGenericArgumentValue("test");
assertThat(bd.equals(otherBd)).isFalse(); assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isFalse(); assertThat(otherBd).isNotEqualTo(bd);
otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 9); otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 9);
assertThat(bd.equals(otherBd)).isFalse(); assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isFalse(); assertThat(otherBd).isNotEqualTo(bd);
otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5); otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5);
assertThat(bd.equals(otherBd)).isTrue(); assertThat(bd).isEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isTrue(); assertThat(otherBd).isEqualTo(bd);
assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode()); assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode());
} }
@ -89,14 +89,14 @@ public class BeanDefinitionTests {
RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class); RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class);
otherBd.getConstructorArgumentValues().addGenericArgumentValue("test", "int"); otherBd.getConstructorArgumentValues().addGenericArgumentValue("test", "int");
otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5); otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5);
assertThat(bd.equals(otherBd)).isFalse(); assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isFalse(); assertThat(otherBd).isNotEqualTo(bd);
otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5, "int"); otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5, "int");
assertThat(bd.equals(otherBd)).isFalse(); assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isFalse(); assertThat(otherBd).isNotEqualTo(bd);
otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5, "long"); otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5, "long");
assertThat(bd.equals(otherBd)).isTrue(); assertThat(bd).isEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isTrue(); assertThat(otherBd).isEqualTo(bd);
assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode()); assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode());
} }
@ -111,21 +111,21 @@ public class BeanDefinitionTests {
otherBd.setScope("request"); otherBd.setScope("request");
otherBd.setAbstract(true); otherBd.setAbstract(true);
otherBd.setLazyInit(true); otherBd.setLazyInit(true);
assertThat(bd.equals(otherBd)).isFalse(); assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isFalse(); assertThat(otherBd).isNotEqualTo(bd);
otherBd.setParentName("parent"); otherBd.setParentName("parent");
assertThat(bd.equals(otherBd)).isTrue(); assertThat(bd).isEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isTrue(); assertThat(otherBd).isEqualTo(bd);
assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode()); assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode());
bd.getPropertyValues(); bd.getPropertyValues();
assertThat(bd.equals(otherBd)).isTrue(); assertThat(bd).isEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isTrue(); assertThat(otherBd).isEqualTo(bd);
assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode()); assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode());
bd.getConstructorArgumentValues(); bd.getConstructorArgumentValues();
assertThat(bd.equals(otherBd)).isTrue(); assertThat(bd).isEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isTrue(); assertThat(otherBd).isEqualTo(bd);
assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode()); assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode());
} }
@ -137,14 +137,14 @@ public class BeanDefinitionTests {
bd.setScope("request"); bd.setScope("request");
BeanDefinitionHolder holder = new BeanDefinitionHolder(bd, "bd"); BeanDefinitionHolder holder = new BeanDefinitionHolder(bd, "bd");
RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class); RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class);
assertThat(bd.equals(otherBd)).isFalse(); assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd.equals(bd)).isFalse(); assertThat(otherBd).isNotEqualTo(bd);
otherBd.setAbstract(true); otherBd.setAbstract(true);
otherBd.setLazyInit(true); otherBd.setLazyInit(true);
otherBd.setScope("request"); otherBd.setScope("request");
BeanDefinitionHolder otherHolder = new BeanDefinitionHolder(bd, "bd"); BeanDefinitionHolder otherHolder = new BeanDefinitionHolder(bd, "bd");
assertThat(holder.equals(otherHolder)).isTrue(); assertThat(holder).isEqualTo(otherHolder);
assertThat(otherHolder.equals(holder)).isTrue(); assertThat(otherHolder).isEqualTo(holder);
assertThat(holder.hashCode()).isEqualTo(otherHolder.hashCode()); assertThat(holder.hashCode()).isEqualTo(otherHolder.hashCode());
} }

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

@ -85,8 +85,8 @@ public class CollectionsWithDefaultTypesTests {
List l = (List) jumble.getJumble(); List l = (List) jumble.getJumble();
assertThat(l.get(0).equals("literal")).isTrue(); assertThat(l.get(0).equals("literal")).isTrue();
Integer[] array1 = (Integer[]) l.get(1); Integer[] array1 = (Integer[]) l.get(1);
assertThat(array1[0].equals(2)).isTrue(); assertThat(array1[0]).isEqualTo(2);
assertThat(array1[1].equals(4)).isTrue(); assertThat(array1[1]).isEqualTo(4);
int[] array2 = (int[]) l.get(2); int[] array2 = (int[]) l.get(2);
assertThat(array2[0]).isEqualTo(3); assertThat(array2[0]).isEqualTo(3);
assertThat(array2[1]).isEqualTo(5); assertThat(array2[1]).isEqualTo(5);

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

@ -198,14 +198,14 @@ public class XmlBeanCollectionTests {
public void testMapWithLiteralsAndReferences() { public void testMapWithLiteralsAndReferences() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("mixedMap"); HasMap hasMap = (HasMap) this.beanFactory.getBean("mixedMap");
assertThat(hasMap.getMap().size()).isEqualTo(5); assertThat(hasMap.getMap().size()).isEqualTo(5);
assertThat(hasMap.getMap().get("foo").equals(10)).isTrue(); assertThat(hasMap.getMap().get("foo")).isEqualTo(10);
TestBean jenny = (TestBean) this.beanFactory.getBean("jenny"); TestBean jenny = (TestBean) this.beanFactory.getBean("jenny");
assertThat(hasMap.getMap().get("jenny")).isSameAs(jenny); assertThat(hasMap.getMap().get("jenny")).isSameAs(jenny);
assertThat(hasMap.getMap().get(5).equals("david")).isTrue(); assertThat(hasMap.getMap().get(5).equals("david")).isTrue();
assertThat(hasMap.getMap().get("bar")).isInstanceOf(Long.class); assertThat(hasMap.getMap().get("bar")).isInstanceOf(Long.class);
assertThat(hasMap.getMap().get("bar").equals(100L)).isTrue(); assertThat(hasMap.getMap().get("bar")).isEqualTo(100L);
assertThat(hasMap.getMap().get("baz")).isInstanceOf(Integer.class); assertThat(hasMap.getMap().get("baz")).isInstanceOf(Integer.class);
assertThat(hasMap.getMap().get("baz").equals(200)).isTrue(); assertThat(hasMap.getMap().get("baz")).isEqualTo(200);
} }
@Test @Test
@ -230,7 +230,7 @@ public class XmlBeanCollectionTests {
assertThat(hasMap.getMap().size()).isEqualTo(4); assertThat(hasMap.getMap().size()).isEqualTo(4);
assertThat(hasMap.getMap().get(null).equals("bar")).isTrue(); assertThat(hasMap.getMap().get(null).equals("bar")).isTrue();
TestBean jenny = (TestBean) this.beanFactory.getBean("jenny"); TestBean jenny = (TestBean) this.beanFactory.getBean("jenny");
assertThat(hasMap.getMap().get("jenny").equals(jenny)).isTrue(); assertThat(hasMap.getMap().get("jenny")).isEqualTo(jenny);
// Check list // Check list
List l = (List) hasMap.getMap().get("list"); List l = (List) hasMap.getMap().get("list");
@ -250,7 +250,7 @@ public class XmlBeanCollectionTests {
l = (List) l.get(2); l = (List) l.get(2);
assertThat(l).isNotNull(); assertThat(l).isNotNull();
assertThat(l.size()).isEqualTo(2); assertThat(l.size()).isEqualTo(2);
assertThat(l.get(0).equals(jenny)).isTrue(); assertThat(l.get(0)).isEqualTo(jenny);
assertThat(l.get(1).equals("ba")).isTrue(); assertThat(l.get(1).equals("ba")).isTrue();
// Check nested map // Check nested map

6
spring-context-support/src/test/java/org/springframework/mail/SimpleMailMessageTests.java
View File

@ -128,7 +128,7 @@ public class SimpleMailMessageTests {
// Same object is equal // Same object is equal
message1 = new SimpleMailMessage(); message1 = new SimpleMailMessage();
message2 = message1; message2 = message1;
assertThat(message1.equals(message2)).isTrue(); assertThat(message1).isEqualTo(message2);
// Null object is not equal // Null object is not equal
message1 = new SimpleMailMessage(); message1 = new SimpleMailMessage();
@ -143,7 +143,7 @@ public class SimpleMailMessageTests {
// Equal values are equal // Equal values are equal
message1 = new SimpleMailMessage(); message1 = new SimpleMailMessage();
message2 = new SimpleMailMessage(); message2 = new SimpleMailMessage();
assertThat(message1.equals(message2)).isTrue(); assertThat(message1).isEqualTo(message2);
message1 = new SimpleMailMessage(); message1 = new SimpleMailMessage();
message1.setFrom("from@somewhere"); message1.setFrom("from@somewhere");
@ -155,7 +155,7 @@ public class SimpleMailMessageTests {
message1.setSubject("subject"); message1.setSubject("subject");
message1.setText("text"); message1.setText("text");
message2 = new SimpleMailMessage(message1); message2 = new SimpleMailMessage(message1);
assertThat(message1.equals(message2)).isTrue(); assertThat(message1).isEqualTo(message2);
} }
@Test @Test

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

@ -1178,7 +1178,7 @@ public abstract class AbstractAopProxyTests {
assertThat(i2).isEqualTo(i1); assertThat(i2).isEqualTo(i1);
assertThat(proxyB).isEqualTo(proxyA); assertThat(proxyB).isEqualTo(proxyA);
assertThat(proxyB.hashCode()).isEqualTo(proxyA.hashCode()); assertThat(proxyB.hashCode()).isEqualTo(proxyA.hashCode());
assertThat(proxyA.equals(a)).isFalse(); assertThat(proxyA).isNotEqualTo(a);
// Equality checks were handled by the proxy // Equality checks were handled by the proxy
assertThat(i1.getCount()).isEqualTo(0); assertThat(i1.getCount()).isEqualTo(0);
@ -1187,7 +1187,7 @@ public abstract class AbstractAopProxyTests {
// and won't think it's equal to B's NopInterceptor // and won't think it's equal to B's NopInterceptor
proxyA.absquatulate(); proxyA.absquatulate();
assertThat(i1.getCount()).isEqualTo(1); assertThat(i1.getCount()).isEqualTo(1);
assertThat(proxyA.equals(proxyB)).isFalse(); assertThat(proxyA).isNotEqualTo(proxyB);
} }
@Test @Test

30
spring-context/src/test/java/org/springframework/context/annotation/ConfigurationClassAndBeanMethodTests.java
View File

@ -44,16 +44,16 @@ class ConfigurationClassAndBeanMethodTests {
ConfigurationClass configurationClass2 = newConfigurationClass(Config1.class); ConfigurationClass configurationClass2 = newConfigurationClass(Config1.class);
ConfigurationClass configurationClass3 = newConfigurationClass(Config2.class); ConfigurationClass configurationClass3 = newConfigurationClass(Config2.class);
assertThat(configurationClass1.equals(null)).isFalse(); assertThat(configurationClass1).isNotEqualTo(null);
assertThat(configurationClass1).isNotSameAs(configurationClass2); assertThat(configurationClass1).isNotSameAs(configurationClass2);
assertThat(configurationClass1.equals(configurationClass1)).isTrue(); assertThat(configurationClass1).isEqualTo(configurationClass1);
assertThat(configurationClass2.equals(configurationClass2)).isTrue(); assertThat(configurationClass2).isEqualTo(configurationClass2);
assertThat(configurationClass1.equals(configurationClass2)).isTrue(); assertThat(configurationClass1).isEqualTo(configurationClass2);
assertThat(configurationClass2.equals(configurationClass1)).isTrue(); assertThat(configurationClass2).isEqualTo(configurationClass1);
assertThat(configurationClass1.equals(configurationClass3)).isFalse(); assertThat(configurationClass1).isNotEqualTo(configurationClass3);
assertThat(configurationClass3.equals(configurationClass2)).isFalse(); assertThat(configurationClass3).isNotEqualTo(configurationClass2);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
@ -72,18 +72,18 @@ class ConfigurationClassAndBeanMethodTests {
BeanMethod beanMethod_3_1 = beanMethods3.get(1); BeanMethod beanMethod_3_1 = beanMethods3.get(1);
BeanMethod beanMethod_3_2 = beanMethods3.get(2); BeanMethod beanMethod_3_2 = beanMethods3.get(2);
assertThat(beanMethod_1_0.equals(null)).isFalse(); assertThat(beanMethod_1_0).isNotEqualTo(null);
assertThat(beanMethod_1_0).isNotSameAs(beanMethod_2_0); assertThat(beanMethod_1_0).isNotSameAs(beanMethod_2_0);
assertThat(beanMethod_1_0.equals(beanMethod_1_0)).isTrue(); assertThat(beanMethod_1_0).isEqualTo(beanMethod_1_0);
assertThat(beanMethod_1_0.equals(beanMethod_2_0)).isTrue(); assertThat(beanMethod_1_0).isEqualTo(beanMethod_2_0);
assertThat(beanMethod_1_1.equals(beanMethod_2_1)).isTrue(); assertThat(beanMethod_1_1).isEqualTo(beanMethod_2_1);
assertThat(beanMethod_1_2.equals(beanMethod_2_2)).isTrue(); assertThat(beanMethod_1_2).isEqualTo(beanMethod_2_2);
assertThat(beanMethod_1_0.getMetadata().getMethodName()).isEqualTo(beanMethod_3_0.getMetadata().getMethodName()); assertThat(beanMethod_1_0.getMetadata().getMethodName()).isEqualTo(beanMethod_3_0.getMetadata().getMethodName());
assertThat(beanMethod_1_0.equals(beanMethod_3_0)).isFalse(); assertThat(beanMethod_1_0).isNotEqualTo(beanMethod_3_0);
assertThat(beanMethod_1_1.equals(beanMethod_3_1)).isFalse(); assertThat(beanMethod_1_1).isNotEqualTo(beanMethod_3_1);
assertThat(beanMethod_1_2.equals(beanMethod_3_2)).isFalse(); assertThat(beanMethod_1_2).isNotEqualTo(beanMethod_3_2);
} }
@Test @Test

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

@ -210,7 +210,7 @@ class ConfigurationClassProcessingTests {
BeanFactory factory = initBeanFactory(ConfigWithNullReference.class); BeanFactory factory = initBeanFactory(ConfigWithNullReference.class);
TestBean foo = factory.getBean("foo", TestBean.class); TestBean foo = factory.getBean("foo", TestBean.class);
assertThat(factory.getBean("bar").equals(null)).isTrue(); assertThat(factory.getBean("bar")).isEqualTo(null);
assertThat(foo.getSpouse()).isNull(); assertThat(foo.getSpouse()).isNull();
} }

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

@ -67,7 +67,7 @@ class AnnotatedElementKeyTests {
AnnotatedElementKey first = new AnnotatedElementKey(this.method, getClass()); AnnotatedElementKey first = new AnnotatedElementKey(this.method, getClass());
AnnotatedElementKey second = new AnnotatedElementKey(this.method, null); AnnotatedElementKey second = new AnnotatedElementKey(this.method, null);
assertThat(first.equals(second)).isFalse(); assertThat(first).isNotEqualTo(second);
} }
private void assertKeyEquals(AnnotatedElementKey first, AnnotatedElementKey second) { private void assertKeyEquals(AnnotatedElementKey first, AnnotatedElementKey second) {

14
spring-context/src/test/java/org/springframework/scheduling/support/PeriodicTriggerTests.java
View File

@ -185,25 +185,25 @@ class PeriodicTriggerTests {
PeriodicTrigger trigger1 = new PeriodicTrigger(Duration.ofMillis(3000)); PeriodicTrigger trigger1 = new PeriodicTrigger(Duration.ofMillis(3000));
PeriodicTrigger trigger2 = new PeriodicTrigger(Duration.ofMillis(3000)); PeriodicTrigger trigger2 = new PeriodicTrigger(Duration.ofMillis(3000));
assertThat(trigger1.equals(new String("not a trigger"))).isFalse(); assertThat(trigger1.equals(new String("not a trigger"))).isFalse();
assertThat(trigger1.equals(null)).isFalse(); assertThat(trigger1).isNotEqualTo(null);
assertThat(trigger1).isEqualTo(trigger1); assertThat(trigger1).isEqualTo(trigger1);
assertThat(trigger2).isEqualTo(trigger2); assertThat(trigger2).isEqualTo(trigger2);
assertThat(trigger2).isEqualTo(trigger1); assertThat(trigger2).isEqualTo(trigger1);
trigger2.setInitialDelay(1234); trigger2.setInitialDelay(1234);
assertThat(trigger1.equals(trigger2)).isFalse(); assertThat(trigger1).isNotEqualTo(trigger2);
assertThat(trigger2.equals(trigger1)).isFalse(); assertThat(trigger2).isNotEqualTo(trigger1);
trigger1.setInitialDelay(1234); trigger1.setInitialDelay(1234);
assertThat(trigger2).isEqualTo(trigger1); assertThat(trigger2).isEqualTo(trigger1);
trigger2.setFixedRate(true); trigger2.setFixedRate(true);
assertThat(trigger1.equals(trigger2)).isFalse(); assertThat(trigger1).isNotEqualTo(trigger2);
assertThat(trigger2.equals(trigger1)).isFalse(); assertThat(trigger2).isNotEqualTo(trigger1);
trigger1.setFixedRate(true); trigger1.setFixedRate(true);
assertThat(trigger2).isEqualTo(trigger1); assertThat(trigger2).isEqualTo(trigger1);
PeriodicTrigger trigger3 = new PeriodicTrigger(Duration.ofSeconds(3)); PeriodicTrigger trigger3 = new PeriodicTrigger(Duration.ofSeconds(3));
trigger3.setInitialDelay(Duration.ofSeconds(7)); trigger3.setInitialDelay(Duration.ofSeconds(7));
trigger3.setFixedRate(true); trigger3.setFixedRate(true);
assertThat(trigger1.equals(trigger3)).isFalse(); assertThat(trigger1).isNotEqualTo(trigger3);
assertThat(trigger3.equals(trigger1)).isFalse(); assertThat(trigger3).isNotEqualTo(trigger1);
trigger1.setInitialDelay(Duration.ofMillis(7000)); trigger1.setInitialDelay(Duration.ofMillis(7000));
assertThat(trigger3).isEqualTo(trigger1); assertThat(trigger3).isEqualTo(trigger1);
} }

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

@ -558,7 +558,7 @@ public abstract class AbstractCacheAnnotationTests {
Object r1 = service.multiConditionalCacheAndEvict(key); Object r1 = service.multiConditionalCacheAndEvict(key);
Object r3 = service.multiConditionalCacheAndEvict(key); Object r3 = service.multiConditionalCacheAndEvict(key);
assertThat(r1.equals(r3)).isFalse(); assertThat(r1).isNotEqualTo(r3);
assertThat(primary.get(key)).isNull(); assertThat(primary.get(key)).isNull();
Object key2 = 3; Object key2 = 3;

12
spring-core/src/test/java/org/springframework/core/MethodParameterTests.java
View File

@ -65,12 +65,12 @@ class MethodParameterTests {
assertThat(longParameter).isEqualTo(longParameter); assertThat(longParameter).isEqualTo(longParameter);
assertThat(intReturnType).isEqualTo(intReturnType); assertThat(intReturnType).isEqualTo(intReturnType);
assertThat(stringParameter.equals(longParameter)).isFalse(); assertThat(stringParameter).isNotEqualTo(longParameter);
assertThat(stringParameter.equals(intReturnType)).isFalse(); assertThat(stringParameter).isNotEqualTo(intReturnType);
assertThat(longParameter.equals(stringParameter)).isFalse(); assertThat(longParameter).isNotEqualTo(stringParameter);
assertThat(longParameter.equals(intReturnType)).isFalse(); assertThat(longParameter).isNotEqualTo(intReturnType);
assertThat(intReturnType.equals(stringParameter)).isFalse(); assertThat(intReturnType).isNotEqualTo(stringParameter);
assertThat(intReturnType.equals(longParameter)).isFalse(); assertThat(intReturnType).isNotEqualTo(longParameter);
Method method = getClass().getMethod("method", String.class, Long.TYPE); Method method = getClass().getMethod("method", String.class, Long.TYPE);
MethodParameter methodParameter = new MethodParameter(method, 0); MethodParameter methodParameter = new MethodParameter(method, 0);

12
spring-core/src/test/java/org/springframework/core/annotation/SynthesizingMethodParameterTests.java
View File

@ -56,12 +56,12 @@ class SynthesizingMethodParameterTests {
assertThat(longParameter).isEqualTo(longParameter); assertThat(longParameter).isEqualTo(longParameter);
assertThat(intReturnType).isEqualTo(intReturnType); assertThat(intReturnType).isEqualTo(intReturnType);
assertThat(stringParameter.equals(longParameter)).isFalse(); assertThat(stringParameter).isNotEqualTo(longParameter);
assertThat(stringParameter.equals(intReturnType)).isFalse(); assertThat(stringParameter).isNotEqualTo(intReturnType);
assertThat(longParameter.equals(stringParameter)).isFalse(); assertThat(longParameter).isNotEqualTo(stringParameter);
assertThat(longParameter.equals(intReturnType)).isFalse(); assertThat(longParameter).isNotEqualTo(intReturnType);
assertThat(intReturnType.equals(stringParameter)).isFalse(); assertThat(intReturnType).isNotEqualTo(stringParameter);
assertThat(intReturnType.equals(longParameter)).isFalse(); assertThat(intReturnType).isNotEqualTo(longParameter);
Method method = getClass().getMethod("method", String.class, Long.TYPE); Method method = getClass().getMethod("method", String.class, Long.TYPE);
MethodParameter methodParameter = new SynthesizingMethodParameter(method, 0); MethodParameter methodParameter = new SynthesizingMethodParameter(method, 0);

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

@ -386,7 +386,7 @@ class GenericConversionServiceTests {
void convertiblePairDifferentEqualsAndHash() { void convertiblePairDifferentEqualsAndHash() {
GenericConverter.ConvertiblePair pair = new GenericConverter.ConvertiblePair(Number.class, String.class); GenericConverter.ConvertiblePair pair = new GenericConverter.ConvertiblePair(Number.class, String.class);
GenericConverter.ConvertiblePair pairOpposite = new GenericConverter.ConvertiblePair(String.class, Number.class); GenericConverter.ConvertiblePair pairOpposite = new GenericConverter.ConvertiblePair(String.class, Number.class);
assertThat(pair.equals(pairOpposite)).isFalse(); assertThat(pair).isNotEqualTo(pairOpposite);
assertThat(pair.hashCode()).isNotEqualTo(pairOpposite.hashCode()); assertThat(pair.hashCode()).isNotEqualTo(pairOpposite.hashCode());
} }

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

@ -72,7 +72,7 @@ class MapToMapConverterTests {
assertThat(conversionService.canConvert(sourceType, targetType)).isTrue(); assertThat(conversionService.canConvert(sourceType, targetType)).isTrue();
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Map<Integer, Integer> result = (Map<Integer, Integer>) conversionService.convert(map, sourceType, targetType); Map<Integer, Integer> result = (Map<Integer, Integer>) conversionService.convert(map, sourceType, targetType);
assertThat(map.equals(result)).isFalse(); assertThat(map).isNotEqualTo(result);
assertThat((int) result.get(1)).isEqualTo(9); assertThat((int) result.get(1)).isEqualTo(9);
assertThat((int) result.get(2)).isEqualTo(37); assertThat((int) result.get(2)).isEqualTo(37);
} }
@ -107,7 +107,7 @@ class MapToMapConverterTests {
assertThat(conversionService.canConvert(sourceType, targetType)).isTrue(); assertThat(conversionService.canConvert(sourceType, targetType)).isTrue();
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Map<Integer, Integer> result = (Map<Integer, Integer>) conversionService.convert(map, sourceType, targetType); Map<Integer, Integer> result = (Map<Integer, Integer>) conversionService.convert(map, sourceType, targetType);
assertThat(map.equals(result)).isFalse(); assertThat(map).isNotEqualTo(result);
assertThat((int) result.get(1)).isEqualTo(9); assertThat((int) result.get(1)).isEqualTo(9);
assertThat((int) result.get(2)).isEqualTo(37); assertThat((int) result.get(2)).isEqualTo(37);
} }
@ -133,7 +133,7 @@ class MapToMapConverterTests {
assertThat(conversionService.canConvert(sourceType, targetType)).isTrue(); assertThat(conversionService.canConvert(sourceType, targetType)).isTrue();
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Map<Integer, List<Integer>> result = (Map<Integer, List<Integer>>) conversionService.convert(map, sourceType, targetType); Map<Integer, List<Integer>> result = (Map<Integer, List<Integer>>) conversionService.convert(map, sourceType, targetType);
assertThat(map.equals(result)).isFalse(); assertThat(map).isNotEqualTo(result);
assertThat(result.get(1)).isEqualTo(Arrays.asList(9, 12)); assertThat(result.get(1)).isEqualTo(Arrays.asList(9, 12));
assertThat(result.get(2)).isEqualTo(Arrays.asList(37, 23)); assertThat(result.get(2)).isEqualTo(Arrays.asList(37, 23));
} }
@ -155,7 +155,7 @@ class MapToMapConverterTests {
assertThat(conversionService.canConvert(sourceType, targetType)).isTrue(); assertThat(conversionService.canConvert(sourceType, targetType)).isTrue();
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Map<Integer, List<Integer>> result = (Map<Integer, List<Integer>>) conversionService.convert(map, sourceType, targetType); Map<Integer, List<Integer>> result = (Map<Integer, List<Integer>>) conversionService.convert(map, sourceType, targetType);
assertThat(map.equals(result)).isFalse(); assertThat(map).isNotEqualTo(result);
assertThat(result.get(1)).isEqualTo(Arrays.asList(9, 12)); assertThat(result.get(1)).isEqualTo(Arrays.asList(9, 12));
assertThat(result.get(2)).isEqualTo(Arrays.asList(37, 23)); assertThat(result.get(2)).isEqualTo(Arrays.asList(37, 23));
} }

2
spring-core/src/test/java/org/springframework/core/io/support/EncodedResourceTests.java
View File

@ -43,7 +43,7 @@ class EncodedResourceTests {
@Test @Test
void equalsWithNullOtherObject() { void equalsWithNullOtherObject() {
assertThat(new EncodedResource(resource).equals(null)).isFalse(); assertThat(new EncodedResource(resource)).isNotEqualTo(null);
} }
@Test @Test

22
spring-core/src/test/java/org/springframework/core/type/AbstractAnnotationMetadataTests.java
View File

@ -44,20 +44,20 @@ public abstract class AbstractAnnotationMetadataTests {
AnnotationMetadata testMemberClass1 = get(TestMemberClass.class); AnnotationMetadata testMemberClass1 = get(TestMemberClass.class);
AnnotationMetadata testMemberClass2 = get(TestMemberClass.class); AnnotationMetadata testMemberClass2 = get(TestMemberClass.class);
assertThat(testClass1.equals(null)).isFalse(); assertThat(testClass1).isNotEqualTo(null);
assertThat(testClass1.equals(testClass1)).isTrue(); assertThat(testClass1).isEqualTo(testClass1);
assertThat(testClass2.equals(testClass2)).isTrue(); assertThat(testClass2).isEqualTo(testClass2);
assertThat(testClass1.equals(testClass2)).isTrue(); assertThat(testClass1).isEqualTo(testClass2);
assertThat(testClass2.equals(testClass1)).isTrue(); assertThat(testClass2).isEqualTo(testClass1);
assertThat(testMemberClass1.equals(testMemberClass1)).isTrue(); assertThat(testMemberClass1).isEqualTo(testMemberClass1);
assertThat(testMemberClass2.equals(testMemberClass2)).isTrue(); assertThat(testMemberClass2).isEqualTo(testMemberClass2);
assertThat(testMemberClass1.equals(testMemberClass2)).isTrue(); assertThat(testMemberClass1).isEqualTo(testMemberClass2);
assertThat(testMemberClass2.equals(testMemberClass1)).isTrue(); assertThat(testMemberClass2).isEqualTo(testMemberClass1);
assertThat(testClass1.equals(testMemberClass1)).isFalse(); assertThat(testClass1).isNotEqualTo(testMemberClass1);
assertThat(testMemberClass1.equals(testClass1)).isFalse(); assertThat(testMemberClass1).isNotEqualTo(testClass1);
} }
@Test @Test

22
spring-core/src/test/java/org/springframework/core/type/AbstractMethodMetadataTests.java
View File

@ -44,20 +44,20 @@ public abstract class AbstractMethodMetadataTests {
MethodMetadata withMethodWithTwoArguments1 = getTagged(WithMethodWithTwoArguments.class); MethodMetadata withMethodWithTwoArguments1 = getTagged(WithMethodWithTwoArguments.class);
MethodMetadata withMethodWithTwoArguments2 = getTagged(WithMethodWithTwoArguments.class); MethodMetadata withMethodWithTwoArguments2 = getTagged(WithMethodWithTwoArguments.class);
assertThat(withMethod1.equals(null)).isFalse(); assertThat(withMethod1).isNotEqualTo(null);
assertThat(withMethod1.equals(withMethod1)).isTrue(); assertThat(withMethod1).isEqualTo(withMethod1);
assertThat(withMethod2.equals(withMethod2)).isTrue(); assertThat(withMethod2).isEqualTo(withMethod2);
assertThat(withMethod1.equals(withMethod2)).isTrue(); assertThat(withMethod1).isEqualTo(withMethod2);
assertThat(withMethod2.equals(withMethod1)).isTrue(); assertThat(withMethod2).isEqualTo(withMethod1);
assertThat(withMethodWithTwoArguments1.equals(withMethodWithTwoArguments1)).isTrue(); assertThat(withMethodWithTwoArguments1).isEqualTo(withMethodWithTwoArguments1);
assertThat(withMethodWithTwoArguments2.equals(withMethodWithTwoArguments2)).isTrue(); assertThat(withMethodWithTwoArguments2).isEqualTo(withMethodWithTwoArguments2);
assertThat(withMethodWithTwoArguments1.equals(withMethodWithTwoArguments2)).isTrue(); assertThat(withMethodWithTwoArguments1).isEqualTo(withMethodWithTwoArguments2);
assertThat(withMethodWithTwoArguments2.equals(withMethodWithTwoArguments1)).isTrue(); assertThat(withMethodWithTwoArguments2).isEqualTo(withMethodWithTwoArguments1);
assertThat(withMethod1.equals(withMethodWithTwoArguments1)).isFalse(); assertThat(withMethod1).isNotEqualTo(withMethodWithTwoArguments1);
assertThat(withMethodWithTwoArguments1.equals(withMethod1)).isFalse(); assertThat(withMethodWithTwoArguments1).isNotEqualTo(withMethod1);
} }
@Test @Test

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

@ -876,7 +876,7 @@ class EvaluationTests extends AbstractExpressionTests {
e = parser.parseExpression("bd++"); e = parser.parseExpression("bd++");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue(); assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
BigDecimal return_bd = e.getValue(ctx, BigDecimal.class); BigDecimal return_bd = e.getValue(ctx, BigDecimal.class);
assertThat(new BigDecimal("2").equals(return_bd)).isTrue(); assertThat(new BigDecimal("2")).isEqualTo(return_bd);
assertThat(new BigDecimal("3").equals(helper.bd)).isTrue(); assertThat(new BigDecimal("3").equals(helper.bd)).isTrue();
// double // double
@ -929,7 +929,7 @@ class EvaluationTests extends AbstractExpressionTests {
e = parser.parseExpression("++bd"); e = parser.parseExpression("++bd");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue(); assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
BigDecimal return_bd = e.getValue(ctx, BigDecimal.class); BigDecimal return_bd = e.getValue(ctx, BigDecimal.class);
assertThat(new BigDecimal("3").equals(return_bd)).isTrue(); assertThat(new BigDecimal("3")).isEqualTo(return_bd);
assertThat(new BigDecimal("3").equals(helper.bd)).isTrue(); assertThat(new BigDecimal("3").equals(helper.bd)).isTrue();
// double // double
@ -1026,7 +1026,7 @@ class EvaluationTests extends AbstractExpressionTests {
e = parser.parseExpression("bd--"); e = parser.parseExpression("bd--");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue(); assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
BigDecimal return_bd = e.getValue(ctx,BigDecimal.class); BigDecimal return_bd = e.getValue(ctx,BigDecimal.class);
assertThat(new BigDecimal("2").equals(return_bd)).isTrue(); assertThat(new BigDecimal("2")).isEqualTo(return_bd);
assertThat(new BigDecimal("1").equals(helper.bd)).isTrue(); assertThat(new BigDecimal("1").equals(helper.bd)).isTrue();
// double // double
@ -1079,7 +1079,7 @@ class EvaluationTests extends AbstractExpressionTests {
e = parser.parseExpression("--bd"); e = parser.parseExpression("--bd");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue(); assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
BigDecimal return_bd = e.getValue(ctx,BigDecimal.class); BigDecimal return_bd = e.getValue(ctx,BigDecimal.class);
assertThat(new BigDecimal("1").equals(return_bd)).isTrue(); assertThat(new BigDecimal("1")).isEqualTo(return_bd);
assertThat(new BigDecimal("1").equals(helper.bd)).isTrue(); assertThat(new BigDecimal("1").equals(helper.bd)).isTrue();
// double // double

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

@ -482,7 +482,7 @@ public class MessageBrokerConfigurationTests {
assertThat(handler.getBroadcastDestination()).isNull(); assertThat(handler.getBroadcastDestination()).isNull();
Object nullBean = context.getBean("userRegistryMessageHandler"); Object nullBean = context.getBean("userRegistryMessageHandler");
assertThat(nullBean.equals(null)).isTrue(); assertThat(nullBean).isEqualTo(null);
} }
@Test // SPR-16275 @Test // SPR-16275

2
spring-orm/src/test/java/org/springframework/orm/jpa/LocalContainerEntityManagerFactoryBeanTests.java
View File

@ -88,7 +88,7 @@ public class LocalContainerEntityManagerFactoryBeanTests extends AbstractEntityM
assertThat(cefb.getObject()).as("EntityManagerFactory reference must be cached after init").isSameAs(emf); assertThat(cefb.getObject()).as("EntityManagerFactory reference must be cached after init").isSameAs(emf);
assertThat(emf).as("EMF must be proxied").isNotSameAs(mockEmf); assertThat(emf).as("EMF must be proxied").isNotSameAs(mockEmf);
assertThat(emf.equals(emf)).isTrue(); assertThat(emf).isEqualTo(emf);
DefaultListableBeanFactory bf = new DefaultListableBeanFactory(); DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.setSerializationId("emf-bf"); bf.setSerializationId("emf-bf");

4
spring-r2dbc/src/test/java/org/springframework/r2dbc/connection/TransactionAwareConnectionFactoryProxyUnitTests.java
View File

@ -126,8 +126,8 @@ class TransactionAwareConnectionFactoryProxyUnitTests {
new TransactionAwareConnectionFactoryProxy(connectionFactoryMock).create() new TransactionAwareConnectionFactoryProxy(connectionFactoryMock).create()
.map(Connection.class::cast).as(StepVerifier::create) .map(Connection.class::cast).as(StepVerifier::create)
.consumeNextWith(connection -> { .consumeNextWith(connection -> {
assertThat(connection.equals(connection)).isTrue(); assertThat(connection).isEqualTo(connection);
assertThat(connection.equals(connectionMock1)).isFalse(); assertThat(connection).isNotEqualTo(connectionMock1);
}).verifyComplete(); }).verifyComplete();
} }

16
spring-web/src/test/java/org/springframework/http/HttpEntityTests.java
View File

@ -97,10 +97,10 @@ public class HttpEntityTests {
assertThat(responseEntity.getHeaders().getFirst("Content-Type")).isEqualTo("text/plain"); assertThat(responseEntity.getHeaders().getFirst("Content-Type")).isEqualTo("text/plain");
assertThat(responseEntity.getHeaders().getFirst("Content-Type")).isEqualTo("text/plain"); assertThat(responseEntity.getHeaders().getFirst("Content-Type")).isEqualTo("text/plain");
assertThat(httpEntity.equals(responseEntity)).isFalse(); assertThat(httpEntity).isNotEqualTo(responseEntity);
assertThat(responseEntity.equals(httpEntity)).isFalse(); assertThat(responseEntity).isNotEqualTo(httpEntity);
assertThat(responseEntity.equals(responseEntity2)).isTrue(); assertThat(responseEntity).isEqualTo(responseEntity2);
assertThat(responseEntity2.equals(responseEntity)).isTrue(); assertThat(responseEntity2).isEqualTo(responseEntity);
} }
@Test @Test
@ -117,10 +117,10 @@ public class HttpEntityTests {
assertThat(requestEntity.getHeaders().getFirst("Content-Type")).isEqualTo("text/plain"); assertThat(requestEntity.getHeaders().getFirst("Content-Type")).isEqualTo("text/plain");
assertThat(requestEntity.getHeaders().getFirst("Content-Type")).isEqualTo("text/plain"); assertThat(requestEntity.getHeaders().getFirst("Content-Type")).isEqualTo("text/plain");
assertThat(httpEntity.equals(requestEntity)).isFalse(); assertThat(httpEntity).isNotEqualTo(requestEntity);
assertThat(requestEntity.equals(httpEntity)).isFalse(); assertThat(requestEntity).isNotEqualTo(httpEntity);
assertThat(requestEntity.equals(requestEntity2)).isTrue(); assertThat(requestEntity).isEqualTo(requestEntity2);
assertThat(requestEntity2.equals(requestEntity)).isTrue(); assertThat(requestEntity2).isEqualTo(requestEntity);
} }
} }

2
spring-web/src/test/java/org/springframework/web/util/pattern/PathPatternParserTests.java
View File

@ -112,7 +112,7 @@ public class PathPatternParserTests {
pp1 = caseInsensitiveParser.parse("/abc"); pp1 = caseInsensitiveParser.parse("/abc");
pp2 = caseSensitiveParser.parse("/abc"); pp2 = caseSensitiveParser.parse("/abc");
assertThat(pp1.equals(pp2)).isFalse(); assertThat(pp1).isNotEqualTo(pp2);
assertThat(pp2.hashCode()).isNotEqualTo(pp1.hashCode()); assertThat(pp2.hashCode()).isNotEqualTo(pp1.hashCode());
} }

14
spring-webflux/src/test/java/org/springframework/web/reactive/result/condition/RequestMappingInfoTests.java
View File

@ -233,7 +233,7 @@ public class RequestMappingInfoTests {
.customCondition(new ParamsRequestCondition("customFoo=customBar")) .customCondition(new ParamsRequestCondition("customFoo=customBar"))
.build(); .build();
assertThat(info1.equals(info2)).isFalse(); assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode()); assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = paths("/foo").methods(RequestMethod.GET, RequestMethod.POST) info2 = paths("/foo").methods(RequestMethod.GET, RequestMethod.POST)
@ -242,7 +242,7 @@ public class RequestMappingInfoTests {
.customCondition(new ParamsRequestCondition("customFoo=customBar")) .customCondition(new ParamsRequestCondition("customFoo=customBar"))
.build(); .build();
assertThat(info1.equals(info2)).isFalse(); assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode()); assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = paths("/foo").methods(RequestMethod.GET) info2 = paths("/foo").methods(RequestMethod.GET)
@ -251,7 +251,7 @@ public class RequestMappingInfoTests {
.customCondition(new ParamsRequestCondition("customFoo=customBar")) .customCondition(new ParamsRequestCondition("customFoo=customBar"))
.build(); .build();
assertThat(info1.equals(info2)).isFalse(); assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode()); assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = paths("/foo").methods(RequestMethod.GET) info2 = paths("/foo").methods(RequestMethod.GET)
@ -260,7 +260,7 @@ public class RequestMappingInfoTests {
.customCondition(new ParamsRequestCondition("customFoo=customBar")) .customCondition(new ParamsRequestCondition("customFoo=customBar"))
.build(); .build();
assertThat(info1.equals(info2)).isFalse(); assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode()); assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = paths("/foo").methods(RequestMethod.GET) info2 = paths("/foo").methods(RequestMethod.GET)
@ -269,7 +269,7 @@ public class RequestMappingInfoTests {
.customCondition(new ParamsRequestCondition("customFoo=customBar")) .customCondition(new ParamsRequestCondition("customFoo=customBar"))
.build(); .build();
assertThat(info1.equals(info2)).isFalse(); assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode()); assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = paths("/foo").methods(RequestMethod.GET) info2 = paths("/foo").methods(RequestMethod.GET)
@ -278,7 +278,7 @@ public class RequestMappingInfoTests {
.customCondition(new ParamsRequestCondition("customFoo=customBar")) .customCondition(new ParamsRequestCondition("customFoo=customBar"))
.build(); .build();
assertThat(info1.equals(info2)).isFalse(); assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode()); assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = paths("/foo").methods(RequestMethod.GET) info2 = paths("/foo").methods(RequestMethod.GET)
@ -287,7 +287,7 @@ public class RequestMappingInfoTests {
.customCondition(new ParamsRequestCondition("customFoo=NOOOOOO")) .customCondition(new ParamsRequestCondition("customFoo=NOOOOOO"))
.build(); .build();
assertThat(info1.equals(info2)).isFalse(); assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode()); assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
} }

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

@ -142,13 +142,13 @@ public class WebMvcConfigurationSupportTests {
assertThat(handlerMappings.containsKey("defaultServletHandlerMapping")).isFalse(); assertThat(handlerMappings.containsKey("defaultServletHandlerMapping")).isFalse();
Object nullBean = context.getBean("viewControllerHandlerMapping"); Object nullBean = context.getBean("viewControllerHandlerMapping");
assertThat(nullBean.equals(null)).isTrue(); assertThat(nullBean).isEqualTo(null);
nullBean = context.getBean("resourceHandlerMapping"); nullBean = context.getBean("resourceHandlerMapping");
assertThat(nullBean.equals(null)).isTrue(); assertThat(nullBean).isEqualTo(null);
nullBean = context.getBean("defaultServletHandlerMapping"); nullBean = context.getBean("defaultServletHandlerMapping");
assertThat(nullBean.equals(null)).isTrue(); assertThat(nullBean).isEqualTo(null);
} }
@Test @Test

14
spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/RequestMappingInfoTests.java
View File

@ -251,7 +251,7 @@ class RequestMappingInfoTests {
.consumes("text/plain").produces("text/plain") .consumes("text/plain").produces("text/plain")
.build(); .build();
assertThat(info1.equals(info2)).isFalse(); assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode()); assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = infoBuilder.paths("/foo").methods(GET, RequestMethod.POST) info2 = infoBuilder.paths("/foo").methods(GET, RequestMethod.POST)
@ -259,7 +259,7 @@ class RequestMappingInfoTests {
.consumes("text/plain").produces("text/plain") .consumes("text/plain").produces("text/plain")
.build(); .build();
assertThat(info1.equals(info2)).isFalse(); assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode()); assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = infoBuilder.paths("/foo").methods(GET) info2 = infoBuilder.paths("/foo").methods(GET)
@ -267,7 +267,7 @@ class RequestMappingInfoTests {
.consumes("text/plain").produces("text/plain") .consumes("text/plain").produces("text/plain")
.build(); .build();
assertThat(info1.equals(info2)).isFalse(); assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode()); assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = infoBuilder.paths("/foo").methods(GET) info2 = infoBuilder.paths("/foo").methods(GET)
@ -275,7 +275,7 @@ class RequestMappingInfoTests {
.consumes("text/plain").produces("text/plain") .consumes("text/plain").produces("text/plain")
.build(); .build();
assertThat(info1.equals(info2)).isFalse(); assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode()); assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = infoBuilder.paths("/foo").methods(GET) info2 = infoBuilder.paths("/foo").methods(GET)
@ -283,7 +283,7 @@ class RequestMappingInfoTests {
.consumes("text/NOOOOOO").produces("text/plain") .consumes("text/NOOOOOO").produces("text/plain")
.build(); .build();
assertThat(info1.equals(info2)).isFalse(); assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode()); assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = infoBuilder.paths("/foo").methods(GET) info2 = infoBuilder.paths("/foo").methods(GET)
@ -291,7 +291,7 @@ class RequestMappingInfoTests {
.consumes("text/plain").produces("text/NOOOOOO") .consumes("text/plain").produces("text/NOOOOOO")
.build(); .build();
assertThat(info1.equals(info2)).isFalse(); assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode()); assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = infoBuilder.paths("/foo").methods(GET) info2 = infoBuilder.paths("/foo").methods(GET)
@ -299,7 +299,7 @@ class RequestMappingInfoTests {
.consumes("text/plain").produces("text/plain") .consumes("text/plain").produces("text/plain")
.build(); .build();
assertThat(info1.equals(info2)).isFalse(); assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode()); assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
} }

4
spring-webmvc/src/test/java/org/springframework/web/servlet/view/BaseViewTests.java
View File

@ -231,8 +231,8 @@ public class BaseViewTests {
String kingval = ""; String kingval = "";
v.setAttributesCSV("foo=(" + fooval + "),king={" + kingval + "},f1=[we]"); v.setAttributesCSV("foo=(" + fooval + "),king={" + kingval + "},f1=[we]");
assertThat(v.getStaticAttributes()).hasSize(3); assertThat(v.getStaticAttributes()).hasSize(3);
assertThat(v.getStaticAttributes().get("foo").equals(fooval)).isTrue(); assertThat(v.getStaticAttributes().get("foo")).isEqualTo(fooval);
assertThat(v.getStaticAttributes().get("king").equals(kingval)).isTrue(); assertThat(v.getStaticAttributes().get("king")).isEqualTo(kingval);
} }
@Test @Test