spring/spring-framework
1
0
Fork 0
mirror of https://github.com/spring-projects/spring-framework.git synced 2026-09-17 16:39:29 +00:00
Code Issues 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-20 10:54:42 +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-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);
}