From 87c4acd7ac2255bb2f5e421f3f3f37330157cd38 Mon Sep 17 00:00:00 2001 From: Sam Brannen <104798+sbrannen@users.noreply.github.com> Date: Thu, 19 Mar 2026 17:06:37 +0100 Subject: [PATCH] Convert assertThat(x.equals(y)).isTrue() to assertThat(x).isEqualTo(y) Search: assertThat\((?!\s*Arrays\.)((?:[^()]+|\([^()]*\))+)\.equals\(\s*((?:[^()]+|\([^()]*\))+)\s*\)\)(.*)\.isTrue\(\) Replace: assertThat($1)$3.isEqualTo($2) See gh-36504 --- .../beans/AbstractPropertyAccessorTests.java | 8 +- .../DefaultListableBeanFactoryTests.java | 4 +- .../MethodInvokingFactoryBeanTests.java | 2 +- .../xml/CollectionsWithDefaultTypesTests.java | 2 +- .../factory/xml/XmlBeanCollectionTests.java | 52 ++++----- .../propertyeditors/CustomEditorTests.java | 18 +-- .../PropertiesEditorTests.java | 26 ++--- .../factory/xml/AbstractBeanFactoryTests.java | 12 +- .../factory/xml/XmlBeanFactoryTests.java | 4 +- .../DataBinderFieldAccessTests.java | 2 +- .../validation/DataBinderTests.java | 4 +- .../AbstractApplicationContextTests.java | 6 +- .../core/ResolvableTypeTests.java | 2 +- .../annotation/AnnotationAttributesTests.java | 2 +- .../core/type/AnnotationMetadataTests.java | 12 +- .../util/CompositeSetTests.java | 2 +- .../util/FilteredSetTests.java | 2 +- .../util/StringUtilsTests.java | 106 ++++++++---------- .../expression/spel/EvaluationTests.java | 16 +-- .../springframework/http/HttpEntityTests.java | 6 +- .../bind/ServletRequestDataBinderTests.java | 2 +- .../web/bind/ServletRequestUtilsTests.java | 2 +- .../support/WebRequestDataBinderTests.java | 2 +- .../web/servlet/DispatcherServletTests.java | 6 +- .../web/servlet/tags/form/SelectTagTests.java | 2 +- .../web/servlet/view/BaseViewTests.java | 4 +- .../web/servlet/view/RedirectViewTests.java | 2 +- .../web/servlet/view/ViewResolverTests.java | 8 +- 28 files changed, 149 insertions(+), 167 deletions(-) diff --git a/spring-beans/src/test/java/org/springframework/beans/AbstractPropertyAccessorTests.java b/spring-beans/src/test/java/org/springframework/beans/AbstractPropertyAccessorTests.java index 69b54a9dc18..ee2802868e0 100644 --- a/spring-beans/src/test/java/org/springframework/beans/AbstractPropertyAccessorTests.java +++ b/spring-beans/src/test/java/org/springframework/beans/AbstractPropertyAccessorTests.java @@ -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(Boolean.TRUE).as("Correct bool2 value").isEqualTo(accessor.getPropertyValue("bool2")); 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(Boolean.FALSE).as("Correct bool2 value").isEqualTo(accessor.getPropertyValue("bool2")); 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()); diff --git a/spring-beans/src/test/java/org/springframework/beans/factory/DefaultListableBeanFactoryTests.java b/spring-beans/src/test/java/org/springframework/beans/factory/DefaultListableBeanFactoryTests.java index a582e69a286..e5e024a9313 100644 --- a/spring-beans/src/test/java/org/springframework/beans/factory/DefaultListableBeanFactoryTests.java +++ b/spring-beans/src/test/java/org/springframework/beans/factory/DefaultListableBeanFactoryTests.java @@ -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(); } diff --git a/spring-beans/src/test/java/org/springframework/beans/factory/config/MethodInvokingFactoryBeanTests.java b/spring-beans/src/test/java/org/springframework/beans/factory/config/MethodInvokingFactoryBeanTests.java index f7b6ce35e93..41fae11cc0a 100644 --- a/spring-beans/src/test/java/org/springframework/beans/factory/config/MethodInvokingFactoryBeanTests.java +++ b/spring-beans/src/test/java/org/springframework/beans/factory/config/MethodInvokingFactoryBeanTests.java @@ -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); diff --git a/spring-beans/src/test/java/org/springframework/beans/factory/xml/CollectionsWithDefaultTypesTests.java b/spring-beans/src/test/java/org/springframework/beans/factory/xml/CollectionsWithDefaultTypesTests.java index 86846a05552..75d776ecfaa 100644 --- a/spring-beans/src/test/java/org/springframework/beans/factory/xml/CollectionsWithDefaultTypesTests.java +++ b/spring-beans/src/test/java/org/springframework/beans/factory/xml/CollectionsWithDefaultTypesTests.java @@ -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); diff --git a/spring-beans/src/test/java/org/springframework/beans/factory/xml/XmlBeanCollectionTests.java b/spring-beans/src/test/java/org/springframework/beans/factory/xml/XmlBeanCollectionTests.java index a1a6dad0bd3..0bddf4eae1e 100644 --- a/spring-beans/src/test/java/org/springframework/beans/factory/xml/XmlBeanCollectionTests.java +++ b/spring-beans/src/test/java/org/springframework/beans/factory/xml/XmlBeanCollectionTests.java @@ -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 diff --git a/spring-beans/src/test/java/org/springframework/beans/propertyeditors/CustomEditorTests.java b/spring-beans/src/test/java/org/springframework/beans/propertyeditors/CustomEditorTests.java index 5ff3de4eafb..4253952e30b 100644 --- a/spring-beans/src/test/java/org/springframework/beans/propertyeditors/CustomEditorTests.java +++ b/spring-beans/src/test/java/org/springframework/beans/propertyeditors/CustomEditorTests.java @@ -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(Boolean.TRUE).as("Correct bool1 value").isEqualTo(bw.getPropertyValue("bool1")); 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(Boolean.FALSE).as("Correct bool1 value").isEqualTo(bw.getPropertyValue("bool1")); 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(Boolean.TRUE).as("Correct bool2 value").isEqualTo(bw.getPropertyValue("bool2")); 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(Boolean.FALSE).as("Correct bool2 value").isEqualTo(bw.getPropertyValue("bool2")); 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(Boolean.TRUE).as("Correct bool2 value").isEqualTo(bw.getPropertyValue("bool2")); 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(Boolean.FALSE).as("Correct bool2 value").isEqualTo(bw.getPropertyValue("bool2")); 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(); diff --git a/spring-beans/src/test/java/org/springframework/beans/propertyeditors/PropertiesEditorTests.java b/spring-beans/src/test/java/org/springframework/beans/propertyeditors/PropertiesEditorTests.java index 76d77e50f6a..dfb86c14096 100644 --- a/spring-beans/src/test/java/org/springframework/beans/propertyeditors/PropertiesEditorTests.java +++ b/spring-beans/src/test/java/org/springframework/beans/propertyeditors/PropertiesEditorTests.java @@ -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"); } /** diff --git a/spring-beans/src/testFixtures/java/org/springframework/beans/testfixture/factory/xml/AbstractBeanFactoryTests.java b/spring-beans/src/testFixtures/java/org/springframework/beans/testfixture/factory/xml/AbstractBeanFactoryTests.java index f08e1bd13ac..156686bb6ce 100644 --- a/spring-beans/src/testFixtures/java/org/springframework/beans/testfixture/factory/xml/AbstractBeanFactoryTests.java +++ b/spring-beans/src/testFixtures/java/org/springframework/beans/testfixture/factory/xml/AbstractBeanFactoryTests.java @@ -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()); } @@ -97,7 +97,7 @@ public abstract class AbstractBeanFactoryTests { 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); }); } @@ -155,7 +155,7 @@ 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); @@ -190,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 @@ -198,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); diff --git a/spring-context/src/test/java/org/springframework/beans/factory/xml/XmlBeanFactoryTests.java b/spring-context/src/test/java/org/springframework/beans/factory/xml/XmlBeanFactoryTests.java index e49bcac4c39..78f47ad86b2 100644 --- a/spring-context/src/test/java/org/springframework/beans/factory/xml/XmlBeanFactoryTests.java +++ b/spring-context/src/test/java/org/springframework/beans/factory/xml/XmlBeanFactoryTests.java @@ -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 diff --git a/spring-context/src/test/java/org/springframework/validation/DataBinderFieldAccessTests.java b/spring-context/src/test/java/org/springframework/validation/DataBinderFieldAccessTests.java index 17b27039406..cc1e22ad51c 100644 --- a/spring-context/src/test/java/org/springframework/validation/DataBinderFieldAccessTests.java +++ b/spring-context/src/test/java/org/springframework/validation/DataBinderFieldAccessTests.java @@ -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 diff --git a/spring-context/src/test/java/org/springframework/validation/DataBinderTests.java b/spring-context/src/test/java/org/springframework/validation/DataBinderTests.java index afd94228ba7..92a9e18a99d 100644 --- a/spring-context/src/test/java/org/springframework/validation/DataBinderTests.java +++ b/spring-context/src/test/java/org/springframework/validation/DataBinderTests.java @@ -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 diff --git a/spring-context/src/testFixtures/java/org/springframework/context/testfixture/AbstractApplicationContextTests.java b/spring-context/src/testFixtures/java/org/springframework/context/testfixture/AbstractApplicationContextTests.java index 57a8c670af0..4b32b4b40e3 100644 --- a/spring-context/src/testFixtures/java/org/springframework/context/testfixture/AbstractApplicationContextTests.java +++ b/spring-context/src/testFixtures/java/org/springframework/context/testfixture/AbstractApplicationContextTests.java @@ -109,19 +109,19 @@ 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 diff --git a/spring-core/src/test/java/org/springframework/core/ResolvableTypeTests.java b/spring-core/src/test/java/org/springframework/core/ResolvableTypeTests.java index c49613f7fce..8b67d70d783 100644 --- a/spring-core/src/test/java/org/springframework/core/ResolvableTypeTests.java +++ b/spring-core/src/test/java/org/springframework/core/ResolvableTypeTests.java @@ -1256,7 +1256,7 @@ 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()).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()); } diff --git a/spring-core/src/test/java/org/springframework/core/annotation/AnnotationAttributesTests.java b/spring-core/src/test/java/org/springframework/core/annotation/AnnotationAttributesTests.java index 454653896dd..3019dfe8e0b 100644 --- a/spring-core/src/test/java/org/springframework/core/annotation/AnnotationAttributesTests.java +++ b/spring-core/src/test/java/org/springframework/core/annotation/AnnotationAttributesTests.java @@ -63,7 +63,7 @@ class AnnotationAttributesTests { assertThat(attributes.getBoolean("bool1")).isTrue(); assertThat(attributes.getBoolean("bool2")).isFalse(); assertThat(attributes.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.getNumber("number")).isEqualTo(42); assertThat(attributes.getAnnotation("anno").getNumber("value")).isEqualTo(10); diff --git a/spring-core/src/test/java/org/springframework/core/type/AnnotationMetadataTests.java b/spring-core/src/test/java/org/springframework/core/type/AnnotationMetadataTests.java index 12292de312b..878734aaeac 100644 --- a/spring-core/src/test/java/org/springframework/core/type/AnnotationMetadataTests.java +++ b/spring-core/src/test/java/org/springframework/core/type/AnnotationMetadataTests.java @@ -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}); diff --git a/spring-core/src/test/java/org/springframework/util/CompositeSetTests.java b/spring-core/src/test/java/org/springframework/util/CompositeSetTests.java index 5210756a255..dfd4124834d 100644 --- a/spring-core/src/test/java/org/springframework/util/CompositeSetTests.java +++ b/spring-core/src/test/java/org/springframework/util/CompositeSetTests.java @@ -38,7 +38,7 @@ class CompositeSetTests { Set all = new HashSet<>(first); all.addAll(second); - assertThat(composite.equals(all)).isTrue(); + assertThat(composite).isEqualTo(all); assertThat(composite).isNotEqualTo(first); assertThat(composite).isNotEqualTo(second); assertThat(composite).isNotEqualTo(Collections.emptySet()); diff --git a/spring-core/src/test/java/org/springframework/util/FilteredSetTests.java b/spring-core/src/test/java/org/springframework/util/FilteredSetTests.java index b760d1cd10a..8490420c5a8 100644 --- a/spring-core/src/test/java/org/springframework/util/FilteredSetTests.java +++ b/spring-core/src/test/java/org/springframework/util/FilteredSetTests.java @@ -35,7 +35,7 @@ class FilteredSetTests { Set expected = Set.of("foo", "baz"); - assertThat(filtered.equals(expected)).isTrue(); + assertThat(filtered).isEqualTo(expected); assertThat(filtered).isNotEqualTo(set); assertThat(filtered).isNotEqualTo(Collections.emptySet()); } diff --git a/spring-core/src/test/java/org/springframework/util/StringUtilsTests.java b/spring-core/src/test/java/org/springframework/util/StringUtilsTests.java index 0d9376bf74f..39b1798b655 100644 --- a/spring-core/src/test/java/org/springframework/util/StringUtilsTests.java +++ b/spring-core/src/test/java/org/springframework/util/StringUtilsTests.java @@ -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); } diff --git a/spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java b/spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java index 7371be1aa5a..920333a2ec6 100644 --- a/spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java +++ b/spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java @@ -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"); diff --git a/spring-web/src/test/java/org/springframework/http/HttpEntityTests.java b/spring-web/src/test/java/org/springframework/http/HttpEntityTests.java index 47fb15c1b1d..a4dd0f9a723 100644 --- a/spring-web/src/test/java/org/springframework/http/HttpEntityTests.java +++ b/spring-web/src/test/java/org/springframework/http/HttpEntityTests.java @@ -71,18 +71,18 @@ class HttpEntityTests { HttpHeaders headers2 = new HttpHeaders(); headers2.set("Content-Type", "application/json"); - assertThat(new HttpEntity<>().equals(new HttpEntity<>())).isTrue(); + assertThat(new HttpEntity<>()).isEqualTo(new HttpEntity<>()); assertThat(new HttpEntity<>(headers1)).isNotEqualTo(new HttpEntity<>()); assertThat(new HttpEntity<>()).isNotEqualTo(new HttpEntity<>(headers2)); - assertThat(new HttpEntity<>(headers1).equals(new HttpEntity<>(headers1))).isTrue(); + assertThat(new HttpEntity<>(headers1)).isEqualTo(new HttpEntity<>(headers1)); assertThat(new HttpEntity<>(headers1)).isNotEqualTo(new HttpEntity<>(headers2)); assertThat(new HttpEntity(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(null, (HttpHeaders) null)).isNotEqualTo(new HttpEntity<>("bar", (HttpHeaders) null)); - assertThat(new HttpEntity<>("foo", headers1).equals(new HttpEntity<>("foo", headers1))).isTrue(); + assertThat(new HttpEntity<>("foo", headers1)).isEqualTo(new HttpEntity<>("foo", headers1)); assertThat(new HttpEntity<>("foo", headers1)).isNotEqualTo(new HttpEntity<>("bar", headers1)); } diff --git a/spring-web/src/test/java/org/springframework/web/bind/ServletRequestDataBinderTests.java b/spring-web/src/test/java/org/springframework/web/bind/ServletRequestDataBinderTests.java index 085a28e3acb..3bcc26bbf3f 100644 --- a/spring-web/src/test/java/org/springframework/web/bind/ServletRequestDataBinderTests.java +++ b/spring-web/src/test/java/org/springframework/web/bind/ServletRequestDataBinderTests.java @@ -250,7 +250,7 @@ class ServletRequestDataBinderTests { Object val = m.get(element.getName()); assertThat(val).as("Can't have unexpected value").isNotNull(); assertThat(val).as("Val i string").isInstanceOf(String.class); - assertThat(val.equals(element.getValue())).as("val matches expected").isTrue(); + assertThat(val).as("val matches expected").isEqualTo(element.getValue()); m.remove(element.getName()); } assertThat(m.size()).as("Map size is 0").isEqualTo(0); diff --git a/spring-web/src/test/java/org/springframework/web/bind/ServletRequestUtilsTests.java b/spring-web/src/test/java/org/springframework/web/bind/ServletRequestUtilsTests.java index 5f77833308e..49a763496bf 100644 --- a/spring-web/src/test/java/org/springframework/web/bind/ServletRequestUtilsTests.java +++ b/spring-web/src/test/java/org/springframework/web/bind/ServletRequestUtilsTests.java @@ -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(); diff --git a/spring-web/src/test/java/org/springframework/web/bind/support/WebRequestDataBinderTests.java b/spring-web/src/test/java/org/springframework/web/bind/support/WebRequestDataBinderTests.java index b9d458a8077..13eab71b896 100644 --- a/spring-web/src/test/java/org/springframework/web/bind/support/WebRequestDataBinderTests.java +++ b/spring-web/src/test/java/org/springframework/web/bind/support/WebRequestDataBinderTests.java @@ -333,7 +333,7 @@ class WebRequestDataBinderTests { Object val = m.get(pv.getName()); assertThat(val).as("Can't have unexpected value").isNotNull(); assertThat(val).as("Val i string").isInstanceOf(String.class); - assertThat(val.equals(pv.getValue())).as("val matches expected").isTrue(); + assertThat(val).as("val matches expected").isEqualTo(pv.getValue()); m.remove(pv.getName()); } assertThat(m.size()).as("Map size is 0").isEqualTo(0); diff --git a/spring-webmvc/src/test/java/org/springframework/web/servlet/DispatcherServletTests.java b/spring-webmvc/src/test/java/org/springframework/web/servlet/DispatcherServletTests.java index efa9d904218..26b6cceb973 100644 --- a/spring-webmvc/src/test/java/org/springframework/web/servlet/DispatcherServletTests.java +++ b/spring-webmvc/src/test/java/org/springframework/web/servlet/DispatcherServletTests.java @@ -206,7 +206,7 @@ class DispatcherServletTests { MockHttpServletResponse response = new MockHttpServletResponse(); complexDispatcherServlet.service(request, response); assertThat(response.getForwardedUrl()).as("forwarded URL").isEqualTo("failed0.jsp"); - assertThat(request.getAttribute("exception").getClass().equals(ServletException.class)).as("Exception exposed").isTrue(); + assertThat(request.getAttribute("exception").getClass()).as("Exception exposed").isEqualTo(ServletException.class); } @Test @@ -368,7 +368,7 @@ class DispatcherServletTests { complexDispatcherServlet.service(request, response); assertThat(response.getStatus()).isEqualTo(200); assertThat(response.getForwardedUrl()).as("forwarded URL").isEqualTo("failed0.jsp"); - assertThat(request.getAttribute("exception").getClass().equals(RuntimeException.class)).as("Exception exposed").isTrue(); + assertThat(request.getAttribute("exception").getClass()).as("Exception exposed").isEqualTo(RuntimeException.class); } @Test @@ -381,7 +381,7 @@ class DispatcherServletTests { complexDispatcherServlet.service(request, response); assertThat(response.getStatus()).isEqualTo(200); assertThat(response.getForwardedUrl()).as("forwarded URL").isEqualTo("failed0.jsp"); - assertThat(request.getAttribute("exception").getClass().equals(ServletException.class)).as("Exception exposed").isTrue(); + assertThat(request.getAttribute("exception").getClass()).as("Exception exposed").isEqualTo(ServletException.class); } @Test diff --git a/spring-webmvc/src/test/java/org/springframework/web/servlet/tags/form/SelectTagTests.java b/spring-webmvc/src/test/java/org/springframework/web/servlet/tags/form/SelectTagTests.java index 0a6a9c00203..0ac9f69350c 100644 --- a/spring-webmvc/src/test/java/org/springframework/web/servlet/tags/form/SelectTagTests.java +++ b/spring-webmvc/src/test/java/org/springframework/web/servlet/tags/form/SelectTagTests.java @@ -1126,7 +1126,7 @@ class SelectTagTests extends AbstractFormTagTests { Element e = (Element) rootElement.selectSingleNode("option[@value = 'UK']"); Attribute selectedAttr = e.attribute("selected"); if (selected) { - assertThat(selectedAttr != null && "selected".equals(selectedAttr.getValue())).isTrue(); + assertThat(selectedAttr.getValue()).isEqualTo("selected"); } else { assertThat(selectedAttr).isNull(); diff --git a/spring-webmvc/src/test/java/org/springframework/web/servlet/view/BaseViewTests.java b/spring-webmvc/src/test/java/org/springframework/web/servlet/view/BaseViewTests.java index 7768fd1a496..8d273ead3c2 100644 --- a/spring-webmvc/src/test/java/org/springframework/web/servlet/view/BaseViewTests.java +++ b/spring-webmvc/src/test/java/org/springframework/web/servlet/view/BaseViewTests.java @@ -217,8 +217,8 @@ class BaseViewTests { AbstractView v = new ConcreteView(); v.setAttributesCSV("foo=[bar],king=[kong]"); assertThat(v.getStaticAttributes()).hasSize(2); - assertThat(v.getStaticAttributes().get("foo").equals("bar")).isTrue(); - assertThat(v.getStaticAttributes().get("king").equals("kong")).isTrue(); + assertThat(v.getStaticAttributes().get("foo")).isEqualTo("bar"); + assertThat(v.getStaticAttributes().get("king")).isEqualTo("kong"); } @Test diff --git a/spring-webmvc/src/test/java/org/springframework/web/servlet/view/RedirectViewTests.java b/spring-webmvc/src/test/java/org/springframework/web/servlet/view/RedirectViewTests.java index f76bf5c9985..3904f010281 100644 --- a/spring-webmvc/src/test/java/org/springframework/web/servlet/view/RedirectViewTests.java +++ b/spring-webmvc/src/test/java/org/springframework/web/servlet/view/RedirectViewTests.java @@ -364,7 +364,7 @@ class RedirectViewTests { */ @Override protected Map queryProperties(Map model) { - assertThat(this.expectedModel.equals(model)).as("Map and model must be equal.").isTrue(); + assertThat(this.expectedModel).as("Map and model must be equal.").isEqualTo(model); this.queryPropertiesCalled = true; return super.queryProperties(model); } diff --git a/spring-webmvc/src/test/java/org/springframework/web/servlet/view/ViewResolverTests.java b/spring-webmvc/src/test/java/org/springframework/web/servlet/view/ViewResolverTests.java index 110eb933780..b6153896bf0 100644 --- a/spring-webmvc/src/test/java/org/springframework/web/servlet/view/ViewResolverTests.java +++ b/spring-webmvc/src/test/java/org/springframework/web/servlet/view/ViewResolverTests.java @@ -175,7 +175,7 @@ class ViewResolverTests { TestBean tb = new TestBean(); model.put("tb", tb); view.render(model, this.request, this.response); - assertThat(tb.equals(this.request.getAttribute("tb"))).as("Correct tb attribute").isTrue(); + assertThat(tb).as("Correct tb attribute").isEqualTo(this.request.getAttribute("tb")); assertThat(this.request.getAttribute("rc")).as("Correct rc attribute").isInstanceOf(RequestContext.class); view = vr.resolveViewName("redirect:myUrl", Locale.getDefault()); @@ -244,7 +244,7 @@ class ViewResolverTests { model.put("tb", tb); view.render(model, this.request, this.response); - assertThat(tb.equals(this.request.getAttribute("tb"))).as("Correct tb attribute").isTrue(); + assertThat(tb).as("Correct tb attribute").isEqualTo(this.request.getAttribute("tb")); assertThat(this.request.getAttribute("rc")).as("Correct rc attribute").isNull(); assertThat(this.request.getAttribute("key1")).isEqualTo("value1"); assertThat(this.request.getAttribute("key2")).isEqualTo(2); @@ -347,7 +347,7 @@ class ViewResolverTests { model.put("tb", tb); view.render(model, this.request, this.response); - assertThat(tb.equals(this.request.getAttribute("tb"))).as("Correct tb attribute").isTrue(); + assertThat(tb).as("Correct tb attribute").isEqualTo(this.request.getAttribute("tb")); assertThat(this.request.getAttribute("rc")).as("Correct rc attribute").isNull(); assertThat(Config.get(this.request, Config.FMT_LOCALE)).isEqualTo(locale); @@ -381,7 +381,7 @@ class ViewResolverTests { model.put("tb", tb); view.render(model, this.request, this.response); - assertThat(tb.equals(this.request.getAttribute("tb"))).as("Correct tb attribute").isTrue(); + assertThat(tb).as("Correct tb attribute").isEqualTo(this.request.getAttribute("tb")); assertThat(this.request.getAttribute("rc")).as("Correct rc attribute").isNull(); assertThat(Config.get(this.request, Config.FMT_LOCALE)).isEqualTo(locale);