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);
assertThat(pc1.equals(pc2)).isFalse();
assertThat(pc1).isNotEqualTo(pc2);
assertThat(pc1.hashCode()).isNotEqualTo(pc2.hashCode());
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() {
MethodMatcher first = MethodMatchers.union(MethodMatcher.TRUE, MethodMatcher.TRUE);
MethodMatcher second = new ComposablePointcut(MethodMatcher.TRUE).union(new ComposablePointcut(MethodMatcher.TRUE)).getMethodMatcher();
assertThat(first.equals(second)).isTrue();
assertThat(second.equals(first)).isTrue();
assertThat(first).isEqualTo(second);
assertThat(second).isEqualTo(first);
}
@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 r3 = service.multiConditionalCacheAndEvict(key);
assertThat(r1.equals(r3)).isFalse();
assertThat(r1).isNotEqualTo(r3);
assertThat(primary.get(key)).isNull();
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.setScope("request");
RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class);
assertThat(bd.equals(otherBd)).isFalse();
assertThat(otherBd.equals(bd)).isFalse();
assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd).isNotEqualTo(bd);
otherBd.setAbstract(true);
otherBd.setLazyInit(true);
otherBd.setScope("request");
assertThat(bd.equals(otherBd)).isTrue();
assertThat(otherBd.equals(bd)).isTrue();
assertThat(bd).isEqualTo(otherBd);
assertThat(otherBd).isEqualTo(bd);
assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode());
}
@ -52,14 +52,14 @@ public class BeanDefinitionTests {
bd.getPropertyValues().add("age", "99");
RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class);
otherBd.getPropertyValues().add("name", "myName");
assertThat(bd.equals(otherBd)).isFalse();
assertThat(otherBd.equals(bd)).isFalse();
assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd).isNotEqualTo(bd);
otherBd.getPropertyValues().add("age", "11");
assertThat(bd.equals(otherBd)).isFalse();
assertThat(otherBd.equals(bd)).isFalse();
assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd).isNotEqualTo(bd);
otherBd.getPropertyValues().add("age", "99");
assertThat(bd.equals(otherBd)).isTrue();
assertThat(otherBd.equals(bd)).isTrue();
assertThat(bd).isEqualTo(otherBd);
assertThat(otherBd).isEqualTo(bd);
assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode());
}
@ -70,14 +70,14 @@ public class BeanDefinitionTests {
bd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5);
RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class);
otherBd.getConstructorArgumentValues().addGenericArgumentValue("test");
assertThat(bd.equals(otherBd)).isFalse();
assertThat(otherBd.equals(bd)).isFalse();
assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd).isNotEqualTo(bd);
otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 9);
assertThat(bd.equals(otherBd)).isFalse();
assertThat(otherBd.equals(bd)).isFalse();
assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd).isNotEqualTo(bd);
otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5);
assertThat(bd.equals(otherBd)).isTrue();
assertThat(otherBd.equals(bd)).isTrue();
assertThat(bd).isEqualTo(otherBd);
assertThat(otherBd).isEqualTo(bd);
assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode());
}
@ -89,14 +89,14 @@ public class BeanDefinitionTests {
RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class);
otherBd.getConstructorArgumentValues().addGenericArgumentValue("test", "int");
otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5);
assertThat(bd.equals(otherBd)).isFalse();
assertThat(otherBd.equals(bd)).isFalse();
assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd).isNotEqualTo(bd);
otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5, "int");
assertThat(bd.equals(otherBd)).isFalse();
assertThat(otherBd.equals(bd)).isFalse();
assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd).isNotEqualTo(bd);
otherBd.getConstructorArgumentValues().addIndexedArgumentValue(1, 5, "long");
assertThat(bd.equals(otherBd)).isTrue();
assertThat(otherBd.equals(bd)).isTrue();
assertThat(bd).isEqualTo(otherBd);
assertThat(otherBd).isEqualTo(bd);
assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode());
}
@ -111,21 +111,21 @@ public class BeanDefinitionTests {
otherBd.setScope("request");
otherBd.setAbstract(true);
otherBd.setLazyInit(true);
assertThat(bd.equals(otherBd)).isFalse();
assertThat(otherBd.equals(bd)).isFalse();
assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd).isNotEqualTo(bd);
otherBd.setParentName("parent");
assertThat(bd.equals(otherBd)).isTrue();
assertThat(otherBd.equals(bd)).isTrue();
assertThat(bd).isEqualTo(otherBd);
assertThat(otherBd).isEqualTo(bd);
assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode());
bd.getPropertyValues();
assertThat(bd.equals(otherBd)).isTrue();
assertThat(otherBd.equals(bd)).isTrue();
assertThat(bd).isEqualTo(otherBd);
assertThat(otherBd).isEqualTo(bd);
assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode());
bd.getConstructorArgumentValues();
assertThat(bd.equals(otherBd)).isTrue();
assertThat(otherBd.equals(bd)).isTrue();
assertThat(bd).isEqualTo(otherBd);
assertThat(otherBd).isEqualTo(bd);
assertThat(bd.hashCode()).isEqualTo(otherBd.hashCode());
}
@ -137,14 +137,14 @@ public class BeanDefinitionTests {
bd.setScope("request");
BeanDefinitionHolder holder = new BeanDefinitionHolder(bd, "bd");
RootBeanDefinition otherBd = new RootBeanDefinition(TestBean.class);
assertThat(bd.equals(otherBd)).isFalse();
assertThat(otherBd.equals(bd)).isFalse();
assertThat(bd).isNotEqualTo(otherBd);
assertThat(otherBd).isNotEqualTo(bd);
otherBd.setAbstract(true);
otherBd.setLazyInit(true);
otherBd.setScope("request");
BeanDefinitionHolder otherHolder = new BeanDefinitionHolder(bd, "bd");
assertThat(holder.equals(otherHolder)).isTrue();
assertThat(otherHolder.equals(holder)).isTrue();
assertThat(holder).isEqualTo(otherHolder);
assertThat(otherHolder).isEqualTo(holder);
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();
assertThat(l.get(0).equals("literal")).isTrue();
Integer[] array1 = (Integer[]) l.get(1);
assertThat(array1[0].equals(2)).isTrue();
assertThat(array1[1].equals(4)).isTrue();
assertThat(array1[0]).isEqualTo(2);
assertThat(array1[1]).isEqualTo(4);
int[] array2 = (int[]) l.get(2);
assertThat(array2[0]).isEqualTo(3);
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() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("mixedMap");
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");
assertThat(hasMap.getMap().get("jenny")).isSameAs(jenny);
assertThat(hasMap.getMap().get(5).equals("david")).isTrue();
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").equals(200)).isTrue();
assertThat(hasMap.getMap().get("baz")).isEqualTo(200);
}
@Test
@ -230,7 +230,7 @@ public class XmlBeanCollectionTests {
assertThat(hasMap.getMap().size()).isEqualTo(4);
assertThat(hasMap.getMap().get(null).equals("bar")).isTrue();
TestBean jenny = (TestBean) this.beanFactory.getBean("jenny");
assertThat(hasMap.getMap().get("jenny").equals(jenny)).isTrue();
assertThat(hasMap.getMap().get("jenny")).isEqualTo(jenny);
// Check list
List l = (List) hasMap.getMap().get("list");
@ -250,7 +250,7 @@ public class XmlBeanCollectionTests {
l = (List) l.get(2);
assertThat(l).isNotNull();
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();
// 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
message1 = new SimpleMailMessage();
message2 = message1;
assertThat(message1.equals(message2)).isTrue();
assertThat(message1).isEqualTo(message2);
// Null object is not equal
message1 = new SimpleMailMessage();
@ -143,7 +143,7 @@ public class SimpleMailMessageTests {
// Equal values are equal
message1 = new SimpleMailMessage();
message2 = new SimpleMailMessage();
assertThat(message1.equals(message2)).isTrue();
assertThat(message1).isEqualTo(message2);
message1 = new SimpleMailMessage();
message1.setFrom("from@somewhere");
@ -155,7 +155,7 @@ public class SimpleMailMessageTests {
message1.setSubject("subject");
message1.setText("text");
message2 = new SimpleMailMessage(message1);
assertThat(message1.equals(message2)).isTrue();
assertThat(message1).isEqualTo(message2);
}
@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(proxyB).isEqualTo(proxyA);
assertThat(proxyB.hashCode()).isEqualTo(proxyA.hashCode());
assertThat(proxyA.equals(a)).isFalse();
assertThat(proxyA).isNotEqualTo(a);
// Equality checks were handled by the proxy
assertThat(i1.getCount()).isEqualTo(0);
@ -1187,7 +1187,7 @@ public abstract class AbstractAopProxyTests {
// and won't think it's equal to B's NopInterceptor
proxyA.absquatulate();
assertThat(i1.getCount()).isEqualTo(1);
assertThat(proxyA.equals(proxyB)).isFalse();
assertThat(proxyA).isNotEqualTo(proxyB);
}
@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 configurationClass3 = newConfigurationClass(Config2.class);
assertThat(configurationClass1.equals(null)).isFalse();
assertThat(configurationClass1).isNotEqualTo(null);
assertThat(configurationClass1).isNotSameAs(configurationClass2);
assertThat(configurationClass1.equals(configurationClass1)).isTrue();
assertThat(configurationClass2.equals(configurationClass2)).isTrue();
assertThat(configurationClass1.equals(configurationClass2)).isTrue();
assertThat(configurationClass2.equals(configurationClass1)).isTrue();
assertThat(configurationClass1).isEqualTo(configurationClass1);
assertThat(configurationClass2).isEqualTo(configurationClass2);
assertThat(configurationClass1).isEqualTo(configurationClass2);
assertThat(configurationClass2).isEqualTo(configurationClass1);
assertThat(configurationClass1.equals(configurationClass3)).isFalse();
assertThat(configurationClass3.equals(configurationClass2)).isFalse();
assertThat(configurationClass1).isNotEqualTo(configurationClass3);
assertThat(configurationClass3).isNotEqualTo(configurationClass2);
// ---------------------------------------------------------------------
@ -72,18 +72,18 @@ class ConfigurationClassAndBeanMethodTests {
BeanMethod beanMethod_3_1 = beanMethods3.get(1);
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.equals(beanMethod_1_0)).isTrue();
assertThat(beanMethod_1_0.equals(beanMethod_2_0)).isTrue();
assertThat(beanMethod_1_1.equals(beanMethod_2_1)).isTrue();
assertThat(beanMethod_1_2.equals(beanMethod_2_2)).isTrue();
assertThat(beanMethod_1_0).isEqualTo(beanMethod_1_0);
assertThat(beanMethod_1_0).isEqualTo(beanMethod_2_0);
assertThat(beanMethod_1_1).isEqualTo(beanMethod_2_1);
assertThat(beanMethod_1_2).isEqualTo(beanMethod_2_2);
assertThat(beanMethod_1_0.getMetadata().getMethodName()).isEqualTo(beanMethod_3_0.getMetadata().getMethodName());
assertThat(beanMethod_1_0.equals(beanMethod_3_0)).isFalse();
assertThat(beanMethod_1_1.equals(beanMethod_3_1)).isFalse();
assertThat(beanMethod_1_2.equals(beanMethod_3_2)).isFalse();
assertThat(beanMethod_1_0).isNotEqualTo(beanMethod_3_0);
assertThat(beanMethod_1_1).isNotEqualTo(beanMethod_3_1);
assertThat(beanMethod_1_2).isNotEqualTo(beanMethod_3_2);
}
@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);
TestBean foo = factory.getBean("foo", TestBean.class);
assertThat(factory.getBean("bar").equals(null)).isTrue();
assertThat(factory.getBean("bar")).isEqualTo(null);
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 second = new AnnotatedElementKey(this.method, null);
assertThat(first.equals(second)).isFalse();
assertThat(first).isNotEqualTo(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 trigger2 = new PeriodicTrigger(Duration.ofMillis(3000));
assertThat(trigger1.equals(new String("not a trigger"))).isFalse();
assertThat(trigger1.equals(null)).isFalse();
assertThat(trigger1).isNotEqualTo(null);
assertThat(trigger1).isEqualTo(trigger1);
assertThat(trigger2).isEqualTo(trigger2);
assertThat(trigger2).isEqualTo(trigger1);
trigger2.setInitialDelay(1234);
assertThat(trigger1.equals(trigger2)).isFalse();
assertThat(trigger2.equals(trigger1)).isFalse();
assertThat(trigger1).isNotEqualTo(trigger2);
assertThat(trigger2).isNotEqualTo(trigger1);
trigger1.setInitialDelay(1234);
assertThat(trigger2).isEqualTo(trigger1);
trigger2.setFixedRate(true);
assertThat(trigger1.equals(trigger2)).isFalse();
assertThat(trigger2.equals(trigger1)).isFalse();
assertThat(trigger1).isNotEqualTo(trigger2);
assertThat(trigger2).isNotEqualTo(trigger1);
trigger1.setFixedRate(true);
assertThat(trigger2).isEqualTo(trigger1);
PeriodicTrigger trigger3 = new PeriodicTrigger(Duration.ofSeconds(3));
trigger3.setInitialDelay(Duration.ofSeconds(7));
trigger3.setFixedRate(true);
assertThat(trigger1.equals(trigger3)).isFalse();
assertThat(trigger3.equals(trigger1)).isFalse();
assertThat(trigger1).isNotEqualTo(trigger3);
assertThat(trigger3).isNotEqualTo(trigger1);
trigger1.setInitialDelay(Duration.ofMillis(7000));
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 r3 = service.multiConditionalCacheAndEvict(key);
assertThat(r1.equals(r3)).isFalse();
assertThat(r1).isNotEqualTo(r3);
assertThat(primary.get(key)).isNull();
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(intReturnType).isEqualTo(intReturnType);
assertThat(stringParameter.equals(longParameter)).isFalse();
assertThat(stringParameter.equals(intReturnType)).isFalse();
assertThat(longParameter.equals(stringParameter)).isFalse();
assertThat(longParameter.equals(intReturnType)).isFalse();
assertThat(intReturnType.equals(stringParameter)).isFalse();
assertThat(intReturnType.equals(longParameter)).isFalse();
assertThat(stringParameter).isNotEqualTo(longParameter);
assertThat(stringParameter).isNotEqualTo(intReturnType);
assertThat(longParameter).isNotEqualTo(stringParameter);
assertThat(longParameter).isNotEqualTo(intReturnType);
assertThat(intReturnType).isNotEqualTo(stringParameter);
assertThat(intReturnType).isNotEqualTo(longParameter);
Method method = getClass().getMethod("method", String.class, Long.TYPE);
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(intReturnType).isEqualTo(intReturnType);
assertThat(stringParameter.equals(longParameter)).isFalse();
assertThat(stringParameter.equals(intReturnType)).isFalse();
assertThat(longParameter.equals(stringParameter)).isFalse();
assertThat(longParameter.equals(intReturnType)).isFalse();
assertThat(intReturnType.equals(stringParameter)).isFalse();
assertThat(intReturnType.equals(longParameter)).isFalse();
assertThat(stringParameter).isNotEqualTo(longParameter);
assertThat(stringParameter).isNotEqualTo(intReturnType);
assertThat(longParameter).isNotEqualTo(stringParameter);
assertThat(longParameter).isNotEqualTo(intReturnType);
assertThat(intReturnType).isNotEqualTo(stringParameter);
assertThat(intReturnType).isNotEqualTo(longParameter);
Method method = getClass().getMethod("method", String.class, Long.TYPE);
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() {
GenericConverter.ConvertiblePair pair = new GenericConverter.ConvertiblePair(Number.class, String.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());
}

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();
@SuppressWarnings("unchecked")
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(2)).isEqualTo(37);
}
@ -107,7 +107,7 @@ class MapToMapConverterTests {
assertThat(conversionService.canConvert(sourceType, targetType)).isTrue();
@SuppressWarnings("unchecked")
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(2)).isEqualTo(37);
}
@ -133,7 +133,7 @@ class MapToMapConverterTests {
assertThat(conversionService.canConvert(sourceType, targetType)).isTrue();
@SuppressWarnings("unchecked")
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(2)).isEqualTo(Arrays.asList(37, 23));
}
@ -155,7 +155,7 @@ class MapToMapConverterTests {
assertThat(conversionService.canConvert(sourceType, targetType)).isTrue();
@SuppressWarnings("unchecked")
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(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
void equalsWithNullOtherObject() {
assertThat(new EncodedResource(resource).equals(null)).isFalse();
assertThat(new EncodedResource(resource)).isNotEqualTo(null);
}
@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 testMemberClass2 = get(TestMemberClass.class);
assertThat(testClass1.equals(null)).isFalse();
assertThat(testClass1).isNotEqualTo(null);
assertThat(testClass1.equals(testClass1)).isTrue();
assertThat(testClass2.equals(testClass2)).isTrue();
assertThat(testClass1.equals(testClass2)).isTrue();
assertThat(testClass2.equals(testClass1)).isTrue();
assertThat(testClass1).isEqualTo(testClass1);
assertThat(testClass2).isEqualTo(testClass2);
assertThat(testClass1).isEqualTo(testClass2);
assertThat(testClass2).isEqualTo(testClass1);
assertThat(testMemberClass1.equals(testMemberClass1)).isTrue();
assertThat(testMemberClass2.equals(testMemberClass2)).isTrue();
assertThat(testMemberClass1.equals(testMemberClass2)).isTrue();
assertThat(testMemberClass2.equals(testMemberClass1)).isTrue();
assertThat(testMemberClass1).isEqualTo(testMemberClass1);
assertThat(testMemberClass2).isEqualTo(testMemberClass2);
assertThat(testMemberClass1).isEqualTo(testMemberClass2);
assertThat(testMemberClass2).isEqualTo(testMemberClass1);
assertThat(testClass1.equals(testMemberClass1)).isFalse();
assertThat(testMemberClass1.equals(testClass1)).isFalse();
assertThat(testClass1).isNotEqualTo(testMemberClass1);
assertThat(testMemberClass1).isNotEqualTo(testClass1);
}
@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 withMethodWithTwoArguments2 = getTagged(WithMethodWithTwoArguments.class);
assertThat(withMethod1.equals(null)).isFalse();
assertThat(withMethod1).isNotEqualTo(null);
assertThat(withMethod1.equals(withMethod1)).isTrue();
assertThat(withMethod2.equals(withMethod2)).isTrue();
assertThat(withMethod1.equals(withMethod2)).isTrue();
assertThat(withMethod2.equals(withMethod1)).isTrue();
assertThat(withMethod1).isEqualTo(withMethod1);
assertThat(withMethod2).isEqualTo(withMethod2);
assertThat(withMethod1).isEqualTo(withMethod2);
assertThat(withMethod2).isEqualTo(withMethod1);
assertThat(withMethodWithTwoArguments1.equals(withMethodWithTwoArguments1)).isTrue();
assertThat(withMethodWithTwoArguments2.equals(withMethodWithTwoArguments2)).isTrue();
assertThat(withMethodWithTwoArguments1.equals(withMethodWithTwoArguments2)).isTrue();
assertThat(withMethodWithTwoArguments2.equals(withMethodWithTwoArguments1)).isTrue();
assertThat(withMethodWithTwoArguments1).isEqualTo(withMethodWithTwoArguments1);
assertThat(withMethodWithTwoArguments2).isEqualTo(withMethodWithTwoArguments2);
assertThat(withMethodWithTwoArguments1).isEqualTo(withMethodWithTwoArguments2);
assertThat(withMethodWithTwoArguments2).isEqualTo(withMethodWithTwoArguments1);
assertThat(withMethod1.equals(withMethodWithTwoArguments1)).isFalse();
assertThat(withMethodWithTwoArguments1.equals(withMethod1)).isFalse();
assertThat(withMethod1).isNotEqualTo(withMethodWithTwoArguments1);
assertThat(withMethodWithTwoArguments1).isNotEqualTo(withMethod1);
}
@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++");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
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();
// double
@ -929,7 +929,7 @@ class EvaluationTests extends AbstractExpressionTests {
e = parser.parseExpression("++bd");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
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();
// double
@ -1026,7 +1026,7 @@ class EvaluationTests extends AbstractExpressionTests {
e = parser.parseExpression("bd--");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
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();
// double
@ -1079,7 +1079,7 @@ class EvaluationTests extends AbstractExpressionTests {
e = parser.parseExpression("--bd");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
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();
// 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();
Object nullBean = context.getBean("userRegistryMessageHandler");
assertThat(nullBean.equals(null)).isTrue();
assertThat(nullBean).isEqualTo(null);
}
@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(emf).as("EMF must be proxied").isNotSameAs(mockEmf);
assertThat(emf.equals(emf)).isTrue();
assertThat(emf).isEqualTo(emf);
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
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()
.map(Connection.class::cast).as(StepVerifier::create)
.consumeNextWith(connection -> {
assertThat(connection.equals(connection)).isTrue();
assertThat(connection.equals(connectionMock1)).isFalse();
assertThat(connection).isEqualTo(connection);
assertThat(connection).isNotEqualTo(connectionMock1);
}).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(httpEntity.equals(responseEntity)).isFalse();
assertThat(responseEntity.equals(httpEntity)).isFalse();
assertThat(responseEntity.equals(responseEntity2)).isTrue();
assertThat(responseEntity2.equals(responseEntity)).isTrue();
assertThat(httpEntity).isNotEqualTo(responseEntity);
assertThat(responseEntity).isNotEqualTo(httpEntity);
assertThat(responseEntity).isEqualTo(responseEntity2);
assertThat(responseEntity2).isEqualTo(responseEntity);
}
@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(httpEntity.equals(requestEntity)).isFalse();
assertThat(requestEntity.equals(httpEntity)).isFalse();
assertThat(requestEntity.equals(requestEntity2)).isTrue();
assertThat(requestEntity2.equals(requestEntity)).isTrue();
assertThat(httpEntity).isNotEqualTo(requestEntity);
assertThat(requestEntity).isNotEqualTo(httpEntity);
assertThat(requestEntity).isEqualTo(requestEntity2);
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");
pp2 = caseSensitiveParser.parse("/abc");
assertThat(pp1.equals(pp2)).isFalse();
assertThat(pp1).isNotEqualTo(pp2);
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"))
.build();
assertThat(info1.equals(info2)).isFalse();
assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = paths("/foo").methods(RequestMethod.GET, RequestMethod.POST)
@ -242,7 +242,7 @@ public class RequestMappingInfoTests {
.customCondition(new ParamsRequestCondition("customFoo=customBar"))
.build();
assertThat(info1.equals(info2)).isFalse();
assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = paths("/foo").methods(RequestMethod.GET)
@ -251,7 +251,7 @@ public class RequestMappingInfoTests {
.customCondition(new ParamsRequestCondition("customFoo=customBar"))
.build();
assertThat(info1.equals(info2)).isFalse();
assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = paths("/foo").methods(RequestMethod.GET)
@ -260,7 +260,7 @@ public class RequestMappingInfoTests {
.customCondition(new ParamsRequestCondition("customFoo=customBar"))
.build();
assertThat(info1.equals(info2)).isFalse();
assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = paths("/foo").methods(RequestMethod.GET)
@ -269,7 +269,7 @@ public class RequestMappingInfoTests {
.customCondition(new ParamsRequestCondition("customFoo=customBar"))
.build();
assertThat(info1.equals(info2)).isFalse();
assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = paths("/foo").methods(RequestMethod.GET)
@ -278,7 +278,7 @@ public class RequestMappingInfoTests {
.customCondition(new ParamsRequestCondition("customFoo=customBar"))
.build();
assertThat(info1.equals(info2)).isFalse();
assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = paths("/foo").methods(RequestMethod.GET)
@ -287,7 +287,7 @@ public class RequestMappingInfoTests {
.customCondition(new ParamsRequestCondition("customFoo=NOOOOOO"))
.build();
assertThat(info1.equals(info2)).isFalse();
assertThat(info1).isNotEqualTo(info2);
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();
Object nullBean = context.getBean("viewControllerHandlerMapping");
assertThat(nullBean.equals(null)).isTrue();
assertThat(nullBean).isEqualTo(null);
nullBean = context.getBean("resourceHandlerMapping");
assertThat(nullBean.equals(null)).isTrue();
assertThat(nullBean).isEqualTo(null);
nullBean = context.getBean("defaultServletHandlerMapping");
assertThat(nullBean.equals(null)).isTrue();
assertThat(nullBean).isEqualTo(null);
}
@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")
.build();
assertThat(info1.equals(info2)).isFalse();
assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = infoBuilder.paths("/foo").methods(GET, RequestMethod.POST)
@ -259,7 +259,7 @@ class RequestMappingInfoTests {
.consumes("text/plain").produces("text/plain")
.build();
assertThat(info1.equals(info2)).isFalse();
assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = infoBuilder.paths("/foo").methods(GET)
@ -267,7 +267,7 @@ class RequestMappingInfoTests {
.consumes("text/plain").produces("text/plain")
.build();
assertThat(info1.equals(info2)).isFalse();
assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = infoBuilder.paths("/foo").methods(GET)
@ -275,7 +275,7 @@ class RequestMappingInfoTests {
.consumes("text/plain").produces("text/plain")
.build();
assertThat(info1.equals(info2)).isFalse();
assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = infoBuilder.paths("/foo").methods(GET)
@ -283,7 +283,7 @@ class RequestMappingInfoTests {
.consumes("text/NOOOOOO").produces("text/plain")
.build();
assertThat(info1.equals(info2)).isFalse();
assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = infoBuilder.paths("/foo").methods(GET)
@ -291,7 +291,7 @@ class RequestMappingInfoTests {
.consumes("text/plain").produces("text/NOOOOOO")
.build();
assertThat(info1.equals(info2)).isFalse();
assertThat(info1).isNotEqualTo(info2);
assertThat(info2.hashCode()).isNotEqualTo(info1.hashCode());
info2 = infoBuilder.paths("/foo").methods(GET)
@ -299,7 +299,7 @@ class RequestMappingInfoTests {
.consumes("text/plain").produces("text/plain")
.build();
assertThat(info1.equals(info2)).isFalse();
assertThat(info1).isNotEqualTo(info2);
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 = "";
v.setAttributesCSV("foo=(" + fooval + "),king={" + kingval + "},f1=[we]");
assertThat(v.getStaticAttributes()).hasSize(3);
assertThat(v.getStaticAttributes().get("foo").equals(fooval)).isTrue();
assertThat(v.getStaticAttributes().get("king").equals(kingval)).isTrue();
assertThat(v.getStaticAttributes().get("foo")).isEqualTo(fooval);
assertThat(v.getStaticAttributes().get("king")).isEqualTo(kingval);
}
@Test