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

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());

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();
 	}
 

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);

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);

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(0)).isEqualTo(this.beanFactory.getBean("david"));
-		assertThat(l.get(1).equals("literal")).isTrue();
+		assertThat(l.get(1)).isEqualTo("literal");
-		assertThat(l.get(2).equals(this.beanFactory.getBean("jenny"))).isTrue();
+		assertThat(l.get(2)).isEqualTo(this.beanFactory.getBean("jenny"));
-		assertThat(l.get(3).equals("rod")).isTrue();
+		assertThat(l.get(3)).isEqualTo("rod");
 		Object[] array = (Object[]) l.get(4);
-		assertThat(array[0].equals(this.beanFactory.getBean("david"))).isTrue();
+		assertThat(array[0]).isEqualTo(this.beanFactory.getBean("david"));
-		assertThat(array[1].equals("literal2")).isTrue();
+		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("foo")).isEqualTo("bar");
-		assertThat(hasMap.getMap().get("fi").equals("fum")).isTrue();
+		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("fo")).isEqualTo("bar");
-		assertThat(m.get("jen").equals(jenny)).as("Map element 'jenny' should be equal to jenny bean, not " + m.get("jen")).isTrue();
+		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("foo")).isEqualTo("bar");
-		assertThat(m.get("jenny").equals(jenny)).as("Map element 'jenny' should be equal to jenny bean, not " + m.get("jenny")).isTrue();
+		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("foo")).isEqualTo("bar");
-		assertThat(hasMap.getProps().get("2").equals("TWO")).isTrue();
+		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()[0]).isEqualTo("one");
-		assertThat(hasMap.getObjectArray()[1].equals(this.beanFactory.getBean("jenny"))).isTrue();
+		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()[0]).isEqualTo(String.class);
-		assertThat(hasMap.getClassArray()[1].equals(Exception.class)).isTrue();
+		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(0)).isEqualTo(String.class);
-		assertThat(hasMap.getClassList().get(1).equals(Exception.class)).isTrue();
+		assertThat(hasMap.getClassList().get(1)).isEqualTo(Exception.class);
 	}
 
 	@Test

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")).as("Correct long2 value").isEqualTo(bw.getPropertyValue("long2"));
-		assertThat(Long.valueOf("6").equals(tb.getLong2())).as("Correct long2 value").isTrue();
+		assertThat(Long.valueOf("6")).as("Correct long2 value").isEqualTo(tb.getLong2());
 
 		bw.setPropertyValue("long2", "");
 		assertThat(bw.getPropertyValue("long2")).as("Correct long2 value").isNull();

spring-beans/src/test/java/org/springframework/beans/propertyeditors/PropertiesEditorTests.java

@@ -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("foo")).as("foo=bar with whitespace").isEqualTo("bar with whitespace");
-		assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
+		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("foo")).as("foo=bar").isEqualTo("bar");
-		assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
+		assertThat(p.get("me")).as("me=mi").isEqualTo("mi");
-		assertThat(p.get("x").equals("y=z")).as("x='y=z'").isTrue();
+		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("foo")).as("foo=bar").isEqualTo("bar");
-		assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
+		assertThat(p.get("me")).as("me=mi").isEqualTo("mi");
-		assertThat(p.get("x").equals("")).as("x='y=z'").isTrue();
+		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("foo")).as("foo is empty").isEqualTo("");
-		assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
+		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("foo")).as("foo is bar").isEqualTo("bar");
-		assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
+		assertThat(p.get("me")).as("me=mi").isEqualTo("mi");
 	}
 
 	/**

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);

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).as("They are object equal").isEqualTo(georgiasJenks);
-		assertThat(emmasJenks.equals(xbf.getBean("jenks"))).as("They object equal direct ref").isTrue();
+		assertThat(emmasJenks).as("They object equal direct ref").isEqualTo(xbf.getBean("jenks"));
 	}
 
 	@Test

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

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

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

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());
 	}

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.<Color>getEnum("color")).isEqualTo(Color.RED);
-		assertThat(attributes.getClass("class").equals(Integer.class)).isTrue();
+		assertThat(attributes.getClass("class")).isEqualTo(Integer.class);
 		assertThat(attributes.getClassArray("classes")).isEqualTo(new Class<?>[] {Number.class, Short.class, Integer.class});
 		assertThat(attributes.<Integer>getNumber("number")).isEqualTo(42);
 		assertThat(attributes.getAnnotation("anno").<Integer>getNumber("value")).isEqualTo(10);

spring-core/src/test/java/org/springframework/core/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});
 

spring-core/src/test/java/org/springframework/util/CompositeSetTests.java

@@ -38,7 +38,7 @@ class CompositeSetTests {
 		Set<String> 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());

spring-core/src/test/java/org/springframework/util/FilteredSetTests.java

@@ -35,7 +35,7 @@ class FilteredSetTests {
 
 		Set<String> expected = Set.of("foo", "baz");
 
-		assertThat(filtered.equals(expected)).isTrue();
+		assertThat(filtered).isEqualTo(expected);
 		assertThat(filtered).isNotEqualTo(set);
 		assertThat(filtered).isNotEqualTo(Collections.emptySet());
 	}

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", ",");
+		String[] array = StringUtils.tokenizeToStringArray("a,b , ,c", ",");
-		assertThat(sa).hasSize(3);
+		assertThat(array).containsExactly("a", "b", "c");
-		assertThat(sa[0].equals("a") && sa[1].equals("b") && sa[2].equals("c")).as("components are correct").isTrue();
 	}
 
 	@Test
 	void tokenizeToStringArrayWithNotIgnoreEmptyTokens() {
-		String[] sa = StringUtils.tokenizeToStringArray("a,b , ,c", ",", true, false);
+		String[] array = StringUtils.tokenizeToStringArray("a,b , ,c", ",", true, false);
-		assertThat(sa).hasSize(4);
+		assertThat(array).containsExactly("a", "b", "", "c");
-		assertThat(sa[0].equals("a") && sa[1].equals("b") && sa[2].isEmpty() && sa[3].equals("c")).as("components are correct").isTrue();
 	}
 
 	@Test
 	void tokenizeToStringArrayWithNotTrimTokens() {
-		String[] sa = StringUtils.tokenizeToStringArray("a,b ,c", ",", false, true);
+		String[] array = StringUtils.tokenizeToStringArray("a,b ,c", ",", false, true);
-		assertThat(sa).hasSize(3);
+		assertThat(array).containsExactly("a", "b ", "c");
-		assertThat(sa[0].equals("a") && sa[1].equals("b ") && sa[2].equals("c")).as("components are correct").isTrue();
 	}
 
 	@Test
 	void commaDelimitedListToStringArrayWithNullProducesEmptyArray() {
-		String[] sa = StringUtils.commaDelimitedListToStringArray(null);
+		String[] array = StringUtils.commaDelimitedListToStringArray(null);
-		assertThat(sa).as("String array isn't null with null input").isNotNull();
+		assertThat(array).isEmpty();
-		assertThat(sa.length).as("String array length == 0 with null input").isEqualTo(0);
 	}
 
 	@Test
 	void commaDelimitedListToStringArrayWithEmptyStringProducesEmptyArray() {
-		String[] sa = StringUtils.commaDelimitedListToStringArray("");
+		String[] array = StringUtils.commaDelimitedListToStringArray("");
-		assertThat(sa).as("String array isn't null with null input").isNotNull();
+		assertThat(array).isEmpty();
-		assertThat(sa.length).as("String array length == 0 with null input").isEqualTo(0);
 	}
 
 	@Test
 	void delimitedListToStringArrayWithComma() {
-		String[] sa = StringUtils.delimitedListToStringArray("a,b", ",");
+		String[] array = StringUtils.delimitedListToStringArray("a,b", ",");
-		assertThat(sa).hasSize(2);
+		assertThat(array).containsExactly("a", "b");
-		assertThat(sa[0]).isEqualTo("a");
-		assertThat(sa[1]).isEqualTo("b");
 	}
 
 	@Test
 	void delimitedListToStringArrayWithSemicolon() {
-		String[] sa = StringUtils.delimitedListToStringArray("a;b", ";");
+		String[] array = StringUtils.delimitedListToStringArray("a;b", ";");
-		assertThat(sa).hasSize(2);
+		assertThat(array).containsExactly("a", "b");
-		assertThat(sa[0]).isEqualTo("a");
-		assertThat(sa[1]).isEqualTo("b");
 	}
 
 	@Test
 	void delimitedListToStringArrayWithEmptyDelimiter() {
-		String[] sa = StringUtils.delimitedListToStringArray("a,b", "");
+		String[] array = StringUtils.delimitedListToStringArray("a,b", "");
-		assertThat(sa).hasSize(3);
+		assertThat(array).containsExactly("a", ",", "b");
-		assertThat(sa[0]).isEqualTo("a");
-		assertThat(sa[1]).isEqualTo(",");
-		assertThat(sa[2]).isEqualTo("b");
 	}
 
 	@Test
 	void delimitedListToStringArrayWithNullDelimiter() {
-		String[] sa = StringUtils.delimitedListToStringArray("a,b", null);
+		String[] array = StringUtils.delimitedListToStringArray("a,b", null);
-		assertThat(sa).hasSize(1);
+		assertThat(array).containsExactly("a,b");
-		assertThat(sa[0]).isEqualTo("a,b");
 	}
 
 	@Test
 	void delimitedListToStringArrayWithCharacterToDelete() {
-		String[] sa = StringUtils.delimitedListToStringArray("a,b,c", ",", "a");
+		String[] array = StringUtils.delimitedListToStringArray("a,b,c", ",", "a");
-		assertThat(sa).containsExactly("", "b", "c");
+		assertThat(array).containsExactly("", "b", "c");
 	}
 
 	@Test
 	void delimitedListToStringArrayWithCharacterToDeleteEqualsToDelimiter() {
-		String[] sa = StringUtils.delimitedListToStringArray("a,b,c", ",", ",");
+		String[] array = StringUtils.delimitedListToStringArray("a,b,c", ",", ",");
-		assertThat(sa).containsExactly("a", "b", "c");
+		assertThat(array).containsExactly("a", "b", "c");
 	}
 
 	@Test
 	void commaDelimitedListToStringArrayMatchWords() {
 		// Could read these from files
-		String[] sa = new String[] {"foo", "bar", "big"};
+		String[] array = new String[] {"foo", "bar", "big"};
-		doTestCommaDelimitedListToStringArrayLegalMatch(sa);
+		doTestCommaDelimitedListToStringArrayLegalMatch(array);
-		doTestStringArrayReverseTransformationMatches(sa);
+		doTestStringArrayReverseTransformationMatches(array);
 
-		sa = new String[] {"a", "b", "c"};
+		array = new String[] {"a", "b", "c"};
-		doTestCommaDelimitedListToStringArrayLegalMatch(sa);
+		doTestCommaDelimitedListToStringArrayLegalMatch(array);
-		doTestStringArrayReverseTransformationMatches(sa);
+		doTestStringArrayReverseTransformationMatches(array);
 
 		// Test same words
-		sa = new String[] {"AA", "AA", "AA", "AA", "AA"};
+		array = new String[] {"AA", "AA", "AA", "AA", "AA"};
-		doTestCommaDelimitedListToStringArrayLegalMatch(sa);
+		doTestCommaDelimitedListToStringArrayLegalMatch(array);
-		doTestStringArrayReverseTransformationMatches(sa);
+		doTestStringArrayReverseTransformationMatches(array);
 	}
 
-	private void doTestStringArrayReverseTransformationMatches(String[] sa) {
+	private void doTestStringArrayReverseTransformationMatches(String[] array) {
 		String[] reverse =
-				StringUtils.commaDelimitedListToStringArray(StringUtils.arrayToCommaDelimitedString(sa));
+				StringUtils.commaDelimitedListToStringArray(StringUtils.arrayToCommaDelimitedString(array));
-		assertThat(Arrays.asList(reverse)).as("Reverse transformation is equal").isEqualTo(Arrays.asList(sa));
+		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);
+		String[] array = StringUtils.commaDelimitedListToStringArray(s);
-		assertThat(sa.length).as("Found one String with no delimiters").isEqualTo(1);
+		assertThat(array).as("Single array entry matches input String with no delimiters").containsExactly(s);
-		assertThat(sa[0]).as("Single array entry matches input String with no delimiters").isEqualTo(s);
 	}
 
 	@Test
 	void commaDelimitedListToStringArrayWithOtherPunctuation() {
 		// Could read these from files
-		String[] sa = new String[] {"xcvwert4456346&*.", "///", ".!", ".", ";"};
+		String[] array = new String[] {"xcvwert4456346&*.", "///", ".!", ".", ";"};
-		doTestCommaDelimitedListToStringArrayLegalMatch(sa);
+		doTestCommaDelimitedListToStringArrayLegalMatch(array);
 	}
 
 	/**
@@ -637,20 +622,17 @@ class StringUtilsTests {
 	@Test
 	void commaDelimitedListToStringArrayEmptyStrings() {
 		// Could read these from files
-		String[] sa = StringUtils.commaDelimitedListToStringArray("a,,b");
+		String[] array = StringUtils.commaDelimitedListToStringArray("a,,b");
-		assertThat(sa.length).as("a,,b produces array length 3").isEqualTo(3);
+		assertThat(array).containsExactly("a", "", "b");
-		assertThat(sa[0].equals("a") && sa[1].isEmpty() && sa[2].equals("b")).as("components are correct").isTrue();
 
-		sa = new String[] {"", "", "a", ""};
+		array = new String[] {"", "", "a", ""};
-		doTestCommaDelimitedListToStringArrayLegalMatch(sa);
+		doTestCommaDelimitedListToStringArrayLegalMatch(array);
 	}
 
 	private void doTestCommaDelimitedListToStringArrayLegalMatch(String[] components) {
 		String sb = String.join(String.valueOf(','), components);
-		String[] sa = StringUtils.commaDelimitedListToStringArray(sb);
+		String[] array = StringUtils.commaDelimitedListToStringArray(sb);
-		assertThat(sa).as("String array isn't null with legal match").isNotNull();
+		assertThat(array).as("Output equals input").isEqualTo(components);
-		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();
 	}
 
 

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");

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<String>(null, (HttpHeaders) null).equals(new HttpEntity<>(null, (HttpHeaders) null))).isTrue();
 		assertThat(new HttpEntity<>("foo", (HttpHeaders) null)).isNotEqualTo(new HttpEntity<>(null, (HttpHeaders) null));
 		assertThat(new HttpEntity<String>(null, (HttpHeaders) null)).isNotEqualTo(new HttpEntity<>("bar", (HttpHeaders) null));
 
-		assertThat(new HttpEntity<>("foo", 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));
 	}
 

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);

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();
 

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);

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

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();

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("foo")).isEqualTo("bar");
-		assertThat(v.getStaticAttributes().get("king").equals("kong")).isTrue();
+		assertThat(v.getStaticAttributes().get("king")).isEqualTo("kong");
 	}
 
 	@Test

spring-webmvc/src/test/java/org/springframework/web/servlet/view/RedirectViewTests.java

@@ -364,7 +364,7 @@ class RedirectViewTests {
 		 */
 		@Override
 		protected Map<String, Object> queryProperties(Map<String, Object> 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);
 		}

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);