Extracting non-breaking spaces in a constant for tests

assertj · Jul 29, 2023 · 0d5edf8 · 0d5edf8
1 parent 55197d7
commit 0d5edf8
Show file tree

Hide file tree

Showing 9 changed files with 95 additions and 53 deletions.
diff --git a/assertj-core/src/main/java/org/assertj/core/api/AbstractCharSequenceAssert.java b/assertj-core/src/main/java/org/assertj/core/api/AbstractCharSequenceAssert.java
@@ -1563,7 +1563,7 @@ public SELF isNotEqualToIgnoringWhitespace(CharSequence expected) {
    * To be exact, the following rules are applied:
    * <ul>
    * <li>all leading and trailing whitespace of both actual and expected strings are ignored</li>
-   * <li>any remaining whitespace (including non-breaking- spaces), appearing within either string, is collapsed to a single space before comparison</li>
+   * <li>any remaining whitespace (including non-breaking spaces), appearing within either string, is collapsed to a single space before comparison</li>
    * </ul>
    * <p>
    * Example:

diff --git a/assertj-core/src/test/java/org/assertj/core/internal/StringsBaseTest.java b/assertj-core/src/test/java/org/assertj/core/internal/StringsBaseTest.java
@@ -19,6 +19,10 @@
 import org.assertj.core.test.CaseInsensitiveStringComparator;
 import org.junit.jupiter.api.BeforeEach;
 
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
 /**
  * 
  * Base class for {@link Strings} tests.
@@ -38,6 +42,17 @@ public class StringsBaseTest {
   protected ComparatorBasedComparisonStrategy comparisonStrategy;
   protected Strings stringsWithCaseInsensitiveComparisonStrategy;
 
+  protected static final Set<Character> NON_BREAKING_SPACES;
+
+  static {
+    Set<Character> nonBreakingSpaces = new HashSet<>();
+    nonBreakingSpaces.add('\u00A0');
+    nonBreakingSpaces.add('\u2007');
+    nonBreakingSpaces.add('\u202F');
+
+    NON_BREAKING_SPACES = Collections.unmodifiableSet(nonBreakingSpaces);
+  }
+
   @BeforeEach
   public void setUp() {
     failures = spy(new Failures());

diff --git a/assertj-core/src/test/java/org/assertj/core/internal/strings/Strings_assertBlank_Test.java b/assertj-core/src/test/java/org/assertj/core/internal/strings/Strings_assertBlank_Test.java
@@ -41,11 +41,16 @@ void should_pass_if_string_is_blank(String actual) {
   }
 
   public static Stream<String> notBlank() {
-    return Stream.of("a",
-                     " bc ",
-                     "\u00A0", // non-breaking space
-                     "\u2007", // non-breaking space
-                     "\u202F"); // non-breaking space);
+
+    Stream<String> nonBreakingSpaces = NON_BREAKING_SPACES
+                                                          .stream()
+                                                          .map(String::valueOf);
+
+    Stream<String> notBlank = Stream.of(
+                                        "a",
+                                        " bc ");
+
+    return Stream.concat(notBlank, nonBreakingSpaces);
   }
 
   @ParameterizedTest

diff --git a/...st/java/org/assertj/core/internal/strings/Strings_assertContainsOnlyWhitespaces_Test.java b/...st/java/org/assertj/core/internal/strings/Strings_assertContainsOnlyWhitespaces_Test.java
@@ -39,13 +39,16 @@ void should_pass_if_string_contains_only_whitespaces(String actual) {
   }
 
   public static Stream<String> containNotOnlyWhitespace() {
-    return Stream.of(null,
-                     "",
-                     "a",
-                     " bc ",
-                     "\u00A0", // non-breaking space
-                     "\u2007", // non-breaking space
-                     "\u202F"); // non-breaking space
+    Stream<String> notBlank = Stream.of(null,
+                                        "",
+                                        "a",
+                                        " bc ");
+
+    Stream<String> nonBreakingSpaces = NON_BREAKING_SPACES
+                                                          .stream()
+                                                          .map(String::valueOf);
+
+    return Stream.concat(notBlank, nonBreakingSpaces);
   }
 
   @ParameterizedTest

diff --git a/...a/org/assertj/core/internal/strings/Strings_assertDoesNotContainOnlyWhitespaces_Test.java b/...a/org/assertj/core/internal/strings/Strings_assertDoesNotContainOnlyWhitespaces_Test.java
@@ -25,13 +25,16 @@
 class Strings_assertDoesNotContainOnlyWhitespaces_Test extends StringsBaseTest {
 
   public static Stream<String> containsNotOnlyWhitespace() {
-    return Stream.of(null,
-                     "",
-                     "a",
-                     " bc ",
-                     "\u00A0", // non-breaking space
-                     "\u2007", // non-breaking space
-                     "\u202F"); // non-breaking space
+    Stream<String> notBlank = Stream.of(null,
+                                        "",
+                                        "a",
+                                        " bc ");
+
+    Stream<String> nonBreakingSpaces = NON_BREAKING_SPACES
+                                                          .stream()
+                                                          .map(String::valueOf);
+
+    return Stream.concat(notBlank, nonBreakingSpaces);
   }
 
   @ParameterizedTest

diff --git a/...ava/org/assertj/core/internal/strings/Strings_assertEqualsNormalizingWhitespace_Test.java b/...ava/org/assertj/core/internal/strings/Strings_assertEqualsNormalizingWhitespace_Test.java
@@ -72,19 +72,25 @@ void should_pass_if_both_Strings_are_equal_after_whitespace_is_normalized(String
   }
 
   public static Stream<Arguments> equalNormalizingWhitespaceGenerator() {
-    return Stream.of(Arguments.of("my   foo bar", "my foo bar"),
-                     Arguments.of("  my foo bar  ", "my foo bar"),
-                     Arguments.of(" my\tfoo bar ", " my foo bar"),
-                     Arguments.of(" my foo    bar ", "my foo bar"),
-                     Arguments.of(" my foo    bar ", "  my foo bar   "),
-                     Arguments.of("       ", " "),
-                     Arguments.of(" my\tfoo bar ", new String(arrayOf(' ', 'm', 'y', ' ', 'f', 'o', 'o', ' ', 'b', 'a', 'r'))),
-                     Arguments.of(" my\tfoo bar ", " my\tfoo bar "),   // same
-                     Arguments.of(null, null),   // null
-                     Arguments.of(" \t \t", " "),
-                     Arguments.of(" abc", "abc "),
-                     Arguments.of("my\u00A0foo bar", "my foo bar"), // non-breaking space
-                     Arguments.of("my\u2007foo bar", "my foo bar"), // non-breaking space
-                     Arguments.of("my\u202Ffoo bar", "my foo bar")); // non-breaking space
+    Stream<Arguments> regularWhiteSpaces = Stream.of(Arguments.of("my   foo bar", "my foo bar"),
+                                                     Arguments.of("  my foo bar  ", "my foo bar"),
+                                                     Arguments.of(" my\tfoo bar ", " my foo bar"),
+                                                     Arguments.of(" my foo    bar ", "my foo bar"),
+                                                     Arguments.of(" my foo    bar ", "  my foo bar   "),
+                                                     Arguments.of("       ", " "),
+                                                     Arguments.of(" my\tfoo bar ",
+                                                                  new String(arrayOf(' ', 'm', 'y', ' ', 'f', 'o', 'o', ' ', 'b',
+                                                                                     'a', 'r'))),
+                                                     Arguments.of(" my\tfoo bar ", " my\tfoo bar "),   // same
+                                                     Arguments.of(null, null),   // null
+                                                     Arguments.of(" \t \t", " "),
+                                                     Arguments.of(" abc", "abc "));
+
+    Stream<Arguments> nonBreakingSpaces = NON_BREAKING_SPACES
+                                                             .stream()
+                                                             .map(nonBreakingSpace -> Arguments.of("my" + nonBreakingSpace
+                                                                                                   + "foo bar", "my foo bar"));
+
+    return Stream.concat(regularWhiteSpaces, nonBreakingSpaces);
   }
 }
diff --git a/...tj-core/src/test/java/org/assertj/core/internal/strings/Strings_assertJavaBlank_Test.java b/...tj-core/src/test/java/org/assertj/core/internal/strings/Strings_assertJavaBlank_Test.java
@@ -42,13 +42,16 @@ void should_pass_string_is_blank(String actual) {
   }
 
   public static Stream<String> notBlank() {
-    return Stream.of(null,
-                     "",
-                     "a",
-                     " bc ",
-                     "\u00A0", // non-breaking space
-                     "\u2007", // non-breaking space
-                     "\u202F"); // non-breaking space
+    Stream<String> notBlank = Stream.of(null,
+                                        "",
+                                        "a",
+                                        " bc ");
+
+    Stream<String> nonBreakingSpaces = NON_BREAKING_SPACES
+                                                          .stream()
+                                                          .map(String::valueOf);
+
+    return Stream.concat(notBlank, nonBreakingSpaces);
   }
 
   @ParameterizedTest

diff --git a/...rtj-core/src/test/java/org/assertj/core/internal/strings/Strings_assertNotBlank_Test.java b/...rtj-core/src/test/java/org/assertj/core/internal/strings/Strings_assertNotBlank_Test.java
@@ -25,11 +25,15 @@
 class Strings_assertNotBlank_Test extends StringsBaseTest {
 
   public static Stream<String> notBlank() {
-    return Stream.of("a",
-                     " bc ",
-                     "\u00A0", // non-breaking space
-                     "\u2007", // non-breaking space
-                     "\u202F"); // non-breaking space
+    Stream<String> nonBreakingSpaces = NON_BREAKING_SPACES
+                                                          .stream()
+                                                          .map(String::valueOf);
+
+    Stream<String> notBlank = Stream.of(
+                                        "a",
+                                        " bc ");
+
+    return Stream.concat(notBlank, nonBreakingSpaces);
   }
 
   @ParameterizedTest

diff --git a/...core/src/test/java/org/assertj/core/internal/strings/Strings_assertNotJavaBlank_Test.java b/...core/src/test/java/org/assertj/core/internal/strings/Strings_assertNotJavaBlank_Test.java
@@ -28,13 +28,16 @@
 class Strings_assertNotJavaBlank_Test extends StringsBaseTest {
 
   public static Stream<String> notBlank() {
-    return Stream.of(null,
-                     "",
-                     "a",
-                     " bc ",
-                     "\u00A0", // non-breaking space
-                     "\u2007", // non-breaking space
-                     "\u202F"); // non-breaking space
+    Stream<String> notBlank = Stream.of(null,
+                                        "",
+                                        "a",
+                                        " bc ");
+
+    Stream<String> nonBreakingSpaces = NON_BREAKING_SPACES
+                                                          .stream()
+                                                          .map(String::valueOf);
+
+    return Stream.concat(notBlank, nonBreakingSpaces);
   }
 
   @ParameterizedTest