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

Convert assertThat(x.equals(y)).isTrue() to assertThat(x).isEqualTo(y)

Browse Source 
Search:

  assertThat\((?!\s*Arrays\.)((?:[^()]+|\([^()]*\))+)\.equals\(\s*((?:[^()]+|\([^()]*\))+)\s*\)\)(.*)\.isTrue\(\)

Replace:

  assertThat($1)$3.isEqualTo($2)

See gh-36504
This commit is contained in:
Sam Brannen
2026-03-19 17:06:37 +01:00
parent 2ce21f7654
commit 87c4acd7ac
28 changed files with 149 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files
spring-beans/src/test/java/org/springframework/beans/AbstractPropertyAccessorTests.java
+4 -4
View File
@@ -599,11 +599,11 @@ abstract class AbstractPropertyAccessorTests {
AbstractPropertyAccessor accessor = createAccessor(target);
accessor.setPropertyValue("bool2", "true");
assertThat(Boolean.TRUE.equals(accessor.getPropertyValue("bool2"))).as("Correct bool2 value").isTrue();
assertThat(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
+2 -2
View File
@@ -516,11 +516,11 @@ class DefaultListableBeanFactoryTests {
String[] names = lbf.getBeanDefinitionNames();
assertThat(names != lbf.getBeanDefinitionNames()).isTrue();
assertThat(names.length == 1).as("Array length == 1").isTrue();
assertThat(names[0].equals("test")).as("0th element == test").isTrue();
assertThat(names[0]).as("0th element == test").isEqualTo("test");
TestBean tb = (TestBean) lbf.getBean("test");
assertThat(tb != null).as("Test is non null").isTrue();
assertThat("Tony".equals(tb.getName())).as("Test bean name is Tony").isTrue();
assertThat("Tony").as("Test bean name is Tony").isEqualTo(tb.getName());
assertThat(tb.getAge() == 48).as("Test bean age is 48").isTrue();
}
spring-beans/src/test/java/org/springframework/beans/factory/config/MethodInvokingFactoryBeanTests.java
+1 -1
View File
@@ -98,7 +98,7 @@ class MethodInvokingFactoryBeanTests {
mcfb.setTargetObject(tc1);
mcfb.setTargetMethod("method1");
mcfb.afterPropertiesSet();
assertThat(int.class.equals(mcfb.getObjectType())).isTrue();
assertThat(int.class).isEqualTo(mcfb.getObjectType());
mcfb = new MethodInvokingFactoryBean();
mcfb.setTargetClass(TestClass1.class);
spring-beans/src/test/java/org/springframework/beans/factory/xml/CollectionsWithDefaultTypesTests.java
+1 -1
View File
@@ -83,7 +83,7 @@ class CollectionsWithDefaultTypesTests {
MixedCollectionBean jumble = (MixedCollectionBean) this.beanFactory.getBean("jumble");
assertThat(jumble.getJumble()).as("Expected 3 elements, not " + jumble.getJumble().size()).hasSize(3);
List l = (List) jumble.getJumble();
assertThat(l.get(0).equals("literal")).isTrue();
assertThat(l.get(0)).isEqualTo("literal");
Integer[] array1 = (Integer[]) l.get(1);
assertThat(array1[0]).isEqualTo(2);
assertThat(array1[1]).isEqualTo(4);
spring-beans/src/test/java/org/springframework/beans/factory/xml/XmlBeanCollectionTests.java
+26 -26
View File
@@ -162,13 +162,13 @@ class XmlBeanCollectionTests {
MixedCollectionBean jumble = (MixedCollectionBean) this.beanFactory.getBean("jumble");
assertThat(jumble.getJumble()).as("Expected 5 elements, not " + jumble.getJumble()).hasSize(5);
List l = (List) jumble.getJumble();
assertThat(l.get(0).equals(this.beanFactory.getBean("david"))).isTrue();
assertThat(l.get(1).equals("literal")).isTrue();
assertThat(l.get(2).equals(this.beanFactory.getBean("jenny"))).isTrue();
assertThat(l.get(3).equals("rod")).isTrue();
assertThat(l.get(0)).isEqualTo(this.beanFactory.getBean("david"));
assertThat(l.get(1)).isEqualTo("literal");
assertThat(l.get(2)).isEqualTo(this.beanFactory.getBean("jenny"));
assertThat(l.get(3)).isEqualTo("rod");
Object[] array = (Object[]) l.get(4);
assertThat(array[0].equals(this.beanFactory.getBean("david"))).isTrue();
assertThat(array[1].equals("literal2")).isTrue();
assertThat(array[0]).isEqualTo(this.beanFactory.getBean("david"));
assertThat(array[1]).isEqualTo("literal2");
}
@Test
@@ -189,8 +189,8 @@ class XmlBeanCollectionTests {
void mapWithLiteralsOnly() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("literalMap");
assertThat(hasMap.getMap()).hasSize(3);
assertThat(hasMap.getMap().get("foo").equals("bar")).isTrue();
assertThat(hasMap.getMap().get("fi").equals("fum")).isTrue();
assertThat(hasMap.getMap().get("foo")).isEqualTo("bar");
assertThat(hasMap.getMap().get("fi")).isEqualTo("fum");
assertThat(hasMap.getMap().get("fa")).isNull();
}
@@ -201,7 +201,7 @@ class XmlBeanCollectionTests {
assertThat(hasMap.getMap().get("foo")).isEqualTo(10);
TestBean jenny = (TestBean) this.beanFactory.getBean("jenny");
assertThat(hasMap.getMap().get("jenny")).isSameAs(jenny);
assertThat(hasMap.getMap().get(5).equals("david")).isTrue();
assertThat(hasMap.getMap().get(5)).isEqualTo("david");
assertThat(hasMap.getMap().get("bar")).isInstanceOf(Long.class);
assertThat(hasMap.getMap().get("bar")).isEqualTo(100L);
assertThat(hasMap.getMap().get("baz")).isInstanceOf(Integer.class);
@@ -213,13 +213,13 @@ class XmlBeanCollectionTests {
TestBean jenny = (TestBean) this.beanFactory.getBean("pJenny");
HasMap hasMap = (HasMap) this.beanFactory.getBean("pMixedMap");
assertThat(hasMap.getMap()).hasSize(2);
assertThat(hasMap.getMap().get("foo").equals("bar")).isTrue();
assertThat(hasMap.getMap().get("foo")).isEqualTo("bar");
assertThat(hasMap.getMap().get("jenny").toString()).isEqualTo(jenny.toString());
assertThat(hasMap.getMap().get("jenny")).as("Not same instance").isNotSameAs(jenny);
HasMap hasMap2 = (HasMap) this.beanFactory.getBean("pMixedMap");
assertThat(hasMap2.getMap()).hasSize(2);
assertThat(hasMap2.getMap().get("foo").equals("bar")).isTrue();
assertThat(hasMap2.getMap().get("foo")).isEqualTo("bar");
assertThat(hasMap2.getMap().get("jenny").toString()).isEqualTo(jenny.toString());
assertThat(hasMap2.getMap().get("jenny")).as("Not same instance").isNotSameAs(hasMap.getMap().get("jenny"));
}
@@ -228,7 +228,7 @@ class XmlBeanCollectionTests {
void mapWithLiteralsReferencesAndList() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("mixedMapWithList");
assertThat(hasMap.getMap()).hasSize(4);
assertThat(hasMap.getMap().get(null).equals("bar")).isTrue();
assertThat(hasMap.getMap().get(null)).isEqualTo("bar");
TestBean jenny = (TestBean) this.beanFactory.getBean("jenny");
assertThat(hasMap.getMap().get("jenny")).isEqualTo(jenny);
@@ -236,29 +236,29 @@ class XmlBeanCollectionTests {
List l = (List) hasMap.getMap().get("list");
assertThat(l).isNotNull();
assertThat(l).hasSize(4);
assertThat(l.get(0).equals("zero")).isTrue();
assertThat(l.get(0)).isEqualTo("zero");
assertThat(l).element(3).isNull();
// Check nested map in list
Map m = (Map) l.get(1);
assertThat(m).isNotNull();
assertThat(m).hasSize(2);
assertThat(m.get("fo").equals("bar")).isTrue();
assertThat(m.get("jen").equals(jenny)).as("Map element 'jenny' should be equal to jenny bean, not " + m.get("jen")).isTrue();
assertThat(m.get("fo")).isEqualTo("bar");
assertThat(m.get("jen")).as("Map element 'jenny' should be equal to jenny bean, not " + m.get("jen")).isEqualTo(jenny);
// Check nested list in list
l = (List) l.get(2);
assertThat(l).isNotNull();
assertThat(l).hasSize(2);
assertThat(l.get(0)).isEqualTo(jenny);
assertThat(l.get(1).equals("ba")).isTrue();
assertThat(l.get(1)).isEqualTo("ba");
// Check nested map
m = (Map) hasMap.getMap().get("map");
assertThat(m).isNotNull();
assertThat(m).hasSize(2);
assertThat(m.get("foo").equals("bar")).isTrue();
assertThat(m.get("jenny").equals(jenny)).as("Map element 'jenny' should be equal to jenny bean, not " + m.get("jenny")).isTrue();
assertThat(m.get("foo")).isEqualTo("bar");
assertThat(m.get("jenny")).as("Map element 'jenny' should be equal to jenny bean, not " + m.get("jenny")).isEqualTo(jenny);
}
@Test
@@ -311,16 +311,16 @@ class XmlBeanCollectionTests {
void populatedProps() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("props");
assertThat(hasMap.getProps()).hasSize(2);
assertThat(hasMap.getProps().get("foo").equals("bar")).isTrue();
assertThat(hasMap.getProps().get("2").equals("TWO")).isTrue();
assertThat(hasMap.getProps().get("foo")).isEqualTo("bar");
assertThat(hasMap.getProps().get("2")).isEqualTo("TWO");
}
@Test
void objectArray() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("objectArray");
assertThat(hasMap.getObjectArray().length).isEqualTo(2);
assertThat(hasMap.getObjectArray()[0].equals("one")).isTrue();
assertThat(hasMap.getObjectArray()[1].equals(this.beanFactory.getBean("jenny"))).isTrue();
assertThat(hasMap.getObjectArray()[0]).isEqualTo("one");
assertThat(hasMap.getObjectArray()[1]).isEqualTo(this.beanFactory.getBean("jenny"));
}
@Test
@@ -336,16 +336,16 @@ class XmlBeanCollectionTests {
void classArray() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("classArray");
assertThat(hasMap.getClassArray().length).isEqualTo(2);
assertThat(hasMap.getClassArray()[0].equals(String.class)).isTrue();
assertThat(hasMap.getClassArray()[1].equals(Exception.class)).isTrue();
assertThat(hasMap.getClassArray()[0]).isEqualTo(String.class);
assertThat(hasMap.getClassArray()[1]).isEqualTo(Exception.class);
}
@Test
void classList() {
HasMap hasMap = (HasMap) this.beanFactory.getBean("classList");
assertThat(hasMap.getClassList()).hasSize(2);
assertThat(hasMap.getClassList().get(0).equals(String.class)).isTrue();
assertThat(hasMap.getClassList().get(1).equals(Exception.class)).isTrue();
assertThat(hasMap.getClassList().get(0)).isEqualTo(String.class);
assertThat(hasMap.getClassList().get(1)).isEqualTo(Exception.class);
}
@Test
spring-beans/src/test/java/org/springframework/beans/propertyeditors/CustomEditorTests.java
+9 -9
View File
@@ -187,11 +187,11 @@ class CustomEditorTests {
BeanWrapper bw = new BeanWrapperImpl(tb);
bw.setPropertyValue("bool1", "true");
assertThat(Boolean.TRUE.equals(bw.getPropertyValue("bool1"))).as("Correct bool1 value").isTrue();
assertThat(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();
spring-beans/src/test/java/org/springframework/beans/propertyeditors/PropertiesEditorTests.java
+13 -13
View File
@@ -42,7 +42,7 @@ class PropertiesEditorTests {
pe.setAsText(s);
Properties p = (Properties) pe.getValue();
assertThat(p.entrySet().size()).as("contains one entry").isEqualTo(1);
assertThat(p.get("foo").equals("bar")).as("foo=bar").isTrue();
assertThat(p.get("foo")).as("foo=bar").isEqualTo("bar");
}
@Test
@@ -53,8 +53,8 @@ class PropertiesEditorTests {
pe.setAsText(s);
Properties p = (Properties) pe.getValue();
assertThat(p.entrySet().size()).as("contains two entries").isEqualTo(2);
assertThat(p.get("foo").equals("bar with whitespace")).as("foo=bar with whitespace").isTrue();
assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
assertThat(p.get("foo")).as("foo=bar with whitespace").isEqualTo("bar with whitespace");
assertThat(p.get("me")).as("me=mi").isEqualTo("mi");
}
@Test
@@ -67,9 +67,9 @@ class PropertiesEditorTests {
pe.setAsText(s);
Properties p = (Properties) pe.getValue();
assertThat(p.entrySet().size()).as("contains two entries").isEqualTo(3);
assertThat(p.get("foo").equals("bar")).as("foo=bar").isTrue();
assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
assertThat(p.get("x").equals("y=z")).as("x='y=z'").isTrue();
assertThat(p.get("foo")).as("foo=bar").isEqualTo("bar");
assertThat(p.get("me")).as("me=mi").isEqualTo("mi");
assertThat(p.get("x")).as("x='y=z'").isEqualTo("y=z");
}
@Test
@@ -79,9 +79,9 @@ class PropertiesEditorTests {
pe.setAsText(s);
Properties p = (Properties) pe.getValue();
assertThat(p.entrySet().size()).as("contains two entries").isEqualTo(3);
assertThat(p.get("foo").equals("bar")).as("foo=bar").isTrue();
assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
assertThat(p.get("x").equals("")).as("x='y=z'").isTrue();
assertThat(p.get("foo")).as("foo=bar").isEqualTo("bar");
assertThat(p.get("me")).as("me=mi").isEqualTo("mi");
assertThat(p.get("x")).as("x='y=z'").isEqualTo("");
}
@Test
@@ -91,8 +91,8 @@ class PropertiesEditorTests {
pe.setAsText(s);
Properties p = (Properties) pe.getValue();
assertThat(p.entrySet().size()).as("contains three entries").isEqualTo(3);
assertThat(p.get("foo").equals("")).as("foo is empty").isTrue();
assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
assertThat(p.get("foo")).as("foo is empty").isEqualTo("");
assertThat(p.get("me")).as("me=mi").isEqualTo("mi");
}
/**
@@ -112,8 +112,8 @@ class PropertiesEditorTests {
pe.setAsText(s);
Properties p = (Properties) pe.getValue();
assertThat(p.entrySet().size()).as("contains three entries").isEqualTo(3);
assertThat(p.get("foo").equals("bar")).as("foo is bar").isTrue();
assertThat(p.get("me").equals("mi")).as("me=mi").isTrue();
assertThat(p.get("foo")).as("foo is bar").isEqualTo("bar");
assertThat(p.get("me")).as("me=mi").isEqualTo("mi");
}
/**
spring-beans/src/testFixtures/java/org/springframework/beans/testfixture/factory/xml/AbstractBeanFactoryTests.java
+6 -6
View File
@@ -56,9 +56,9 @@ public abstract class AbstractBeanFactoryTests {
TestBean rod = (TestBean) getBeanFactory().getBean("rod");
TestBean roderick = (TestBean) getBeanFactory().getBean("roderick");
assertThat(rod).as("not == ").isNotSameAs(roderick);
assertThat(rod.getName().equals("Rod")).as("rod.name is Rod").isTrue();
assertThat(rod.getName()).as("rod.name is Rod").isEqualTo("Rod");
assertThat(rod.getAge()).as("rod.age is 31").isEqualTo(31);
assertThat(roderick.getName().equals("Roderick")).as("roderick.name is Roderick").isTrue();
assertThat(roderick.getName()).as("roderick.name is Roderick").isEqualTo("Roderick");
assertThat(roderick.getAge()).as("roderick.age was inherited").isEqualTo(rod.getAge());
}
@@ -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
+2 -2
View File
@@ -152,8 +152,8 @@ class XmlBeanFactoryTests {
assertThat(emmasJenks.getName()).as("Emmas jenks has right name").isEqualTo("Andrew");
assertThat(emmasJenks).as("Emmas doesn't equal new ref").isNotSameAs(xbf.getBean("jenks"));
assertThat(georgiasJenks.getName()).as("Georgias jenks has right name").isEqualTo("Andrew");
assertThat(emmasJenks.equals(georgiasJenks)).as("They are object equal").isTrue();
assertThat(emmasJenks.equals(xbf.getBean("jenks"))).as("They object equal direct ref").isTrue();
assertThat(emmasJenks).as("They are object equal").isEqualTo(georgiasJenks);
assertThat(emmasJenks).as("They object equal direct ref").isEqualTo(xbf.getBean("jenks"));
}
@Test
spring-context/src/test/java/org/springframework/validation/DataBinderFieldAccessTests.java
+1 -1
View File
@@ -58,7 +58,7 @@ class DataBinderFieldAccessTests {
Map<?, ?> m = binder.getBindingResult().getModel();
assertThat(m).as("There is one element in map").hasSize(2);
FieldAccessBean tb = (FieldAccessBean) m.get("person");
assertThat(tb.equals(rod)).as("Same object").isTrue();
assertThat(tb).as("Same object").isEqualTo(rod);
}
@Test
spring-context/src/test/java/org/springframework/validation/DataBinderTests.java
+2 -2
View File
@@ -113,7 +113,7 @@ class DataBinderTests {
Map<?, ?> map = binder.getBindingResult().getModel();
assertThat(map).as("There is one element in map").hasSize(2);
TestBean tb = (TestBean) map.get("person");
assertThat(tb.equals(rod)).as("Same object").isTrue();
assertThat(tb).as("Same object").isEqualTo(rod);
BindingResult other = new DataBinder(rod, "person").getBindingResult();
assertThat(binder.getBindingResult()).isEqualTo(other);
@@ -793,7 +793,7 @@ class DataBinderTests {
Map<?,?> m = binder.getBindingResult().getModel();
assertThat(m).as("There is one element in map").hasSize(2);
TestBean tb = (TestBean) m.get("person");
assertThat(tb.equals(rod)).as("Same object").isTrue();
assertThat(tb).as("Same object").isEqualTo(rod);
}
@Test
spring-context/src/testFixtures/java/org/springframework/context/testfixture/AbstractApplicationContextTests.java
+3 -3
View File
@@ -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
+1 -1
View File
@@ -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
+1 -1
View File
@@ -63,7 +63,7 @@ class AnnotationAttributesTests {
assertThat(attributes.getBoolean("bool1")).isTrue();
assertThat(attributes.getBoolean("bool2")).isFalse();
assertThat(attributes.<Color>getEnum("color")).isEqualTo(Color.RED);
assertThat(attributes.getClass("class").equals(Integer.class)).isTrue();
assertThat(attributes.getClass("class")).isEqualTo(Integer.class);
assertThat(attributes.getClassArray("classes")).isEqualTo(new Class<?>[] {Number.class, Short.class, Integer.class});
assertThat(attributes.<Integer>getNumber("number")).isEqualTo(42);
assertThat(attributes.getAnnotation("anno").<Integer>getNumber("value")).isEqualTo(10);
spring-core/src/test/java/org/springframework/core/type/AnnotationMetadataTests.java
+6 -6
View File
@@ -433,33 +433,33 @@ class AnnotationMetadataTests {
AnnotationAttributes specialAttrs = (AnnotationAttributes) metadata.getAnnotationAttributes(SpecialAttr.class.getName());
assertThat(specialAttrs).hasSize(6);
assertThat(String.class.isAssignableFrom(specialAttrs.getClass("clazz"))).isTrue();
assertThat(specialAttrs.getEnum("state").equals(Thread.State.NEW)).isTrue();
assertThat((Enum<?>) specialAttrs.getEnum("state")).isEqualTo(Thread.State.NEW);
AnnotationAttributes nestedAnno = specialAttrs.getAnnotation("nestedAnno");
assertThat(nestedAnno.getString("value")).isEqualTo("na");
assertThat(nestedAnno.getEnum("anEnum").equals(SomeEnum.LABEL1)).isTrue();
assertThat((Enum<?>) nestedAnno.getEnum("anEnum")).isEqualTo(SomeEnum.LABEL1);
assertThat((Class<?>[]) nestedAnno.get("classArray")).isEqualTo(new Class<?>[] {String.class});
AnnotationAttributes[] nestedAnnoArray = specialAttrs.getAnnotationArray("nestedAnnoArray");
assertThat(nestedAnnoArray).hasSize(2);
assertThat(nestedAnnoArray[0].getString("value")).isEqualTo("default");
assertThat(nestedAnnoArray[0].getEnum("anEnum").equals(SomeEnum.DEFAULT)).isTrue();
assertThat((Enum<?>) nestedAnnoArray[0].getEnum("anEnum")).isEqualTo(SomeEnum.DEFAULT);
assertThat((Class<?>[]) nestedAnnoArray[0].get("classArray")).isEqualTo(new Class<?>[] {Void.class});
assertThat(nestedAnnoArray[1].getString("value")).isEqualTo("na1");
assertThat(nestedAnnoArray[1].getEnum("anEnum").equals(SomeEnum.LABEL2)).isTrue();
assertThat((Enum<?>) nestedAnnoArray[1].getEnum("anEnum")).isEqualTo(SomeEnum.LABEL2);
assertThat((Class<?>[]) nestedAnnoArray[1].get("classArray")).isEqualTo(new Class<?>[] {Number.class});
assertThat(nestedAnnoArray[1].getClassArray("classArray")).isEqualTo(new Class<?>[] {Number.class});
AnnotationAttributes optional = specialAttrs.getAnnotation("optional");
assertThat(optional.getString("value")).isEqualTo("optional");
assertThat(optional.getEnum("anEnum").equals(SomeEnum.DEFAULT)).isTrue();
assertThat((Enum<?>) optional.getEnum("anEnum")).isEqualTo(SomeEnum.DEFAULT);
assertThat((Class<?>[]) optional.get("classArray")).isEqualTo(new Class<?>[] {Void.class});
assertThat(optional.getClassArray("classArray")).isEqualTo(new Class<?>[] {Void.class});
AnnotationAttributes[] optionalArray = specialAttrs.getAnnotationArray("optionalArray");
assertThat(optionalArray).hasSize(1);
assertThat(optionalArray[0].getString("value")).isEqualTo("optional");
assertThat(optionalArray[0].getEnum("anEnum").equals(SomeEnum.DEFAULT)).isTrue();
assertThat((Enum<?>) optionalArray[0].getEnum("anEnum")).isEqualTo(SomeEnum.DEFAULT);
assertThat((Class<?>[]) optionalArray[0].get("classArray")).isEqualTo(new Class<?>[] {Void.class});
assertThat(optionalArray[0].getClassArray("classArray")).isEqualTo(new Class<?>[] {Void.class});
spring-core/src/test/java/org/springframework/util/CompositeSetTests.java
+1 -1
View File
@@ -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
+1 -1
View File
@@ -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
+44 -62
View File
@@ -16,7 +16,6 @@
package org.springframework.util;
import java.util.Arrays;
import java.util.Collections;
import java.util.Locale;
import java.util.Properties;
@@ -515,120 +514,106 @@ class StringUtilsTests {
@Test
void tokenizeToStringArray() {
String[] sa = StringUtils.tokenizeToStringArray("a,b , ,c", ",");
assertThat(sa).hasSize(3);
assertThat(sa[0].equals("a") && sa[1].equals("b") && sa[2].equals("c")).as("components are correct").isTrue();
String[] array = StringUtils.tokenizeToStringArray("a,b , ,c", ",");
assertThat(array).containsExactly("a", "b", "c");
}
@Test
void tokenizeToStringArrayWithNotIgnoreEmptyTokens() {
String[] sa = StringUtils.tokenizeToStringArray("a,b , ,c", ",", true, false);
assertThat(sa).hasSize(4);
assertThat(sa[0].equals("a") && sa[1].equals("b") && sa[2].isEmpty() && sa[3].equals("c")).as("components are correct").isTrue();
String[] array = StringUtils.tokenizeToStringArray("a,b , ,c", ",", true, false);
assertThat(array).containsExactly("a", "b", "", "c");
}
@Test
void tokenizeToStringArrayWithNotTrimTokens() {
String[] sa = StringUtils.tokenizeToStringArray("a,b ,c", ",", false, true);
assertThat(sa).hasSize(3);
assertThat(sa[0].equals("a") && sa[1].equals("b ") && sa[2].equals("c")).as("components are correct").isTrue();
String[] array = StringUtils.tokenizeToStringArray("a,b ,c", ",", false, true);
assertThat(array).containsExactly("a", "b ", "c");
}
@Test
void commaDelimitedListToStringArrayWithNullProducesEmptyArray() {
String[] sa = StringUtils.commaDelimitedListToStringArray(null);
assertThat(sa).as("String array isn't null with null input").isNotNull();
assertThat(sa.length).as("String array length == 0 with null input").isEqualTo(0);
String[] array = StringUtils.commaDelimitedListToStringArray(null);
assertThat(array).isEmpty();
}
@Test
void commaDelimitedListToStringArrayWithEmptyStringProducesEmptyArray() {
String[] sa = StringUtils.commaDelimitedListToStringArray("");
assertThat(sa).as("String array isn't null with null input").isNotNull();
assertThat(sa.length).as("String array length == 0 with null input").isEqualTo(0);
String[] array = StringUtils.commaDelimitedListToStringArray("");
assertThat(array).isEmpty();
}
@Test
void delimitedListToStringArrayWithComma() {
String[] sa = StringUtils.delimitedListToStringArray("a,b", ",");
assertThat(sa).hasSize(2);
assertThat(sa[0]).isEqualTo("a");
assertThat(sa[1]).isEqualTo("b");
String[] array = StringUtils.delimitedListToStringArray("a,b", ",");
assertThat(array).containsExactly("a", "b");
}
@Test
void delimitedListToStringArrayWithSemicolon() {
String[] sa = StringUtils.delimitedListToStringArray("a;b", ";");
assertThat(sa).hasSize(2);
assertThat(sa[0]).isEqualTo("a");
assertThat(sa[1]).isEqualTo("b");
String[] array = StringUtils.delimitedListToStringArray("a;b", ";");
assertThat(array).containsExactly("a", "b");
}
@Test
void delimitedListToStringArrayWithEmptyDelimiter() {
String[] sa = StringUtils.delimitedListToStringArray("a,b", "");
assertThat(sa).hasSize(3);
assertThat(sa[0]).isEqualTo("a");
assertThat(sa[1]).isEqualTo(",");
assertThat(sa[2]).isEqualTo("b");
String[] array = StringUtils.delimitedListToStringArray("a,b", "");
assertThat(array).containsExactly("a", ",", "b");
}
@Test
void delimitedListToStringArrayWithNullDelimiter() {
String[] sa = StringUtils.delimitedListToStringArray("a,b", null);
assertThat(sa).hasSize(1);
assertThat(sa[0]).isEqualTo("a,b");
String[] array = StringUtils.delimitedListToStringArray("a,b", null);
assertThat(array).containsExactly("a,b");
}
@Test
void delimitedListToStringArrayWithCharacterToDelete() {
String[] sa = StringUtils.delimitedListToStringArray("a,b,c", ",", "a");
assertThat(sa).containsExactly("", "b", "c");
String[] array = StringUtils.delimitedListToStringArray("a,b,c", ",", "a");
assertThat(array).containsExactly("", "b", "c");
}
@Test
void delimitedListToStringArrayWithCharacterToDeleteEqualsToDelimiter() {
String[] sa = StringUtils.delimitedListToStringArray("a,b,c", ",", ",");
assertThat(sa).containsExactly("a", "b", "c");
String[] array = StringUtils.delimitedListToStringArray("a,b,c", ",", ",");
assertThat(array).containsExactly("a", "b", "c");
}
@Test
void commaDelimitedListToStringArrayMatchWords() {
// Could read these from files
String[] sa = new String[] {"foo", "bar", "big"};
doTestCommaDelimitedListToStringArrayLegalMatch(sa);
doTestStringArrayReverseTransformationMatches(sa);
String[] array = new String[] {"foo", "bar", "big"};
doTestCommaDelimitedListToStringArrayLegalMatch(array);
doTestStringArrayReverseTransformationMatches(array);
sa = new String[] {"a", "b", "c"};
doTestCommaDelimitedListToStringArrayLegalMatch(sa);
doTestStringArrayReverseTransformationMatches(sa);
array = new String[] {"a", "b", "c"};
doTestCommaDelimitedListToStringArrayLegalMatch(array);
doTestStringArrayReverseTransformationMatches(array);
// Test same words
sa = new String[] {"AA", "AA", "AA", "AA", "AA"};
doTestCommaDelimitedListToStringArrayLegalMatch(sa);
doTestStringArrayReverseTransformationMatches(sa);
array = new String[] {"AA", "AA", "AA", "AA", "AA"};
doTestCommaDelimitedListToStringArrayLegalMatch(array);
doTestStringArrayReverseTransformationMatches(array);
}
private void doTestStringArrayReverseTransformationMatches(String[] sa) {
private void doTestStringArrayReverseTransformationMatches(String[] array) {
String[] reverse =
StringUtils.commaDelimitedListToStringArray(StringUtils.arrayToCommaDelimitedString(sa));
assertThat(Arrays.asList(reverse)).as("Reverse transformation is equal").isEqualTo(Arrays.asList(sa));
StringUtils.commaDelimitedListToStringArray(StringUtils.arrayToCommaDelimitedString(array));
assertThat(reverse).as("Reverse transformation is equal").isEqualTo(array);
}
@Test
void commaDelimitedListToStringArraySingleString() {
// Could read these from files
String s = "woeirqupoiewuropqiewuorpqiwueopriquwopeiurqopwieur";
String[] sa = StringUtils.commaDelimitedListToStringArray(s);
assertThat(sa.length).as("Found one String with no delimiters").isEqualTo(1);
assertThat(sa[0]).as("Single array entry matches input String with no delimiters").isEqualTo(s);
String[] array = StringUtils.commaDelimitedListToStringArray(s);
assertThat(array).as("Single array entry matches input String with no delimiters").containsExactly(s);
}
@Test
void commaDelimitedListToStringArrayWithOtherPunctuation() {
// Could read these from files
String[] sa = new String[] {"xcvwert4456346&*.", "///", ".!", ".", ";"};
doTestCommaDelimitedListToStringArrayLegalMatch(sa);
String[] array = new String[] {"xcvwert4456346&*.", "///", ".!", ".", ";"};
doTestCommaDelimitedListToStringArrayLegalMatch(array);
}
/**
@@ -637,20 +622,17 @@ class StringUtilsTests {
@Test
void commaDelimitedListToStringArrayEmptyStrings() {
// Could read these from files
String[] sa = StringUtils.commaDelimitedListToStringArray("a,,b");
assertThat(sa.length).as("a,,b produces array length 3").isEqualTo(3);
assertThat(sa[0].equals("a") && sa[1].isEmpty() && sa[2].equals("b")).as("components are correct").isTrue();
String[] array = StringUtils.commaDelimitedListToStringArray("a,,b");
assertThat(array).containsExactly("a", "", "b");
sa = new String[] {"", "", "a", ""};
doTestCommaDelimitedListToStringArrayLegalMatch(sa);
array = new String[] {"", "", "a", ""};
doTestCommaDelimitedListToStringArrayLegalMatch(array);
}
private void doTestCommaDelimitedListToStringArrayLegalMatch(String[] components) {
String sb = String.join(String.valueOf(','), components);
String[] sa = StringUtils.commaDelimitedListToStringArray(sb);
assertThat(sa).as("String array isn't null with legal match").isNotNull();
assertThat(sa.length).as("String array length is correct with legal match").isEqualTo(components.length);
assertThat(Arrays.equals(sa, components)).as("Output equals input").isTrue();
String[] array = StringUtils.commaDelimitedListToStringArray(sb);
assertThat(array).as("Output equals input").isEqualTo(components);
}
spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java
+8 -8
View File
@@ -886,10 +886,10 @@ class EvaluationTests extends AbstractExpressionTests {
// BigDecimal
e = parser.parseExpression("bd++");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("2")).isEqualTo(helper.bd);
BigDecimal return_bd = e.getValue(ctx, BigDecimal.class);
assertThat(new BigDecimal("2")).isEqualTo(return_bd);
assertThat(new BigDecimal("3").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("3")).isEqualTo(helper.bd);
// double
e = parser.parseExpression("ddd++");
@@ -939,10 +939,10 @@ class EvaluationTests extends AbstractExpressionTests {
// BigDecimal
e = parser.parseExpression("++bd");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("2")).isEqualTo(helper.bd);
BigDecimal return_bd = e.getValue(ctx, BigDecimal.class);
assertThat(new BigDecimal("3")).isEqualTo(return_bd);
assertThat(new BigDecimal("3").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("3")).isEqualTo(helper.bd);
// double
e = parser.parseExpression("++ddd");
@@ -1036,10 +1036,10 @@ class EvaluationTests extends AbstractExpressionTests {
// BigDecimal
e = parser.parseExpression("bd--");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("2")).isEqualTo(helper.bd);
BigDecimal return_bd = e.getValue(ctx,BigDecimal.class);
assertThat(new BigDecimal("2")).isEqualTo(return_bd);
assertThat(new BigDecimal("1").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("1")).isEqualTo(helper.bd);
// double
e = parser.parseExpression("ddd--");
@@ -1089,10 +1089,10 @@ class EvaluationTests extends AbstractExpressionTests {
// BigDecimal
e = parser.parseExpression("--bd");
assertThat(new BigDecimal("2").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("2")).isEqualTo(helper.bd);
BigDecimal return_bd = e.getValue(ctx,BigDecimal.class);
assertThat(new BigDecimal("1")).isEqualTo(return_bd);
assertThat(new BigDecimal("1").equals(helper.bd)).isTrue();
assertThat(new BigDecimal("1")).isEqualTo(helper.bd);
// double
e = parser.parseExpression("--ddd");
spring-web/src/test/java/org/springframework/http/HttpEntityTests.java
+3 -3
View File
@@ -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
+1 -1
View File
@@ -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
+1 -1
View File
@@ -205,7 +205,7 @@ class ServletRequestUtilsTests {
request.addParameter("param5", "1");
request.addParameter("paramEmpty", "");
assertThat(ServletRequestUtils.getBooleanParameter(request, "param1").equals(Boolean.TRUE)).isTrue();
assertThat(ServletRequestUtils.getBooleanParameter(request, "param1")).isEqualTo(Boolean.TRUE);
assertThat(ServletRequestUtils.getBooleanParameter(request, "param1", false)).isTrue();
assertThat(ServletRequestUtils.getRequiredBooleanParameter(request, "param1")).isTrue();
spring-web/src/test/java/org/springframework/web/bind/support/WebRequestDataBinderTests.java
+1 -1
View File
@@ -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
+3 -3
View File
@@ -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
+1 -1
View File
@@ -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
+2 -2
View File
@@ -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
spring-webmvc/src/test/java/org/springframework/web/servlet/view/RedirectViewTests.java
+1 -1
View File
@@ -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
+4 -4
View File
@@ -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);