You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2024/09/30 17:12:56 UTC
(commons-text) branch master updated: Make test more readable and maintainable, and less verbose
This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-text.git
The following commit(s) were added to refs/heads/master by this push:
new 2c43b010 Make test more readable and maintainable, and less verbose
2c43b010 is described below
commit 2c43b01016f5218b2cd79b053e8ffaba01a31c5a
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Mon Sep 30 13:12:49 2024 -0400
Make test more readable and maintainable, and less verbose
- Use JUnit 5 APIs
- Be consistent throughout tests
---
pom.xml | 6 -
.../apache/commons/text/AlphabetConverterTest.java | 157 +++---
.../org/apache/commons/text/CaseUtilsTest.java | 70 +--
.../commons/text/CharacterPredicatesTest.java | 113 ++--
.../commons/text/ExtendedMessageFormatTest.java | 154 +++---
.../apache/commons/text/FormattableUtilsTest.java | 140 +++--
.../java/org/apache/commons/text/OssFuzzTest.java | Bin 16930 -> 16930 bytes
.../commons/text/RandomStringGeneratorTest.java | 79 ++-
.../commons/text/StrBuilderAppendInsertTest.java | 578 +++++++++++----------
.../org/apache/commons/text/StrBuilderTest.java | 113 ++--
.../org/apache/commons/text/StrMatcherTest.java | 182 +++----
.../apache/commons/text/StrSubstitutorTest.java | 3 +-
.../apache/commons/text/StringSubstitutorTest.java | 135 ++---
.../text/TextStringBuilderAppendInsertTest.java | 448 ++++++++--------
.../apache/commons/text/TextStringBuilderTest.java | 50 +-
.../org/apache/commons/text/WordUtilsTest.java | 572 ++++++++++----------
.../commons/text/diff/ReplacementsFinderTest.java | 4 +-
.../commons/text/diff/StringsComparatorTest.java | 9 +-
.../text/matcher/StringMatcherOnCharArrayTest.java | 376 +++++++-------
.../StringMatcherOnCharSequenceStringTest.java | 374 +++++++------
.../text/similarity/CosineDistanceTest.java | 13 +-
.../text/similarity/CosineSimilarityTest.java | 19 +-
.../commons/text/similarity/FuzzyScoreTest.java | 30 +-
.../text/similarity/HammingDistanceTest.java | 20 +-
.../similarity/IntersectionSimilarityTest.java | 23 +-
.../text/similarity/JaccardDistanceTest.java | 8 +-
.../text/similarity/JaccardSimilarityTest.java | 8 +-
.../text/similarity/LevenshteinDistanceTest.java | 8 +-
.../text/similarity/LevenshteinResultsTest.java | 24 +-
.../LongestCommonSubsequenceDistanceTest.java | 36 +-
.../similarity/LongestCommonSubsequenceTest.java | 104 ++--
.../ParameterizedEditDistanceFromTest.java | 7 +-
.../ParameterizedLevenshteinDistanceTest.java | 10 +-
.../ParameterizedSimilarityScoreFromTest.java | 20 +-
.../text/similarity/SimilarityScoreFromTest.java | 12 +-
.../text/similarity/StringMetricFromTest.java | 19 +-
.../text/translate/AggregateTranslatorTest.java | 14 +-
.../text/translate/CodePointTranslatorTest.java | 4 +-
.../commons/text/translate/CsvTranslatorsTest.java | 22 +-
.../commons/text/translate/EntityArraysTest.java | 16 +-
.../text/translate/JavaUnicodeEscaperTest.java | 16 +-
.../text/translate/LookupTranslatorTest.java | 16 +-
.../text/translate/NumericEntityEscaperTest.java | 12 +-
.../text/translate/NumericEntityUnescaperTest.java | 24 +-
.../commons/text/translate/OctalUnescaperTest.java | 29 +-
.../text/translate/SinglePassTranslatorTest.java | 14 +-
.../commons/text/translate/UnicodeEscaperTest.java | 28 +-
.../text/translate/UnicodeUnescaperTest.java | 19 +-
.../UnicodeUnpairedSurrogateRemoverTest.java | 16 +-
49 files changed, 2002 insertions(+), 2152 deletions(-)
diff --git a/pom.xml b/pom.xml
index 8cd88d77..419d3761 100644
--- a/pom.xml
+++ b/pom.xml
@@ -106,12 +106,6 @@
<version>${commons.bytebuddy.version}</version>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.assertj</groupId>
- <artifactId>assertj-core</artifactId>
- <version>3.26.3</version>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
diff --git a/src/test/java/org/apache/commons/text/AlphabetConverterTest.java b/src/test/java/org/apache/commons/text/AlphabetConverterTest.java
index b17fad88..59e78372 100644
--- a/src/test/java/org/apache/commons/text/AlphabetConverterTest.java
+++ b/src/test/java/org/apache/commons/text/AlphabetConverterTest.java
@@ -16,9 +16,11 @@
*/
package org.apache.commons.text;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
@@ -34,52 +36,52 @@ import org.junit.jupiter.api.Test;
*/
public class AlphabetConverterTest {
- private static final Character[] LOWER_CASE_ENGLISH = {' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
- 't', 'u', 'v', 'w', 'x', 'y', 'z'};
+ private static final Character[] LOWER_CASE_ENGLISH = { ' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
+ 't', 'u', 'v', 'w', 'x', 'y', 'z' };
- private static final Character[] ENGLISH_AND_NUMBERS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
- 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
- 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', ' '};
+ private static final Character[] ENGLISH_AND_NUMBERS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
+ 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+ 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', ' ' };
- private static final Character[] LOWER_CASE_ENGLISH_AND_NUMBERS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
- 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', ' '};
+ private static final Character[] LOWER_CASE_ENGLISH_AND_NUMBERS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
+ 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', ' ' };
- private static final Character[] NUMBERS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
+ private static final Character[] NUMBERS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
- private static final Character[] BINARY = {'0', '1'};
+ private static final Character[] BINARY = { '0', '1' };
- private static final Character[] HEBREW = {'_', ' ', '\u05e7', '\u05e8', '\u05d0', '\u05d8', '\u05d5', '\u05df', '\u05dd', '\u05e4', '\u05e9', '\u05d3',
- '\u05d2', '\u05db', '\u05e2', '\u05d9', '\u05d7', '\u05dc', '\u05da', '\u05e3', '\u05d6', '\u05e1', '\u05d1', '\u05d4', '\u05e0', '\u05de', '\u05e6',
- '\u05ea', '\u05e5'};
+ private static final Character[] HEBREW = { '_', ' ', '\u05e7', '\u05e8', '\u05d0', '\u05d8', '\u05d5', '\u05df', '\u05dd', '\u05e4', '\u05e9', '\u05d3',
+ '\u05d2', '\u05db', '\u05e2', '\u05d9', '\u05d7', '\u05dc', '\u05da', '\u05e3', '\u05d6', '\u05e1', '\u05d1', '\u05d4', '\u05e0', '\u05de',
+ '\u05e6', '\u05ea', '\u05e5' };
- private static final Integer[] UNICODE = {32, 35395, 35397, 36302, 36291, 35203, 35201, 35215, 35219, 35268, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
- 107, 108, 109, 110, 1001, 1002, 1003, 1004, 1005};
+ private static final Integer[] UNICODE = { 32, 35395, 35397, 36302, 36291, 35203, 35201, 35215, 35219, 35268, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
+ 107, 108, 109, 110, 1001, 1002, 1003, 1004, 1005 };
- private static final Integer[] LOWER_CASE_ENGLISH_CODEPOINTS = {32, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
- 115, 116, 117, 118, 119, 120, 121, 122};
+ private static final Integer[] LOWER_CASE_ENGLISH_CODEPOINTS = { 32, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
+ 115, 116, 117, 118, 119, 120, 121, 122 };
- private static final Integer[] DO_NOT_ENCODE_CODEPOINTS = {32, 97, 98, 99}; // space, a, b, c
+ private static final Integer[] DO_NOT_ENCODE_CODEPOINTS = { 32, 97, 98, 99 }; // space, a, b, c
private AlphabetConverter createJavadocExample() {
- final Character[] original = {'a', 'b', 'c', 'd'};
- final Character[] encoding = {'0', '1', 'd'};
- final Character[] doNotEncode = {'d'};
+ final Character[] original = { 'a', 'b', 'c', 'd' };
+ final Character[] encoding = { '0', '1', 'd' };
+ final Character[] doNotEncode = { 'd' };
return AlphabetConverter.createConverterFromChars(original, encoding, doNotEncode);
}
private void test(final Character[] originalChars, final Character[] encodingChars, final Character[] doNotEncodeChars, final String... strings)
- throws UnsupportedEncodingException {
+ throws UnsupportedEncodingException {
final AlphabetConverter ac = AlphabetConverter.createConverterFromChars(originalChars, encodingChars, doNotEncodeChars);
final AlphabetConverter reconstructedAlphabetConverter = AlphabetConverter.createConverterFromMap(ac.getOriginalToEncoded());
- assertThat(reconstructedAlphabetConverter).isEqualTo(ac);
- assertThat(reconstructedAlphabetConverter.hashCode()).isEqualTo(ac.hashCode());
- assertThat(reconstructedAlphabetConverter.toString()).isEqualTo(ac.toString());
- assertThat(ac.encode(null)).isNull(); // test null conversions
- assertThat(ac.encode("")).isEqualTo(""); // test empty conversion
+ assertEquals(ac, reconstructedAlphabetConverter);
+ assertEquals(ac.hashCode(), reconstructedAlphabetConverter.hashCode());
+ assertEquals(ac.toString(), reconstructedAlphabetConverter.toString());
+ assertNull(ac.encode(null)); // test null conversions
+ assertEquals("", ac.encode("")); // test empty conversion
// test all the trial strings
for (final String s : strings) {
@@ -88,7 +90,7 @@ public class AlphabetConverterTest {
// test that only encoding chars are used
final List<Character> originalEncodingChars = Arrays.asList(encodingChars);
for (int i = 0; i < encoded.length(); i++) {
- assertThat(originalEncodingChars.contains(encoded.charAt(i))).isTrue();
+ assertTrue(originalEncodingChars.contains(encoded.charAt(i)));
}
final String decoded = ac.decode(encoded);
@@ -96,10 +98,10 @@ public class AlphabetConverterTest {
// test that only the original alphabet is used after decoding
final List<Character> originalCharsList = Arrays.asList(originalChars);
for (int i = 0; i < decoded.length(); i++) {
- assertThat(originalCharsList.contains(decoded.charAt(i))).isTrue();
+ assertTrue(originalCharsList.contains(decoded.charAt(i)));
}
- assertThat(decoded).as("Encoded '" + s + "' into '" + encoded + "', but decoded into '" + decoded + "'").isEqualTo(s);
+ assertEquals(s, decoded, () -> "Encoded '" + s + "' into '" + encoded + "', but decoded into '" + decoded + "'");
}
}
@@ -119,7 +121,7 @@ public class AlphabetConverterTest {
characterArray[1] = characterArray[0];
final AlphabetConverter alphabetConverter = AlphabetConverter.createConverterFromChars(characterArray, characterArray, characterArray);
- assertThat(alphabetConverter.equals(charOne)).isFalse();
+ assertFalse(alphabetConverter.equals(charOne));
}
@Test
@@ -129,16 +131,15 @@ public class AlphabetConverterTest {
characterArray[1] = characterArray[0];
final AlphabetConverter alphabetConverter = AlphabetConverter.createConverterFromChars(characterArray, characterArray, characterArray);
- assertThat(alphabetConverter.getEncodedCharLength()).isEqualTo(1);
+ assertEquals(1, alphabetConverter.getEncodedCharLength());
}
@Test
public void testCreateConverterFromCharsWithNullAndNull() {
- assertThatIllegalArgumentException().isThrownBy(() -> {
+ assertThrows(IllegalArgumentException.class, () -> {
final Character[] characterArray = new Character[2];
characterArray[0] = '$';
characterArray[1] = characterArray[0];
-
AlphabetConverter.createConverterFromChars(characterArray, null, null);
});
}
@@ -149,9 +150,8 @@ public class AlphabetConverterTest {
final AlphabetConverter alphabetConverter = AlphabetConverter.createConverterFromMap(hashMap);
hashMap.put(0, "CtDs");
final AlphabetConverter alphabetConverterTwo = AlphabetConverter.createConverterFromMap(hashMap);
-
- assertThat(alphabetConverter.equals(alphabetConverterTwo)).isFalse();
- assertThat(alphabetConverter.getEncodedCharLength()).isEqualTo(1);
+ assertFalse(alphabetConverter.equals(alphabetConverterTwo));
+ assertEquals(1, alphabetConverter.getEncodedCharLength());
}
@Test
@@ -159,8 +159,7 @@ public class AlphabetConverterTest {
final Map<Integer, String> map = new HashMap<>();
final AlphabetConverter alphabetConverter = AlphabetConverter.createConverterFromMap(map);
alphabetConverter.decode(null);
-
- assertThat(alphabetConverter.getEncodedCharLength()).isEqualTo(1);
+ assertEquals(1, alphabetConverter.getEncodedCharLength());
}
@Test
@@ -171,8 +170,8 @@ public class AlphabetConverterTest {
@Test
public void testEncodeFailureTest() {
- assertThatThrownBy(() -> test(BINARY, NUMBERS, ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, "3")).isInstanceOf(UnsupportedEncodingException.class)
- .hasMessage("Couldn't find encoding for '3' in 3");
+ assertEquals("Couldn't find encoding for '3' in 3",
+ assertThrows(UnsupportedEncodingException.class, () -> test(BINARY, NUMBERS, ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, "3")).getMessage());
}
@Test
@@ -185,8 +184,8 @@ public class AlphabetConverterTest {
final Map<Integer, String> map = new HashMap<>();
final AlphabetConverter alphabetConverterTwo = AlphabetConverter.createConverterFromMap(map);
- assertThat(alphabetConverterTwo.getEncodedCharLength()).isEqualTo(1);
- assertThat(alphabetConverter.equals(alphabetConverterTwo)).isFalse();
+ assertEquals(1, alphabetConverterTwo.getEncodedCharLength());
+ assertFalse(alphabetConverter.equals(alphabetConverterTwo));
}
@Test
@@ -194,7 +193,7 @@ public class AlphabetConverterTest {
final Character[] characterArray = ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY;
final AlphabetConverter alphabetConverter = AlphabetConverter.createConverterFromChars(characterArray, null, null);
- assertThat(alphabetConverter.equals(null)).isFalse();
+ assertFalse(alphabetConverter.equals(null));
}
@Test
@@ -205,17 +204,17 @@ public class AlphabetConverterTest {
characterArray[1] = character;
final AlphabetConverter alphabetConverter = AlphabetConverter.createConverterFromChars(characterArray, characterArray, characterArray);
- assertThat(alphabetConverter.equals(alphabetConverter)).isTrue();
+ assertTrue(alphabetConverter.equals(alphabetConverter));
}
@Test
public void testHebrewTest() throws UnsupportedEncodingException {
test(HEBREW, BINARY, ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, "\u05d0", "\u05e2",
- "\u05d0\u05dc\u05e3_\u05d0\u05d5\u05d4\u05d1\u05dc_\u05d1\u05d9\u05ea_\u05d6\u05d4_\u05d1\u05d9\u05ea_"
- + "\u05d2\u05d9\u05de\u05dc_\u05d6\u05d4_\u05db\u05de\u05dc_\u05d2\u05d3\u05d5\u05dc");
+ "\u05d0\u05dc\u05e3_\u05d0\u05d5\u05d4\u05d1\u05dc_\u05d1\u05d9\u05ea_\u05d6\u05d4_\u05d1\u05d9\u05ea_"
+ + "\u05d2\u05d9\u05de\u05dc_\u05d6\u05d4_\u05db\u05de\u05dc_\u05d2\u05d3\u05d5\u05dc");
test(HEBREW, NUMBERS, ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, "\u05d0", "\u05e2",
- "\u05d0\u05dc\u05e3_\u05d0\u05d5\u05d4\u05d1\u05dc_\u05d1\u05d9\u05ea_\u05d6\u05d4_\u05d1\u05d9\u05ea_"
- + "\u05d2\u05d9\u05de\u05dc_\u05d6\u05d4_\u05db\u05de\u05dc_\u05d2\u05d3\u05d5\u05dc");
+ "\u05d0\u05dc\u05e3_\u05d0\u05d5\u05d4\u05d1\u05dc_\u05d1\u05d9\u05ea_\u05d6\u05d4_\u05d1\u05d9\u05ea_"
+ + "\u05d2\u05d9\u05de\u05dc_\u05d6\u05d4_\u05db\u05de\u05dc_\u05d2\u05d3\u05d5\u05dc");
test(NUMBERS, HEBREW, ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, "123456789", "1", "5");
test(LOWER_CASE_ENGLISH, HEBREW, ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, "this is a test");
}
@@ -227,58 +226,57 @@ public class AlphabetConverterTest {
public void testJavadocExampleTest() throws UnsupportedEncodingException {
final AlphabetConverter ac = createJavadocExample();
- assertThat(ac.encode("a")).isEqualTo("00");
- assertThat(ac.encode("b")).isEqualTo("01");
- assertThat(ac.encode("c")).isEqualTo("0d");
- assertThat(ac.encode("d")).isEqualTo("d");
- assertThat(ac.encode("abcd")).isEqualTo("00010dd");
+ assertEquals("00", ac.encode("a"));
+ assertEquals("01", ac.encode("b"));
+ assertEquals("0d", ac.encode("c"));
+ assertEquals("d", ac.encode("d"));
+ assertEquals("00010dd", ac.encode("abcd"));
}
@Test
public void testMissingDoNotEncodeLettersFromEncodingTest() {
- assertThatThrownBy(() -> AlphabetConverter.createConverterFromChars(ENGLISH_AND_NUMBERS, LOWER_CASE_ENGLISH, NUMBERS))
- .isInstanceOf(IllegalArgumentException.class).hasMessage("Can not use 'do not encode' list because encoding alphabet does not contain '0'");
+ assertEquals("Can not use 'do not encode' list because encoding alphabet does not contain '0'",
+ assertThrows(IllegalArgumentException.class, () -> AlphabetConverter.createConverterFromChars(ENGLISH_AND_NUMBERS, LOWER_CASE_ENGLISH, NUMBERS))
+ .getMessage());
}
@Test
public void testMissingDoNotEncodeLettersFromOriginalTest() {
- assertThatThrownBy(() -> AlphabetConverter.createConverterFromChars(LOWER_CASE_ENGLISH, ENGLISH_AND_NUMBERS, NUMBERS))
- .isInstanceOf(IllegalArgumentException.class).hasMessage("Can not use 'do not encode' list because original alphabet does not contain '0'");
+ assertEquals("Can not use 'do not encode' list because original alphabet does not contain '0'",
+ assertThrows(IllegalArgumentException.class, () -> AlphabetConverter.createConverterFromChars(LOWER_CASE_ENGLISH, ENGLISH_AND_NUMBERS, NUMBERS))
+ .getMessage());
}
@Test
public void testNoEncodingLettersTest() {
- assertThatThrownBy(() -> AlphabetConverter.createConverterFromChars(ENGLISH_AND_NUMBERS, NUMBERS, NUMBERS)).isInstanceOf(IllegalArgumentException.class)
- .hasMessage("Must have at least two encoding characters (excluding those in the 'do not encode' list), but has 0");
+ assertEquals("Must have at least two encoding characters (excluding those in the 'do not encode' list), but has 0",
+ assertThrows(IllegalArgumentException.class, () -> AlphabetConverter.createConverterFromChars(ENGLISH_AND_NUMBERS, NUMBERS, NUMBERS))
+ .getMessage());
}
@Test
public void testOnlyOneEncodingLettersTest() {
- assertThatThrownBy(() -> {
- final Character[] numbersPlusUnderscore = Arrays.copyOf(NUMBERS, NUMBERS.length + 1);
- numbersPlusUnderscore[numbersPlusUnderscore.length - 1] = '_';
+ assertEquals("Must have at least two encoding characters (excluding those in the 'do not encode' list), but has 1",
+ assertThrows(IllegalArgumentException.class, () -> {
+ final Character[] numbersPlusUnderscore = Arrays.copyOf(NUMBERS, NUMBERS.length + 1);
+ numbersPlusUnderscore[numbersPlusUnderscore.length - 1] = '_';
- AlphabetConverter.createConverterFromChars(ENGLISH_AND_NUMBERS, numbersPlusUnderscore, NUMBERS);
- }).isInstanceOf(IllegalArgumentException.class)
- .hasMessage("Must have at least two encoding characters (excluding those in the 'do not encode' list), but has 1");
+ AlphabetConverter.createConverterFromChars(ENGLISH_AND_NUMBERS, numbersPlusUnderscore, NUMBERS);
+ }).getMessage());
}
@Test
public void testUnexpectedEndWhileDecodingTest() {
final String toDecode = "00d01d0";
- assertThatThrownBy(() -> {
- final AlphabetConverter ac = createJavadocExample();
- ac.decode(toDecode);
- }).isInstanceOf(UnsupportedEncodingException.class).hasMessage("Unexpected end of string while decoding " + toDecode);
+ assertEquals("Unexpected end of string while decoding " + toDecode,
+ assertThrows(UnsupportedEncodingException.class, () -> createJavadocExample().decode(toDecode)).getMessage());
}
@Test
public void testUnexpectedStringWhileDecodingTest() {
final String toDecode = "00XX";
- assertThatThrownBy(() -> {
- final AlphabetConverter ac = createJavadocExample();
- ac.decode(toDecode);
- }).isInstanceOf(UnsupportedEncodingException.class).hasMessage("Unexpected string without decoding (XX) in " + toDecode);
+ assertEquals("Unexpected string without decoding (XX) in " + toDecode,
+ assertThrows(UnsupportedEncodingException.class, () -> createJavadocExample().decode(toDecode)).getMessage());
}
/**
@@ -287,14 +285,11 @@ public class AlphabetConverterTest {
@Test
public void testUnicodeTest() throws UnsupportedEncodingException {
final AlphabetConverter ac = AlphabetConverter.createConverter(UNICODE, LOWER_CASE_ENGLISH_CODEPOINTS, DO_NOT_ENCODE_CODEPOINTS);
-
- assertThat(ac.getEncodedCharLength()).isEqualTo(2);
-
+ assertEquals(2, ac.getEncodedCharLength());
final String original = "\u8a43\u8a45 \u8dce ab \u8dc3 c \u8983";
final String encoded = ac.encode(original);
final String decoded = ac.decode(encoded);
-
- assertThat(decoded).as("Encoded '" + original + "' into '" + encoded + "', but decoded into '" + decoded + "'").isEqualTo(original);
+ assertEquals(original, decoded, () -> "Encoded '" + original + "' into '" + encoded + "', but decoded into '" + decoded + "'");
}
}
diff --git a/src/test/java/org/apache/commons/text/CaseUtilsTest.java b/src/test/java/org/apache/commons/text/CaseUtilsTest.java
index f7195e70..78a6c549 100644
--- a/src/test/java/org/apache/commons/text/CaseUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/CaseUtilsTest.java
@@ -16,7 +16,11 @@
*/
package org.apache.commons.text;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
@@ -30,47 +34,47 @@ public class CaseUtilsTest {
@Test
public void testConstructor() {
- assertThat(new CaseUtils()).isNotNull();
+ assertNotNull(new CaseUtils());
final Constructor<?>[] cons = CaseUtils.class.getDeclaredConstructors();
- assertThat(cons.length).isEqualTo(1);
- assertThat(Modifier.isPublic(cons[0].getModifiers())).isTrue();
- assertThat(Modifier.isPublic(CaseUtils.class.getModifiers())).isTrue();
- assertThat(Modifier.isFinal(CaseUtils.class.getModifiers())).isFalse();
+ assertEquals(1, cons.length);
+ assertTrue(Modifier.isPublic(cons[0].getModifiers()));
+ assertTrue(Modifier.isPublic(CaseUtils.class.getModifiers()));
+ assertFalse(Modifier.isFinal(CaseUtils.class.getModifiers()));
}
@Test
public void testToCamelCase() {
- assertThat(CaseUtils.toCamelCase(null, false, null)).isNull();
- assertThat(CaseUtils.toCamelCase("", true, null)).isEqualTo("");
- assertThat(CaseUtils.toCamelCase(" ", false, null)).isEqualTo("");
- assertThat(CaseUtils.toCamelCase("a b c @def", false, null)).isEqualTo("aBC@def");
- assertThat(CaseUtils.toCamelCase("a b c @def", true)).isEqualTo("ABC@def");
- assertThat(CaseUtils.toCamelCase("a b c @def", true, '-')).isEqualTo("ABC@def");
- assertThat(CaseUtils.toCamelCase("a b c @def", true, '-')).isEqualTo("ABC@def");
+ assertNull(CaseUtils.toCamelCase(null, false, null));
+ assertEquals("", CaseUtils.toCamelCase("", true, null));
+ assertEquals("", CaseUtils.toCamelCase(" ", false, null));
+ assertEquals("aBC@def", CaseUtils.toCamelCase("a b c @def", false, null));
+ assertEquals("ABC@def", CaseUtils.toCamelCase("a b c @def", true));
+ assertEquals("ABC@def", CaseUtils.toCamelCase("a b c @def", true, '-'));
+ assertEquals("ABC@def", CaseUtils.toCamelCase("a b c @def", true, '-'));
- final char[] chars = {'-', '+', ' ', '@'};
- assertThat(CaseUtils.toCamelCase("-+@ ", true, chars)).isEqualTo("");
- assertThat(CaseUtils.toCamelCase(" to-CAMEL-cASE", false, chars)).isEqualTo("toCamelCase");
- assertThat(CaseUtils.toCamelCase("@@@@ to+CAMEL@cASE ", true, chars)).isEqualTo("ToCamelCase");
- assertThat(CaseUtils.toCamelCase("To+CA+ME L@cASE", true, chars)).isEqualTo("ToCaMeLCase");
+ final char[] chars = { '-', '+', ' ', '@' };
+ assertEquals("", CaseUtils.toCamelCase("-+@ ", true, chars));
+ assertEquals("toCamelCase", CaseUtils.toCamelCase(" to-CAMEL-cASE", false, chars));
+ assertEquals("ToCamelCase", CaseUtils.toCamelCase("@@@@ to+CAMEL@cASE ", true, chars));
+ assertEquals("ToCaMeLCase", CaseUtils.toCamelCase("To+CA+ME L@cASE", true, chars));
- assertThat(CaseUtils.toCamelCase("To.Camel.Case", false, '.')).isEqualTo("toCamelCase");
- assertThat(CaseUtils.toCamelCase("To.Camel-Case", false, '-', '.')).isEqualTo("toCamelCase");
- assertThat(CaseUtils.toCamelCase(" to @ Camel case", false, '-', '@')).isEqualTo("toCamelCase");
- assertThat(CaseUtils.toCamelCase(" @to @ Camel case", true, '-', '@')).isEqualTo("ToCamelCase");
+ assertEquals("toCamelCase", CaseUtils.toCamelCase("To.Camel.Case", false, '.'));
+ assertEquals("toCamelCase", CaseUtils.toCamelCase("To.Camel-Case", false, '-', '.'));
+ assertEquals("toCamelCase", CaseUtils.toCamelCase(" to @ Camel case", false, '-', '@'));
+ assertEquals("ToCamelCase", CaseUtils.toCamelCase(" @to @ Camel case", true, '-', '@'));
- assertThat(CaseUtils.toCamelCase("TO CAMEL CASE", true, null)).isEqualTo("ToCamelCase");
- assertThat(CaseUtils.toCamelCase("TO CAMEL CASE", false, null)).isEqualTo("toCamelCase");
- assertThat(CaseUtils.toCamelCase("TO CAMEL CASE", false, null)).isEqualTo("toCamelCase");
- assertThat(CaseUtils.toCamelCase("tocamelcase", false, null)).isEqualTo("tocamelcase");
- assertThat(CaseUtils.toCamelCase("tocamelcase", true, null)).isEqualTo("Tocamelcase");
- assertThat(CaseUtils.toCamelCase("Tocamelcase", false, null)).isEqualTo("tocamelcase");
+ assertEquals("ToCamelCase", CaseUtils.toCamelCase("TO CAMEL CASE", true, null));
+ assertEquals("toCamelCase", CaseUtils.toCamelCase("TO CAMEL CASE", false, null));
+ assertEquals("toCamelCase", CaseUtils.toCamelCase("TO CAMEL CASE", false, null));
+ assertEquals("tocamelcase", CaseUtils.toCamelCase("tocamelcase", false, null));
+ assertEquals("Tocamelcase", CaseUtils.toCamelCase("tocamelcase", true, null));
+ assertEquals("tocamelcase", CaseUtils.toCamelCase("Tocamelcase", false, null));
- assertThat(CaseUtils.toCamelCase("tocamelcase", true)).isEqualTo("Tocamelcase");
- assertThat(CaseUtils.toCamelCase("tocamelcase", false)).isEqualTo("tocamelcase");
+ assertEquals("Tocamelcase", CaseUtils.toCamelCase("tocamelcase", true));
+ assertEquals("tocamelcase", CaseUtils.toCamelCase("tocamelcase", false));
- assertThat(CaseUtils.toCamelCase("\uD800\uDF00 \uD800\uDF02", true)).isEqualTo("\uD800\uDF00\uD800\uDF02");
- assertThat(CaseUtils.toCamelCase("\uD800\uDF00\uD800\uDF01\uD800\uDF14\uD800\uDF02\uD800\uDF03", true, '\uD800',
- '\uDF14')).isEqualTo("\uD800\uDF00\uD800\uDF01\uD800\uDF02\uD800\uDF03");
+ assertEquals("\uD800\uDF00\uD800\uDF02", CaseUtils.toCamelCase("\uD800\uDF00 \uD800\uDF02", true));
+ assertEquals("\uD800\uDF00\uD800\uDF01\uD800\uDF02\uD800\uDF03",
+ CaseUtils.toCamelCase("\uD800\uDF00\uD800\uDF01\uD800\uDF14\uD800\uDF02\uD800\uDF03", true, '\uD800', '\uDF14'));
}
}
diff --git a/src/test/java/org/apache/commons/text/CharacterPredicatesTest.java b/src/test/java/org/apache/commons/text/CharacterPredicatesTest.java
index 4a53c6b3..815ff13e 100644
--- a/src/test/java/org/apache/commons/text/CharacterPredicatesTest.java
+++ b/src/test/java/org/apache/commons/text/CharacterPredicatesTest.java
@@ -16,7 +16,8 @@
*/
package org.apache.commons.text;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
@@ -27,87 +28,87 @@ public class CharacterPredicatesTest {
@Test
public void testArabicNumerals() {
- assertThat(CharacterPredicates.ARABIC_NUMERALS.test('0')).isTrue();
- assertThat(CharacterPredicates.ARABIC_NUMERALS.test('1')).isTrue();
- assertThat(CharacterPredicates.ARABIC_NUMERALS.test('9')).isTrue();
+ assertTrue(CharacterPredicates.ARABIC_NUMERALS.test('0'));
+ assertTrue(CharacterPredicates.ARABIC_NUMERALS.test('1'));
+ assertTrue(CharacterPredicates.ARABIC_NUMERALS.test('9'));
- assertThat(CharacterPredicates.ARABIC_NUMERALS.test('/')).isFalse();
- assertThat(CharacterPredicates.ARABIC_NUMERALS.test(':')).isFalse();
- assertThat(CharacterPredicates.ARABIC_NUMERALS.test('a')).isFalse();
+ assertFalse(CharacterPredicates.ARABIC_NUMERALS.test('/'));
+ assertFalse(CharacterPredicates.ARABIC_NUMERALS.test(':'));
+ assertFalse(CharacterPredicates.ARABIC_NUMERALS.test('a'));
}
@Test
public void testAsciiAlphaNumerals() {
- assertThat(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('a')).isTrue();
- assertThat(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('z')).isTrue();
- assertThat(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('A')).isTrue();
- assertThat(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('Z')).isTrue();
- assertThat(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('0')).isTrue();
- assertThat(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('9')).isTrue();
-
- assertThat(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('`')).isFalse();
- assertThat(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('{')).isFalse();
- assertThat(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('@')).isFalse();
- assertThat(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('[')).isFalse();
- assertThat(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('/')).isFalse();
- assertThat(CharacterPredicates.ASCII_ALPHA_NUMERALS.test(':')).isFalse();
+ assertTrue(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('a'));
+ assertTrue(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('z'));
+ assertTrue(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('A'));
+ assertTrue(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('Z'));
+ assertTrue(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('0'));
+ assertTrue(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('9'));
+
+ assertFalse(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('`'));
+ assertFalse(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('{'));
+ assertFalse(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('@'));
+ assertFalse(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('['));
+ assertFalse(CharacterPredicates.ASCII_ALPHA_NUMERALS.test('/'));
+ assertFalse(CharacterPredicates.ASCII_ALPHA_NUMERALS.test(':'));
}
@Test
public void testAsciiLetters() {
- assertThat(CharacterPredicates.ASCII_LETTERS.test('a')).isTrue();
- assertThat(CharacterPredicates.ASCII_LETTERS.test('z')).isTrue();
- assertThat(CharacterPredicates.ASCII_LETTERS.test('A')).isTrue();
- assertThat(CharacterPredicates.ASCII_LETTERS.test('Z')).isTrue();
-
- assertThat(CharacterPredicates.ASCII_LETTERS.test('9')).isFalse();
- assertThat(CharacterPredicates.ASCII_LETTERS.test('`')).isFalse();
- assertThat(CharacterPredicates.ASCII_LETTERS.test('{')).isFalse();
- assertThat(CharacterPredicates.ASCII_LETTERS.test('@')).isFalse();
- assertThat(CharacterPredicates.ASCII_LETTERS.test('[')).isFalse();
+ assertTrue(CharacterPredicates.ASCII_LETTERS.test('a'));
+ assertTrue(CharacterPredicates.ASCII_LETTERS.test('z'));
+ assertTrue(CharacterPredicates.ASCII_LETTERS.test('A'));
+ assertTrue(CharacterPredicates.ASCII_LETTERS.test('Z'));
+
+ assertFalse(CharacterPredicates.ASCII_LETTERS.test('9'));
+ assertFalse(CharacterPredicates.ASCII_LETTERS.test('`'));
+ assertFalse(CharacterPredicates.ASCII_LETTERS.test('{'));
+ assertFalse(CharacterPredicates.ASCII_LETTERS.test('@'));
+ assertFalse(CharacterPredicates.ASCII_LETTERS.test('['));
}
@Test
public void testAsciiLowercaseLetters() {
- assertThat(CharacterPredicates.ASCII_LOWERCASE_LETTERS.test('a')).isTrue();
- assertThat(CharacterPredicates.ASCII_LOWERCASE_LETTERS.test('z')).isTrue();
-
- assertThat(CharacterPredicates.ASCII_LOWERCASE_LETTERS.test('9')).isFalse();
- assertThat(CharacterPredicates.ASCII_LOWERCASE_LETTERS.test('A')).isFalse();
- assertThat(CharacterPredicates.ASCII_LOWERCASE_LETTERS.test('Z')).isFalse();
- assertThat(CharacterPredicates.ASCII_LOWERCASE_LETTERS.test('`')).isFalse();
- assertThat(CharacterPredicates.ASCII_LOWERCASE_LETTERS.test('{')).isFalse();
+ assertTrue(CharacterPredicates.ASCII_LOWERCASE_LETTERS.test('a'));
+ assertTrue(CharacterPredicates.ASCII_LOWERCASE_LETTERS.test('z'));
+
+ assertFalse(CharacterPredicates.ASCII_LOWERCASE_LETTERS.test('9'));
+ assertFalse(CharacterPredicates.ASCII_LOWERCASE_LETTERS.test('A'));
+ assertFalse(CharacterPredicates.ASCII_LOWERCASE_LETTERS.test('Z'));
+ assertFalse(CharacterPredicates.ASCII_LOWERCASE_LETTERS.test('`'));
+ assertFalse(CharacterPredicates.ASCII_LOWERCASE_LETTERS.test('{'));
}
@Test
public void testAsciiUppercaseLetters() {
- assertThat(CharacterPredicates.ASCII_UPPERCASE_LETTERS.test('A')).isTrue();
- assertThat(CharacterPredicates.ASCII_UPPERCASE_LETTERS.test('Z')).isTrue();
-
- assertThat(CharacterPredicates.ASCII_UPPERCASE_LETTERS.test('9')).isFalse();
- assertThat(CharacterPredicates.ASCII_UPPERCASE_LETTERS.test('@')).isFalse();
- assertThat(CharacterPredicates.ASCII_UPPERCASE_LETTERS.test('[')).isFalse();
- assertThat(CharacterPredicates.ASCII_UPPERCASE_LETTERS.test('a')).isFalse();
- assertThat(CharacterPredicates.ASCII_UPPERCASE_LETTERS.test('z')).isFalse();
+ assertTrue(CharacterPredicates.ASCII_UPPERCASE_LETTERS.test('A'));
+ assertTrue(CharacterPredicates.ASCII_UPPERCASE_LETTERS.test('Z'));
+
+ assertFalse(CharacterPredicates.ASCII_UPPERCASE_LETTERS.test('9'));
+ assertFalse(CharacterPredicates.ASCII_UPPERCASE_LETTERS.test('@'));
+ assertFalse(CharacterPredicates.ASCII_UPPERCASE_LETTERS.test('['));
+ assertFalse(CharacterPredicates.ASCII_UPPERCASE_LETTERS.test('a'));
+ assertFalse(CharacterPredicates.ASCII_UPPERCASE_LETTERS.test('z'));
}
@Test
public void testDigits() {
- assertThat(CharacterPredicates.DIGITS.test('0')).isTrue();
- assertThat(CharacterPredicates.DIGITS.test('9')).isTrue();
+ assertTrue(CharacterPredicates.DIGITS.test('0'));
+ assertTrue(CharacterPredicates.DIGITS.test('9'));
- assertThat(CharacterPredicates.DIGITS.test('-')).isFalse();
- assertThat(CharacterPredicates.DIGITS.test('.')).isFalse();
- assertThat(CharacterPredicates.DIGITS.test('L')).isFalse();
+ assertFalse(CharacterPredicates.DIGITS.test('-'));
+ assertFalse(CharacterPredicates.DIGITS.test('.'));
+ assertFalse(CharacterPredicates.DIGITS.test('L'));
}
@Test
public void testLetters() {
- assertThat(CharacterPredicates.LETTERS.test('a')).isTrue();
- assertThat(CharacterPredicates.LETTERS.test('Z')).isTrue();
+ assertTrue(CharacterPredicates.LETTERS.test('a'));
+ assertTrue(CharacterPredicates.LETTERS.test('Z'));
- assertThat(CharacterPredicates.LETTERS.test('1')).isFalse();
- assertThat(CharacterPredicates.LETTERS.test('?')).isFalse();
- assertThat(CharacterPredicates.LETTERS.test('@')).isFalse();
+ assertFalse(CharacterPredicates.LETTERS.test('1'));
+ assertFalse(CharacterPredicates.LETTERS.test('?'));
+ assertFalse(CharacterPredicates.LETTERS.test('@'));
}
}
diff --git a/src/test/java/org/apache/commons/text/ExtendedMessageFormatTest.java b/src/test/java/org/apache/commons/text/ExtendedMessageFormatTest.java
index b718dcf5..20d6e4a8 100644
--- a/src/test/java/org/apache/commons/text/ExtendedMessageFormatTest.java
+++ b/src/test/java/org/apache/commons/text/ExtendedMessageFormatTest.java
@@ -16,10 +16,9 @@
*/
package org.apache.commons.text;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
import java.text.DateFormat;
import java.text.FieldPosition;
@@ -68,8 +67,7 @@ public class ExtendedMessageFormatTest {
private static final class OtherExtendedMessageFormat extends ExtendedMessageFormat {
private static final long serialVersionUID = 1L;
- OtherExtendedMessageFormat(final String pattern, final Locale locale,
- final Map<String, ? extends FormatFactory> registry) {
+ OtherExtendedMessageFormat(final String pattern, final Locale locale, final Map<String, ? extends FormatFactory> registry) {
super(pattern, locale, registry);
}
}
@@ -79,9 +77,7 @@ public class ExtendedMessageFormatTest {
*/
private static final class OverrideShortDateFormatFactory {
static final FormatFactory FACTORY = (n, a, l) -> !"short".equals(a) ? null
- : l == null ? DateFormat
- .getDateInstance(DateFormat.DEFAULT) : DateFormat
- .getDateInstance(DateFormat.DEFAULT, l);
+ : l == null ? DateFormat.getDateInstance(DateFormat.DEFAULT) : DateFormat.getDateInstance(DateFormat.DEFAULT, l);
}
/**
@@ -106,15 +102,14 @@ public class ExtendedMessageFormatTest {
private final Map<String, FormatFactory> registry = new HashMap<>();
/**
- * Create an ExtendedMessageFormat for the specified pattern and locale and check the
- * formatted output matches the expected result for the parameters.
- * @param pattern string
+ * Create an ExtendedMessageFormat for the specified pattern and locale and check the formatted output matches the expected result for the parameters.
+ *
+ * @param pattern string
* @param registryUnused map (currently unused)
- * @param args Object[]
- * @param locale Locale
+ * @param args Object[]
+ * @param locale Locale
*/
- private void checkBuiltInFormat(final String pattern, final Map<String, ?> registryUnused, final Object[] args,
- final Locale locale) {
+ private void checkBuiltInFormat(final String pattern, final Map<String, ?> registryUnused, final Object[] args, final Locale locale) {
final StringBuilder buffer = new StringBuilder();
buffer.append("Pattern=[");
buffer.append(pattern);
@@ -129,7 +124,7 @@ public class ExtendedMessageFormatTest {
} else {
emf = new ExtendedMessageFormat(pattern, locale);
}
- assertEquals(mf.format(args), emf.format(args), "format " + buffer.toString());
+ assertEquals(mf.format(args), emf.format(args), "format " + buffer.toString());
assertEquals(mf.toPattern(), emf.toPattern(), "toPattern " + buffer.toString());
}
@@ -190,13 +185,13 @@ public class ExtendedMessageFormatTest {
/**
* Test a built in format for the specified Locales, plus {@code null} Locale.
- * @param pattern MessageFormat pattern
+ *
+ * @param pattern MessageFormat pattern
* @param fmtRegistry FormatFactory registry to use
- * @param args MessageFormat arguments
- * @param locales to test
+ * @param args MessageFormat arguments
+ * @param locales to test
*/
- private void checkBuiltInFormat(final String pattern, final Map<String, ?> fmtRegistry, final Object[] args,
- final Locale[] locales) {
+ private void checkBuiltInFormat(final String pattern, final Map<String, ?> fmtRegistry, final Object[] args, final Locale[] locales) {
checkBuiltInFormat(pattern, fmtRegistry, args, (Locale) null);
for (final Locale locale : locales) {
checkBuiltInFormat(pattern, fmtRegistry, args, locale);
@@ -205,8 +200,9 @@ public class ExtendedMessageFormatTest {
/**
* Test a built in format for the specified Locales, plus {@code null} Locale.
+ *
* @param pattern MessageFormat pattern
- * @param args MessageFormat arguments
+ * @param args MessageFormat arguments
* @param locales to test
*/
private void checkBuiltInFormat(final String pattern, final Object[] args, final Locale[] locales) {
@@ -215,8 +211,9 @@ public class ExtendedMessageFormatTest {
/**
* Replace MessageFormat(String, Locale) constructor (not available until JDK 1.4).
+ *
* @param pattern string
- * @param locale Locale
+ * @param locale Locale
* @return MessageFormat
*/
private MessageFormat createMessageFormat(final String pattern, final Locale locale) {
@@ -239,18 +236,18 @@ public class ExtendedMessageFormatTest {
*/
@Test
public void testBuiltInChoiceFormat() {
- final Object[] values = new Number[] {1, Double.valueOf("2.2"), Double.valueOf("1234.5")};
+ final Object[] values = new Number[] { 1, Double.valueOf("2.2"), Double.valueOf("1234.5") };
String choicePattern;
final Locale[] availableLocales = NumberFormat.getAvailableLocales();
choicePattern = "{0,choice,1#One|2#Two|3#Many {0,number}}";
for (final Object value : values) {
- checkBuiltInFormat(value + ": " + choicePattern, new Object[] {value}, availableLocales);
+ checkBuiltInFormat(value + ": " + choicePattern, new Object[] { value }, availableLocales);
}
choicePattern = "{0,choice,1#''One''|2#\"Two\"|3#''{Many}'' {0,number}}";
for (final Object value : values) {
- checkBuiltInFormat(value + ": " + choicePattern, new Object[] {value}, availableLocales);
+ checkBuiltInFormat(value + ": " + choicePattern, new Object[] { value }, availableLocales);
}
}
@@ -261,21 +258,21 @@ public class ExtendedMessageFormatTest {
public void testBuiltInDateTimeFormat() {
final Calendar cal = Calendar.getInstance();
cal.set(2007, Calendar.JANUARY, 23, 18, 33, 5);
- final Object[] args = {cal.getTime()};
+ final Object[] args = { cal.getTime() };
final Locale[] availableLocales = DateFormat.getAvailableLocales();
- checkBuiltInFormat("1: {0,date,short}", args, availableLocales);
- checkBuiltInFormat("2: {0,date,medium}", args, availableLocales);
- checkBuiltInFormat("3: {0,date,long}", args, availableLocales);
- checkBuiltInFormat("4: {0,date,full}", args, availableLocales);
+ checkBuiltInFormat("1: {0,date,short}", args, availableLocales);
+ checkBuiltInFormat("2: {0,date,medium}", args, availableLocales);
+ checkBuiltInFormat("3: {0,date,long}", args, availableLocales);
+ checkBuiltInFormat("4: {0,date,full}", args, availableLocales);
checkBuiltInFormat("5: {0,date,d MMM yy}", args, availableLocales);
- checkBuiltInFormat("6: {0,time,short}", args, availableLocales);
- checkBuiltInFormat("7: {0,time,medium}", args, availableLocales);
- checkBuiltInFormat("8: {0,time,long}", args, availableLocales);
- checkBuiltInFormat("9: {0,time,full}", args, availableLocales);
- checkBuiltInFormat("10: {0,time,HH:mm}", args, availableLocales);
- checkBuiltInFormat("11: {0,date}", args, availableLocales);
- checkBuiltInFormat("12: {0,time}", args, availableLocales);
+ checkBuiltInFormat("6: {0,time,short}", args, availableLocales);
+ checkBuiltInFormat("7: {0,time,medium}", args, availableLocales);
+ checkBuiltInFormat("8: {0,time,long}", args, availableLocales);
+ checkBuiltInFormat("9: {0,time,full}", args, availableLocales);
+ checkBuiltInFormat("10: {0,time,HH:mm}", args, availableLocales);
+ checkBuiltInFormat("11: {0,date}", args, availableLocales);
+ checkBuiltInFormat("12: {0,time}", args, availableLocales);
}
/**
@@ -283,34 +280,31 @@ public class ExtendedMessageFormatTest {
*/
@Test
public void testBuiltInNumberFormat() {
- final Object[] args = {Double.valueOf("6543.21")};
+ final Object[] args = { Double.valueOf("6543.21") };
final Locale[] availableLocales = NumberFormat.getAvailableLocales();
- checkBuiltInFormat("1: {0,number}", args, availableLocales);
- checkBuiltInFormat("2: {0,number,integer}", args, availableLocales);
- checkBuiltInFormat("3: {0,number,currency}", args, availableLocales);
- checkBuiltInFormat("4: {0,number,percent}", args, availableLocales);
+ checkBuiltInFormat("1: {0,number}", args, availableLocales);
+ checkBuiltInFormat("2: {0,number,integer}", args, availableLocales);
+ checkBuiltInFormat("3: {0,number,currency}", args, availableLocales);
+ checkBuiltInFormat("4: {0,number,percent}", args, availableLocales);
checkBuiltInFormat("5: {0,number,00000.000}", args, availableLocales);
}
/**
- * Test Bug TEXT-106 - Exception while using ExtendedMessageFormat and choice format element with quote just
- * before brace end
+ * Test Bug TEXT-106 - Exception while using ExtendedMessageFormat and choice format element with quote just before brace end
*/
@Test
public void testChoiceQuoteJustBeforeBraceEnd_TEXT_106() {
final String pattern2 = "Choice format element with quote just before brace end ''{0,choice,0#0|0<'1'}''";
final ExtendedMessageFormat emf = new ExtendedMessageFormat(pattern2, registry);
- assertEquals("Choice format element with quote just before brace end '0'", emf.format(new Object[] {0}));
- assertEquals("Choice format element with quote just before brace end '1'", emf.format(new Object[] {1}));
+ assertEquals("Choice format element with quote just before brace end '0'", emf.format(new Object[] { 0 }));
+ assertEquals("Choice format element with quote just before brace end '1'", emf.format(new Object[] { 1 }));
}
@Test
public void testCreatesExtendedMessageFormatTakingString() {
- final ExtendedMessageFormat extendedMessageFormat =
- new ExtendedMessageFormat("Unterminated format element at position ");
+ final ExtendedMessageFormat extendedMessageFormat = new ExtendedMessageFormat("Unterminated format element at position ");
final Map<String, FormatFactory> map = new HashMap<>();
- final ExtendedMessageFormat extendedMessageFormatTwo =
- new ExtendedMessageFormat("Unterminated format element at position ", map);
+ final ExtendedMessageFormat extendedMessageFormatTwo = new ExtendedMessageFormat("Unterminated format element at position ", map);
assertEquals("Unterminated format element at position ", extendedMessageFormatTwo.toPattern());
assertNotEquals(extendedMessageFormat, extendedMessageFormatTwo);
@@ -323,7 +317,7 @@ public class ExtendedMessageFormatTest {
public void testEmbeddedPatternInChoice() {
final String pattern = "Hi {0,lower}, got {1,choice,0#none|1#one|1<{1,number}}, {2,upper}!";
final ExtendedMessageFormat emf = new ExtendedMessageFormat(pattern, registry);
- assertEquals("Hi there, got 3, GREAT!", emf.format(new Object[] {"there", 3, "great"}));
+ assertEquals("Hi there, got 3, GREAT!", emf.format(new Object[] { "there", 3, "great" }));
}
/**
@@ -331,10 +325,8 @@ public class ExtendedMessageFormatTest {
*/
@Test
public void testEqualsHashcode() {
- final Map<String, ? extends FormatFactory> fmtRegistry =
- Collections.singletonMap("testfmt", LowerCaseFormat.FACTORY);
- final Map<String, ? extends FormatFactory> otherRegistry =
- Collections.singletonMap("testfmt", UpperCaseFormat.FACTORY);
+ final Map<String, ? extends FormatFactory> fmtRegistry = Collections.singletonMap("testfmt", LowerCaseFormat.FACTORY);
+ final Map<String, ? extends FormatFactory> otherRegistry = Collections.singletonMap("testfmt", UpperCaseFormat.FACTORY);
final String pattern = "Pattern: {0,testfmt}";
final ExtendedMessageFormat emf = new ExtendedMessageFormat(pattern, Locale.US, fmtRegistry);
@@ -381,12 +373,12 @@ public class ExtendedMessageFormatTest {
// message without placeholder because braces are escaped by quotes
final String pattern = "Message without placeholders '{}'";
final ExtendedMessageFormat emf = new ExtendedMessageFormat(pattern, registry);
- assertEquals("Message without placeholders {}", emf.format(new Object[] {"DUMMY"}));
+ assertEquals("Message without placeholders {}", emf.format(new Object[] { "DUMMY" }));
// message with placeholder because quotes are escaped by quotes
final String pattern2 = "Message with placeholder ''{0}''";
final ExtendedMessageFormat emf2 = new ExtendedMessageFormat(pattern2, registry);
- assertEquals("Message with placeholder 'DUMMY'", emf2.format(new Object[] {"DUMMY"}));
+ assertEquals("Message with placeholder 'DUMMY'", emf2.format(new Object[] { "DUMMY" }));
}
/**
@@ -396,7 +388,7 @@ public class ExtendedMessageFormatTest {
public void testEscapedQuote_LANG_477() {
final String pattern = "it''s a {0,lower} 'test'!";
final ExtendedMessageFormat emf = new ExtendedMessageFormat(pattern, registry);
- assertEquals("it's a dummy test!", emf.format(new Object[] {"DUMMY"}));
+ assertEquals("it's a dummy test!", emf.format(new Object[] { "DUMMY" }));
}
/**
@@ -406,7 +398,7 @@ public class ExtendedMessageFormatTest {
public void testExtendedAndBuiltInFormats() {
final Calendar cal = Calendar.getInstance();
cal.set(2007, Calendar.JANUARY, 23, 18, 33, 5);
- final Object[] args = {"John Doe", cal.getTime(), Double.valueOf("12345.67")};
+ final Object[] args = { "John Doe", cal.getTime(), Double.valueOf("12345.67") };
final String builtinsPattern = "DOB: {1,date,short} Salary: {2,number,currency}";
final String extendedPattern = "Name: {0,upper} ";
final String pattern = extendedPattern + builtinsPattern;
@@ -450,36 +442,36 @@ public class ExtendedMessageFormatTest {
final String pattern = "Lower: {0,lower} Upper: {1,upper}";
final ExtendedMessageFormat emf = new ExtendedMessageFormat(pattern, registry);
assertEquals(pattern, emf.toPattern(), "TOPATTERN");
- assertEquals("Lower: foo Upper: BAR", emf.format(new Object[] {"foo", "bar"}));
- assertEquals("Lower: foo Upper: BAR", emf.format(new Object[] {"Foo", "Bar"}));
- assertEquals("Lower: foo Upper: BAR", emf.format(new Object[] {"FOO", "BAR"}));
- assertEquals("Lower: foo Upper: BAR", emf.format(new Object[] {"FOO", "bar"}));
- assertEquals("Lower: foo Upper: BAR", emf.format(new Object[] {"foo", "BAR"}));
+ assertEquals("Lower: foo Upper: BAR", emf.format(new Object[] { "foo", "bar" }));
+ assertEquals("Lower: foo Upper: BAR", emf.format(new Object[] { "Foo", "Bar" }));
+ assertEquals("Lower: foo Upper: BAR", emf.format(new Object[] { "FOO", "BAR" }));
+ assertEquals("Lower: foo Upper: BAR", emf.format(new Object[] { "FOO", "bar" }));
+ assertEquals("Lower: foo Upper: BAR", emf.format(new Object[] { "foo", "BAR" }));
}
@Test
public void testFailsToCreateExtendedMessageFormatTakingTwoArgumentsThrowsIllegalArgumentExceptionFive() {
- assertThatIllegalArgumentException().isThrownBy(() -> new ExtendedMessageFormat("j/[_D9{0,\"&'+0o", new HashMap<>()));
+ assertThrowsExactly(IllegalArgumentException.class, () -> new ExtendedMessageFormat("j/[_D9{0,\"&'+0o", new HashMap<>()));
}
@Test
public void testFailsToCreateExtendedMessageFormatTakingTwoArgumentsThrowsIllegalArgumentExceptionFour() {
- assertThatIllegalArgumentException().isThrownBy(() -> new ExtendedMessageFormat("RD,nXhM{}{", new HashMap<>()));
+ assertThrowsExactly(IllegalArgumentException.class, () -> new ExtendedMessageFormat("RD,nXhM{}{", new HashMap<>()));
}
@Test
public void testFailsToCreateExtendedMessageFormatTakingTwoArgumentsThrowsIllegalArgumentExceptionOne() {
- assertThatIllegalArgumentException().isThrownBy(() -> new ExtendedMessageFormat("agdXdkR;T1{9 ^,LzXf?", new HashMap<>()));
+ assertThrowsExactly(IllegalArgumentException.class, () -> new ExtendedMessageFormat("agdXdkR;T1{9 ^,LzXf?", new HashMap<>()));
}
@Test
public void testFailsToCreateExtendedMessageFormatTakingTwoArgumentsThrowsIllegalArgumentExceptionThree() {
- assertThatIllegalArgumentException().isThrownBy(() -> new ExtendedMessageFormat("9jLh_D9{ ", new HashMap<>()));
+ assertThrowsExactly(IllegalArgumentException.class, () -> new ExtendedMessageFormat("9jLh_D9{ ", new HashMap<>()));
}
@Test
public void testFailsToCreateExtendedMessageFormatTakingTwoArgumentsThrowsIllegalArgumentExceptionTwo() {
- assertThatIllegalArgumentException().isThrownBy(() -> new ExtendedMessageFormat("a5XdkR;T1{9 ,LzXf?", new HashMap<>()));
+ assertThrowsExactly(IllegalArgumentException.class, () -> new ExtendedMessageFormat("a5XdkR;T1{9 ,LzXf?", new HashMap<>()));
}
@Test
@@ -510,32 +502,24 @@ public class ExtendedMessageFormatTest {
@Test
public void testSetFormatByArgumentIndexIsUnsupported() {
- assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() -> {
- final ExtendedMessageFormat emf = new ExtendedMessageFormat("");
- emf.setFormatByArgumentIndex(0, new LowerCaseFormat());
- });
+ assertThrowsExactly(UnsupportedOperationException.class, () -> new ExtendedMessageFormat("").setFormatByArgumentIndex(0, new LowerCaseFormat()));
}
+
@Test
public void testSetFormatIsUnsupported() {
- assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() -> {
- final ExtendedMessageFormat emf = new ExtendedMessageFormat("");
- emf.setFormat(0, new LowerCaseFormat());
- });
+ assertThrowsExactly(UnsupportedOperationException.class, () -> new ExtendedMessageFormat("").setFormat(0, new LowerCaseFormat()));
}
+
@Test
public void testSetFormatsByArgumentIndex() {
- assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() -> {
- final ExtendedMessageFormat emf = new ExtendedMessageFormat("");
- emf.setFormatsByArgumentIndex(new Format[] {new LowerCaseFormat(), new UpperCaseFormat()});
- });
+ assertThrowsExactly(UnsupportedOperationException.class,
+ () -> new ExtendedMessageFormat("").setFormatsByArgumentIndex(new Format[] { new LowerCaseFormat(), new UpperCaseFormat() }));
}
@Test
public void testSetFormatsIsUnsupported() {
- assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() -> {
- final ExtendedMessageFormat emf = new ExtendedMessageFormat("");
- emf.setFormats(new Format[] {new LowerCaseFormat(), new UpperCaseFormat()});
- });
+ assertThrowsExactly(UnsupportedOperationException.class,
+ () -> new ExtendedMessageFormat("").setFormats(new Format[] { new LowerCaseFormat(), new UpperCaseFormat() }));
}
}
diff --git a/src/test/java/org/apache/commons/text/FormattableUtilsTest.java b/src/test/java/org/apache/commons/text/FormattableUtilsTest.java
index b6008ee1..483096a8 100644
--- a/src/test/java/org/apache/commons/text/FormattableUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/FormattableUtilsTest.java
@@ -17,9 +17,8 @@
package org.apache.commons.text;
import static java.util.FormattableFlags.LEFT_JUSTIFY;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
-import static org.assertj.core.api.Assertions.assertThatNullPointerException;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
import java.util.Formattable;
import java.util.Formatter;
@@ -51,98 +50,98 @@ public class FormattableUtilsTest {
@Test
public void testAlternatePadCharacter() {
final char pad = '_';
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, -1, -1, pad).toString()).isEqualTo("foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, -1, 2, pad).toString()).isEqualTo("fo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 4, -1, pad).toString()).isEqualTo("_foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 6, -1, pad).toString()).isEqualTo("___foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 3, 2, pad).toString()).isEqualTo("_fo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 5, 2, pad).toString()).isEqualTo("___fo");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 4, -1, pad).toString()).isEqualTo("foo_");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 6, -1, pad).toString()).isEqualTo("foo___");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 3, 2, pad).toString()).isEqualTo("fo_");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 5, 2, pad).toString()).isEqualTo("fo___");
+ assertEquals("foo", FormattableUtils.append("foo", createFormatter(), 0, -1, -1, pad).toString());
+ assertEquals("fo", FormattableUtils.append("foo", createFormatter(), 0, -1, 2, pad).toString());
+ assertEquals("_foo", FormattableUtils.append("foo", createFormatter(), 0, 4, -1, pad).toString());
+ assertEquals("___foo", FormattableUtils.append("foo", createFormatter(), 0, 6, -1, pad).toString());
+ assertEquals("_fo", FormattableUtils.append("foo", createFormatter(), 0, 3, 2, pad).toString());
+ assertEquals("___fo", FormattableUtils.append("foo", createFormatter(), 0, 5, 2, pad).toString());
+ assertEquals("foo_", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 4, -1, pad).toString());
+ assertEquals("foo___", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 6, -1, pad).toString());
+ assertEquals("fo_", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 3, 2, pad).toString());
+ assertEquals("fo___", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 5, 2, pad).toString());
}
@Test
public void testAlternatePadCharAndEllipsis() {
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, -1, -1, '_', "*").toString()).isEqualTo("foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, -1, 2, '_', "*").toString()).isEqualTo("f*");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 4, -1, '_', "*").toString()).isEqualTo("_foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 6, -1, '_', "*").toString()).isEqualTo("___foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 3, 2, '_', "*").toString()).isEqualTo("_f*");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 5, 2, '_', "*").toString()).isEqualTo("___f*");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 4, -1, '_', "*").toString()).isEqualTo("foo_");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 6, -1, '_', "*").toString()).isEqualTo("foo___");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 3, 2, '_', "*").toString()).isEqualTo("f*_");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 5, 2, '_', "*").toString()).isEqualTo("f*___");
-
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, -1, -1, '_', "+*").toString()).isEqualTo("foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, -1, 2, '_', "+*").toString()).isEqualTo("+*");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 4, -1, '_', "+*").toString()).isEqualTo("_foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 6, -1, '_', "+*").toString()).isEqualTo("___foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 3, 2, '_', "+*").toString()).isEqualTo("_+*");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 5, 2, '_', "+*").toString()).isEqualTo("___+*");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 4, -1, '_', "+*").toString()).isEqualTo("foo_");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 6, -1, '_', "+*").toString()).isEqualTo("foo___");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 3, 2, '_', "+*").toString()).isEqualTo("+*_");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 5, 2, '_', "+*").toString()).isEqualTo("+*___");
+ assertEquals("foo", FormattableUtils.append("foo", createFormatter(), 0, -1, -1, '_', "*").toString());
+ assertEquals("f*", FormattableUtils.append("foo", createFormatter(), 0, -1, 2, '_', "*").toString());
+ assertEquals("_foo", FormattableUtils.append("foo", createFormatter(), 0, 4, -1, '_', "*").toString());
+ assertEquals("___foo", FormattableUtils.append("foo", createFormatter(), 0, 6, -1, '_', "*").toString());
+ assertEquals("_f*", FormattableUtils.append("foo", createFormatter(), 0, 3, 2, '_', "*").toString());
+ assertEquals("___f*", FormattableUtils.append("foo", createFormatter(), 0, 5, 2, '_', "*").toString());
+ assertEquals("foo_", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 4, -1, '_', "*").toString());
+ assertEquals("foo___", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 6, -1, '_', "*").toString());
+ assertEquals("f*_", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 3, 2, '_', "*").toString());
+ assertEquals("f*___", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 5, 2, '_', "*").toString());
+
+ assertEquals("foo", FormattableUtils.append("foo", createFormatter(), 0, -1, -1, '_', "+*").toString());
+ assertEquals("+*", FormattableUtils.append("foo", createFormatter(), 0, -1, 2, '_', "+*").toString());
+ assertEquals("_foo", FormattableUtils.append("foo", createFormatter(), 0, 4, -1, '_', "+*").toString());
+ assertEquals("___foo", FormattableUtils.append("foo", createFormatter(), 0, 6, -1, '_', "+*").toString());
+ assertEquals("_+*", FormattableUtils.append("foo", createFormatter(), 0, 3, 2, '_', "+*").toString());
+ assertEquals("___+*", FormattableUtils.append("foo", createFormatter(), 0, 5, 2, '_', "+*").toString());
+ assertEquals("foo_", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 4, -1, '_', "+*").toString());
+ assertEquals("foo___", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 6, -1, '_', "+*").toString());
+ assertEquals("+*_", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 3, 2, '_', "+*").toString());
+ assertEquals("+*___", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 5, 2, '_', "+*").toString());
}
@Test
public void testAppendWithNullFormatterAndIntsThrowsNullPointerException() {
- assertThatNullPointerException().isThrownBy(() -> FormattableUtils.append("", null, 0, 0, 0, '}'));
+ assertThrowsExactly(NullPointerException.class, () -> FormattableUtils.append("", null, 0, 0, 0, '}'));
}
@Test
public void testDefaultAppend() {
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, -1, -1).toString()).isEqualTo("foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, -1, 2).toString()).isEqualTo("fo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 4, -1).toString()).isEqualTo(" foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 6, -1).toString()).isEqualTo(" foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 3, 2).toString()).isEqualTo(" fo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 5, 2).toString()).isEqualTo(" fo");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 4, -1).toString()).isEqualTo("foo ");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 6, -1).toString()).isEqualTo("foo ");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 3, 2).toString()).isEqualTo("fo ");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 5, 2).toString()).isEqualTo("fo ");
+ assertEquals("foo", FormattableUtils.append("foo", createFormatter(), 0, -1, -1).toString());
+ assertEquals("fo", FormattableUtils.append("foo", createFormatter(), 0, -1, 2).toString());
+ assertEquals(" foo", FormattableUtils.append("foo", createFormatter(), 0, 4, -1).toString());
+ assertEquals(" foo", FormattableUtils.append("foo", createFormatter(), 0, 6, -1).toString());
+ assertEquals(" fo", FormattableUtils.append("foo", createFormatter(), 0, 3, 2).toString());
+ assertEquals(" fo", FormattableUtils.append("foo", createFormatter(), 0, 5, 2).toString());
+ assertEquals("foo ", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 4, -1).toString());
+ assertEquals("foo ", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 6, -1).toString());
+ assertEquals("fo ", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 3, 2).toString());
+ assertEquals("fo ", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 5, 2).toString());
}
@Test
public void testEllipsis() {
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, -1, -1, "*").toString()).isEqualTo("foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, -1, 2, "*").toString()).isEqualTo("f*");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 4, -1, "*").toString()).isEqualTo(" foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 6, -1, "*").toString()).isEqualTo(" foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 3, 2, "*").toString()).isEqualTo(" f*");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 5, 2, "*").toString()).isEqualTo(" f*");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 4, -1, "*").toString()).isEqualTo("foo ");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 6, -1, "*").toString()).isEqualTo("foo ");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 3, 2, "*").toString()).isEqualTo("f* ");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 5, 2, "*").toString()).isEqualTo("f* ");
-
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, -1, -1, "+*").toString()).isEqualTo("foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, -1, 2, "+*").toString()).isEqualTo("+*");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 4, -1, "+*").toString()).isEqualTo(" foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 6, -1, "+*").toString()).isEqualTo(" foo");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 3, 2, "+*").toString()).isEqualTo(" +*");
- assertThat(FormattableUtils.append("foo", createFormatter(), 0, 5, 2, "+*").toString()).isEqualTo(" +*");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 4, -1, "+*").toString()).isEqualTo("foo ");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 6, -1, "+*").toString()).isEqualTo("foo ");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 3, 2, "+*").toString()).isEqualTo("+* ");
- assertThat(FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 5, 2, "+*").toString()).isEqualTo("+* ");
+ assertEquals("foo", FormattableUtils.append("foo", createFormatter(), 0, -1, -1, "*").toString());
+ assertEquals("f*", FormattableUtils.append("foo", createFormatter(), 0, -1, 2, "*").toString());
+ assertEquals(" foo", FormattableUtils.append("foo", createFormatter(), 0, 4, -1, "*").toString());
+ assertEquals(" foo", FormattableUtils.append("foo", createFormatter(), 0, 6, -1, "*").toString());
+ assertEquals(" f*", FormattableUtils.append("foo", createFormatter(), 0, 3, 2, "*").toString());
+ assertEquals(" f*", FormattableUtils.append("foo", createFormatter(), 0, 5, 2, "*").toString());
+ assertEquals("foo ", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 4, -1, "*").toString());
+ assertEquals("foo ", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 6, -1, "*").toString());
+ assertEquals("f* ", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 3, 2, "*").toString());
+ assertEquals("f* ", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 5, 2, "*").toString());
+
+ assertEquals("foo", FormattableUtils.append("foo", createFormatter(), 0, -1, -1, "+*").toString());
+ assertEquals("+*", FormattableUtils.append("foo", createFormatter(), 0, -1, 2, "+*").toString());
+ assertEquals(" foo", FormattableUtils.append("foo", createFormatter(), 0, 4, -1, "+*").toString());
+ assertEquals(" foo", FormattableUtils.append("foo", createFormatter(), 0, 6, -1, "+*").toString());
+ assertEquals(" +*", FormattableUtils.append("foo", createFormatter(), 0, 3, 2, "+*").toString());
+ assertEquals(" +*", FormattableUtils.append("foo", createFormatter(), 0, 5, 2, "+*").toString());
+ assertEquals("foo ", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 4, -1, "+*").toString());
+ assertEquals("foo ", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 6, -1, "+*").toString());
+ assertEquals("+* ", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 3, 2, "+*").toString());
+ assertEquals("+* ", FormattableUtils.append("foo", createFormatter(), LEFT_JUSTIFY, 5, 2, "+*").toString());
}
@Test
public void testIllegalEllipsis() {
- assertThatIllegalArgumentException().isThrownBy(() -> FormattableUtils.append("foo", createFormatter(), 0, -1, 1, "xx"));
+ assertThrowsExactly(IllegalArgumentException.class, () -> FormattableUtils.append("foo", createFormatter(), 0, -1, 1, "xx"));
}
@Test
public void testIllegalEllipsisWith7Args() {
final String ellipsis = "xxxx";
final int precisionLessThanEllipsisLength = ellipsis.length() - 1;
- assertThatIllegalArgumentException()
- .isThrownBy(() -> FormattableUtils.append("foo", createFormatter(), 0, 0, precisionLessThanEllipsisLength, '}', ellipsis));
+ assertThrowsExactly(IllegalArgumentException.class,
+ () -> FormattableUtils.append("foo", createFormatter(), 0, 0, precisionLessThanEllipsisLength, '}', ellipsis));
}
@Test
@@ -153,8 +152,7 @@ public class FormattableUtilsTest {
@Test
public void testSimplestFormat() {
final Formattable formattable = new SimplestFormattable("foo");
-
- assertThat(FormattableUtils.toString(formattable)).isEqualTo("foo");
+ assertEquals("foo", FormattableUtils.toString(formattable));
}
}
diff --git a/src/test/java/org/apache/commons/text/OssFuzzTest.java b/src/test/java/org/apache/commons/text/OssFuzzTest.java
index 85ee598a..0b4e1a55 100644
Binary files a/src/test/java/org/apache/commons/text/OssFuzzTest.java and b/src/test/java/org/apache/commons/text/OssFuzzTest.java differ
diff --git a/src/test/java/org/apache/commons/text/RandomStringGeneratorTest.java b/src/test/java/org/apache/commons/text/RandomStringGeneratorTest.java
index fa4b7830..8ac267a1 100644
--- a/src/test/java/org/apache/commons/text/RandomStringGeneratorTest.java
+++ b/src/test/java/org/apache/commons/text/RandomStringGeneratorTest.java
@@ -16,12 +16,11 @@
*/
package org.apache.commons.text;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
-import static org.assertj.core.api.Assertions.assertThatNullPointerException;
-import static org.assertj.core.api.Assertions.fail;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import org.apache.commons.text.RandomStringGenerator.Builder;
import org.junit.jupiter.api.Test;
@@ -41,27 +40,25 @@ public class RandomStringGeneratorTest {
@Test
public void testBadMaximumCodePoint() {
- assertThatIllegalArgumentException().isThrownBy(() -> RandomStringGenerator.builder().withinRange(0, Character.MAX_CODE_POINT + 1));
+ assertThrowsExactly(IllegalArgumentException.class, () -> RandomStringGenerator.builder().withinRange(0, Character.MAX_CODE_POINT + 1));
}
@Test
public void testBadMinAndMax() {
- assertThatIllegalArgumentException().isThrownBy(() -> RandomStringGenerator.builder().withinRange(2, 1));
+ assertThrowsExactly(IllegalArgumentException.class, () -> RandomStringGenerator.builder().withinRange(2, 1));
}
@Test
public void testBadMinimumCodePoint() {
- assertThatIllegalArgumentException().isThrownBy(() -> RandomStringGenerator.builder().withinRange(-1, 1));
+ assertThrowsExactly(IllegalArgumentException.class, () -> RandomStringGenerator.builder().withinRange(-1, 1));
}
@Test
public void testChangeOfFilter() {
- final RandomStringGenerator.Builder builder = RandomStringGenerator.builder().withinRange('a', 'z')
- .filteredBy(A_FILTER);
+ final RandomStringGenerator.Builder builder = RandomStringGenerator.builder().withinRange('a', 'z').filteredBy(A_FILTER);
final String str = builder.filteredBy(B_FILTER).build().generate(100);
-
for (final char c : str.toCharArray()) {
- assertThat(c == 'b').isTrue();
+ assertEquals('b', c);
}
}
@@ -71,12 +68,13 @@ public class RandomStringGeneratorTest {
final int maxLength = 3;
final RandomStringGenerator generator = RandomStringGenerator.builder().build();
final String str = generator.generate(minLength, maxLength);
- assertThat(codePointLength(str)).isBetween(0, 3);
+ final int codePointLength = codePointLength(str);
+ assertTrue(codePointLength > 0 && codePointLength < 3);
}
@Test
public void testGenerateMinMaxLengthInvalidLength() {
- assertThatIllegalArgumentException().isThrownBy(() -> {
+ assertThrowsExactly(IllegalArgumentException.class, () -> {
final RandomStringGenerator generator = RandomStringGenerator.builder().build();
generator.generate(-1, 0);
});
@@ -84,7 +82,7 @@ public class RandomStringGeneratorTest {
@Test
public void testGenerateMinMaxLengthMinGreaterThanMax() {
- assertThatIllegalArgumentException().isThrownBy(() -> {
+ assertThrowsExactly(IllegalArgumentException.class, () -> {
final RandomStringGenerator generator = RandomStringGenerator.builder().build();
generator.generate(1, 0);
});
@@ -92,28 +90,23 @@ public class RandomStringGeneratorTest {
@Test
public void testGenerateTakingIntThrowsNullPointerException() {
- assertThatNullPointerException().isThrownBy(() -> {
+ assertThrowsExactly(NullPointerException.class, () -> {
final RandomStringGenerator.Builder randomStringGeneratorBuilder = RandomStringGenerator.builder();
final CharacterPredicate[] characterPredicateArray = new CharacterPredicate[2];
randomStringGeneratorBuilder.filteredBy(characterPredicateArray);
final RandomStringGenerator randomStringGenerator = randomStringGeneratorBuilder.build();
-
randomStringGenerator.generate(18);
});
}
@Test
public void testInvalidLength() {
- assertThatIllegalArgumentException().isThrownBy(() -> {
- final RandomStringGenerator generator = RandomStringGenerator.builder().build();
- generator.generate(-1);
- });
+ assertThrowsExactly(IllegalArgumentException.class, () -> RandomStringGenerator.builder().build().generate(-1));
}
@Test
public void testMultipleFilters() {
- final String str = RandomStringGenerator.builder().withinRange('a', 'd')
- .filteredBy(A_FILTER, B_FILTER).build().generate(5000);
+ final String str = RandomStringGenerator.builder().withinRange('a', 'd').filteredBy(A_FILTER, B_FILTER).build().generate(5000);
boolean aFound = false;
boolean bFound = false;
@@ -128,7 +121,7 @@ public class RandomStringGeneratorTest {
}
}
- assertThat(aFound && bFound).isTrue();
+ assertTrue(aFound && bFound);
}
@Test
@@ -141,16 +134,16 @@ public class RandomStringGeneratorTest {
final char c = str.charAt(i);
if (Character.isLowSurrogate(c)) {
- assertThat(Character.isHighSurrogate(lastChar)).isTrue();
+ assertTrue(Character.isHighSurrogate(lastChar));
}
if (Character.isHighSurrogate(lastChar)) {
- assertThat(Character.isLowSurrogate(c)).isTrue();
+ assertTrue(Character.isLowSurrogate(c));
}
if (Character.isHighSurrogate(c)) {
// test this isn't the last character in the string
- assertThat(i + 1 < str.length()).isTrue();
+ assertTrue(i + 1 < str.length());
}
lastChar = c;
@@ -163,21 +156,20 @@ public class RandomStringGeneratorTest {
// Request a string in an area of the Basic Multilingual Plane that is
// largely occupied by private characters
- final String str = RandomStringGenerator.builder().withinRange(startOfPrivateBMPChars,
- Character.MIN_SUPPLEMENTARY_CODE_POINT - 1).build().generate(5000);
+ final String str = RandomStringGenerator.builder().withinRange(startOfPrivateBMPChars, Character.MIN_SUPPLEMENTARY_CODE_POINT - 1).build()
+ .generate(5000);
int i = 0;
do {
final int codePoint = str.codePointAt(i);
- assertThat(Character.getType(codePoint) == Character.PRIVATE_USE).isFalse();
+ assertFalse(Character.getType(codePoint) == Character.PRIVATE_USE);
i += Character.charCount(codePoint);
} while (i < str.length());
}
@Test
public void testRemoveFilters() {
- final RandomStringGenerator.Builder builder = RandomStringGenerator.builder().withinRange('a', 'z')
- .filteredBy(A_FILTER);
+ final RandomStringGenerator.Builder builder = RandomStringGenerator.builder().withinRange('a', 'z').filteredBy(A_FILTER);
builder.filteredBy();
@@ -201,7 +193,7 @@ public class RandomStringGeneratorTest {
final String randomText = generator.generate(5);
for (final char c : randomText.toCharArray()) {
- assertThat(str.indexOf(c) != -1).isTrue();
+ assertTrue(str.indexOf(c) != -1);
}
}
@@ -211,7 +203,7 @@ public class RandomStringGeneratorTest {
final RandomStringGenerator generator = RandomStringGenerator.builder().selectFrom('a', 'b', 'c').build();
final String randomText = generator.generate(5);
for (final char c : randomText.toCharArray()) {
- assertThat(str.indexOf(c) != -1).isTrue();
+ assertTrue(str.indexOf(c) != -1);
}
}
@@ -230,7 +222,7 @@ public class RandomStringGeneratorTest {
// @formatter:on
final String randomText = generator.generate(10);
for (final char c : randomText.toCharArray()) {
- assertThat(str.indexOf(c) != -1).isTrue();
+ assertTrue(str.indexOf(c) != -1);
}
}
@@ -257,7 +249,7 @@ public class RandomStringGeneratorTest {
final int length = 5;
RandomStringGenerator generator = RandomStringGenerator.builder().selectFrom(null).build();
String randomText = generator.generate(length);
- assertThat(codePointLength(randomText)).isEqualTo(length);
+ assertEquals(length, codePointLength(randomText));
for (final char c : randomText.toCharArray()) {
assertTrue(c >= Character.MIN_CODE_POINT && c <= Character.MAX_CODE_POINT);
}
@@ -271,7 +263,7 @@ public class RandomStringGeneratorTest {
// null input resets
generator = builder.selectFrom(null).build();
randomText = generator.generate(length);
- assertThat(codePointLength(randomText)).isEqualTo(length);
+ assertEquals(length, codePointLength(randomText));
for (final char c : randomText.toCharArray()) {
assertTrue(c >= Character.MIN_CODE_POINT && c <= Character.MAX_CODE_POINT);
}
@@ -282,7 +274,7 @@ public class RandomStringGeneratorTest {
final int length = 99;
final RandomStringGenerator generator = RandomStringGenerator.builder().build();
final String str = generator.generate(length);
- assertThat(codePointLength(str)).isEqualTo(length);
+ assertEquals(length, codePointLength(str));
}
@Test
@@ -292,14 +284,14 @@ public class RandomStringGeneratorTest {
final String str = RandomStringGenerator.builder().usingRandom(testRandom).build().generate(10);
for (final char c : str.toCharArray()) {
- assertThat(c).isEqualTo(testChar);
+ assertEquals(testChar, c);
}
}
@Test
public void testWithinMultipleRanges() {
final int length = 5000;
- final char[][] pairs = {{'a', 'z'}, {'0', '9'}};
+ final char[][] pairs = { { 'a', 'z' }, { '0', '9' } };
// @formatter:off
final RandomStringGenerator generator = RandomStringGenerator.builder()
.withinRange()
@@ -319,7 +311,7 @@ public class RandomStringGeneratorTest {
int i = 0;
do {
final int codePoint = str.codePointAt(i);
- assertThat(codePoint >= minimumCodePoint && codePoint <= maximumCodePoint).isTrue();
+ assertTrue(codePoint >= minimumCodePoint && codePoint <= maximumCodePoint);
i += Character.charCount(codePoint);
} while (i < str.length());
}
@@ -329,14 +321,13 @@ public class RandomStringGeneratorTest {
final int length = 5000;
final int minimumCodePoint = 'a';
final int maximumCodePoint = 'z';
- final RandomStringGenerator generator = RandomStringGenerator.builder()
- .withinRange(minimumCodePoint, maximumCodePoint).build();
+ final RandomStringGenerator generator = RandomStringGenerator.builder().withinRange(minimumCodePoint, maximumCodePoint).build();
final String str = generator.generate(length);
int i = 0;
do {
final int codePoint = str.codePointAt(i);
- assertThat(codePoint >= minimumCodePoint && codePoint <= maximumCodePoint).isTrue();
+ assertTrue(codePoint >= minimumCodePoint && codePoint <= maximumCodePoint);
i += Character.charCount(codePoint);
} while (i < str.length());
}
@@ -344,6 +335,6 @@ public class RandomStringGeneratorTest {
@Test
public void testZeroLength() {
final RandomStringGenerator generator = RandomStringGenerator.builder().build();
- assertThat(generator.generate(0)).isEqualTo("");
+ assertEquals("", generator.generate(0));
}
}
diff --git a/src/test/java/org/apache/commons/text/StrBuilderAppendInsertTest.java b/src/test/java/org/apache/commons/text/StrBuilderAppendInsertTest.java
index 5652f576..b826f16c 100644
--- a/src/test/java/org/apache/commons/text/StrBuilderAppendInsertTest.java
+++ b/src/test/java/org/apache/commons/text/StrBuilderAppendInsertTest.java
@@ -17,9 +17,9 @@
package org.apache.commons.text;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.fail;
import java.text.DecimalFormatSymbols;
import java.util.Arrays;
@@ -53,86 +53,86 @@ public class StrBuilderAppendInsertTest {
public void testAppend_Boolean() {
final StrBuilder sb = new StrBuilder();
sb.append(true);
- assertThat(sb.toString()).isEqualTo("true");
+ assertEquals("true", sb.toString());
sb.append(false);
- assertThat(sb.toString()).isEqualTo("truefalse");
+ assertEquals("truefalse", sb.toString());
sb.append('!');
- assertThat(sb.toString()).isEqualTo("truefalse!");
+ assertEquals("truefalse!", sb.toString());
}
@Test
public void testAppend_CharArray() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((char[]) null);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new StrBuilder();
sb.append(ArrayUtils.EMPTY_CHAR_ARRAY);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
- sb.append(new char[]{'f', 'o', 'o'});
- assertThat(sb.toString()).isEqualTo("foo");
+ sb.append(new char[] { 'f', 'o', 'o' });
+ assertEquals("foo", sb.toString());
}
@Test
public void testAppend_CharArray_int_int() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((char[]) null, 0, 1);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new StrBuilder();
- sb.append(new char[]{'f', 'o', 'o'}, 0, 3);
- assertThat(sb.toString()).isEqualTo("foo");
+ sb.append(new char[] { 'f', 'o', 'o' }, 0, 3);
+ assertEquals("foo", sb.toString());
try {
- sb.append(new char[]{'b', 'a', 'r'}, -1, 1);
+ sb.append(new char[] { 'b', 'a', 'r' }, -1, 1);
fail("append(char[], -1,) expected IndexOutOfBoundsException");
} catch (final IndexOutOfBoundsException e) {
// expected
}
try {
- sb.append(new char[]{'b', 'a', 'r'}, 3, 1);
+ sb.append(new char[] { 'b', 'a', 'r' }, 3, 1);
fail("append(char[], 3,) expected IndexOutOfBoundsException");
} catch (final IndexOutOfBoundsException e) {
// expected
}
try {
- sb.append(new char[]{'b', 'a', 'r'}, 1, -1);
+ sb.append(new char[] { 'b', 'a', 'r' }, 1, -1);
fail("append(char[],, -1) expected IndexOutOfBoundsException");
} catch (final IndexOutOfBoundsException e) {
// expected
}
try {
- sb.append(new char[]{'b', 'a', 'r'}, 1, 3);
+ sb.append(new char[] { 'b', 'a', 'r' }, 1, 3);
fail("append(char[], 1, 3) expected IndexOutOfBoundsException");
} catch (final IndexOutOfBoundsException e) {
// expected
}
try {
- sb.append(new char[]{'b', 'a', 'r'}, -1, 3);
+ sb.append(new char[] { 'b', 'a', 'r' }, -1, 3);
fail("append(char[], -1, 3) expected IndexOutOfBoundsException");
} catch (final IndexOutOfBoundsException e) {
// expected
}
try {
- sb.append(new char[]{'b', 'a', 'r'}, 4, 0);
+ sb.append(new char[] { 'b', 'a', 'r' }, 4, 0);
fail("append(char[], 4, 0) expected IndexOutOfBoundsException");
} catch (final IndexOutOfBoundsException e) {
// expected
}
- sb.append(new char[]{'b', 'a', 'r'}, 3, 0);
- assertThat(sb.toString()).isEqualTo("foo");
+ sb.append(new char[] { 'b', 'a', 'r' }, 3, 0);
+ assertEquals("foo", sb.toString());
- sb.append(new char[]{'a', 'b', 'c', 'b', 'a', 'r', 'd', 'e', 'f'}, 3, 3);
- assertThat(sb.toString()).isEqualTo("foobar");
+ sb.append(new char[] { 'a', 'b', 'c', 'b', 'a', 'r', 'd', 'e', 'f' }, 3, 3);
+ assertEquals("foobar", sb.toString());
}
@Test
@@ -141,94 +141,94 @@ public class StrBuilderAppendInsertTest {
sb = new StrBuilder();
sb.append("Hi", (Object[]) null);
- assertThat(sb.toString()).isEqualTo("Hi");
+ assertEquals("Hi", sb.toString());
sb = new StrBuilder();
sb.append("Hi", "Alice");
- assertThat(sb.toString()).isEqualTo("Hi");
+ assertEquals("Hi", sb.toString());
sb = new StrBuilder();
sb.append("Hi %s", "Alice");
- assertThat(sb.toString()).isEqualTo("Hi Alice");
+ assertEquals("Hi Alice", sb.toString());
sb = new StrBuilder();
sb.append("Hi %s %,d", "Alice", 5000);
// group separator depends on system locale
final char groupingSeparator = DecimalFormatSymbols.getInstance().getGroupingSeparator();
final String expected = "Hi Alice 5" + groupingSeparator + "000";
- assertThat(sb.toString()).isEqualTo(expected);
+ assertEquals(expected, sb.toString());
}
@Test
public void testAppend_Object() {
final StrBuilder sb = new StrBuilder();
sb.appendNull();
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.append((Object) null);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.append(FOO);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append((StringBuffer) null);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StringBuffer("baz"));
- assertThat(sb.toString()).isEqualTo("foobaz");
+ assertEquals("foobaz", sb.toString());
sb.append(new StrBuilder("yes"));
- assertThat(sb.toString()).isEqualTo("foobazyes");
+ assertEquals("foobazyes", sb.toString());
sb.append((CharSequence) "Seq");
- assertThat(sb.toString()).isEqualTo("foobazyesSeq");
+ assertEquals("foobazyesSeq", sb.toString());
sb.append(new StringBuilder("bld")); // Check it supports StringBuilder
- assertThat(sb.toString()).isEqualTo("foobazyesSeqbld");
+ assertEquals("foobazyesSeqbld", sb.toString());
}
@Test
public void testAppend_PrimitiveNumber() {
final StrBuilder sb = new StrBuilder();
sb.append(0);
- assertThat(sb.toString()).isEqualTo("0");
+ assertEquals("0", sb.toString());
sb.append(1L);
- assertThat(sb.toString()).isEqualTo("01");
+ assertEquals("01", sb.toString());
sb.append(2.3f);
- assertThat(sb.toString()).isEqualTo("012.3");
+ assertEquals("012.3", sb.toString());
sb.append(4.5d);
- assertThat(sb.toString()).isEqualTo("012.34.5");
+ assertEquals("012.34.5", sb.toString());
}
@Test
public void testAppend_StrBuilder() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((StrBuilder) null);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new StrBuilder();
sb.append(new StrBuilder("foo"));
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StrBuilder(""));
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StrBuilder("bar"));
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
}
@Test
public void testAppend_StrBuilder_int_int() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((StrBuilder) null, 0, 1);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new StrBuilder();
sb.append(new StrBuilder("foo"), 0, 3);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
try {
sb.append(new StrBuilder("bar"), -1, 1);
@@ -273,38 +273,38 @@ public class StrBuilderAppendInsertTest {
}
sb.append(new StrBuilder("bar"), 3, 0);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StrBuilder("abcbardef"), 3, 3);
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
}
@Test
public void testAppend_String() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((String) null);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new StrBuilder();
sb.append("foo");
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append("");
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append("bar");
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
}
@Test
public void testAppend_String_int_int() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((String) null, 0, 1);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new StrBuilder();
sb.append("foo", 0, 3);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
try {
sb.append("bar", -1, 1);
@@ -349,41 +349,41 @@ public class StrBuilderAppendInsertTest {
}
sb.append("bar", 3, 0);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append("abcbardef", 3, 3);
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
sb.append((CharSequence) "abcbardef", 4, 3);
- assertThat(sb.toString()).isEqualTo("foobarard");
+ assertEquals("foobarard", sb.toString());
}
@Test
public void testAppend_StringBuffer() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((StringBuffer) null);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new StrBuilder();
sb.append(new StringBuffer("foo"));
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StringBuffer(""));
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StringBuffer("bar"));
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
}
@Test
public void testAppend_StringBuffer_int_int() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((StringBuffer) null, 0, 1);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new StrBuilder();
sb.append(new StringBuffer("foo"), 0, 3);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
try {
sb.append(new StringBuffer("bar"), -1, 1);
@@ -428,38 +428,38 @@ public class StrBuilderAppendInsertTest {
}
sb.append(new StringBuffer("bar"), 3, 0);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StringBuffer("abcbardef"), 3, 3);
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
}
@Test
public void testAppend_StringBuilder() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((String) null);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new StrBuilder();
sb.append(new StringBuilder("foo"));
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StringBuilder(""));
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StringBuilder("bar"));
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
}
@Test
public void testAppend_StringBuilder_int_int() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((String) null, 0, 1);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new StrBuilder();
sb.append(new StringBuilder("foo"), 0, 3);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
try {
sb.append(new StringBuilder("bar"), -1, 1);
@@ -504,215 +504,215 @@ public class StrBuilderAppendInsertTest {
}
sb.append(new StringBuilder("bar"), 3, 0);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StringBuilder("abcbardef"), 3, 3);
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
sb.append(new StringBuilder("abcbardef"), 4, 3);
- assertThat(sb.toString()).isEqualTo("foobarard");
+ assertEquals("foobarard", sb.toString());
}
@Test
public void testAppendAll_Array() {
final StrBuilder sb = new StrBuilder();
sb.appendAll((Object[]) null);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendAll();
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendAll("foo", "bar", "baz");
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.appendAll("foo", "bar", "baz");
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
}
@Test
public void testAppendAll_Collection() {
final StrBuilder sb = new StrBuilder();
sb.appendAll((Collection<?>) null);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendAll(Collections.EMPTY_LIST);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendAll(Arrays.asList("foo", "bar", "baz"));
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
}
@Test
public void testAppendAll_Iterator() {
final StrBuilder sb = new StrBuilder();
sb.appendAll((Iterator<?>) null);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendAll(Collections.EMPTY_LIST.iterator());
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendAll(Arrays.asList("foo", "bar", "baz").iterator());
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
}
@Test
public void testAppendFixedWidthPadLeft() {
final StrBuilder sb = new StrBuilder();
sb.appendFixedWidthPadLeft("foo", -1, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft("foo", 0, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft("foo", 1, '-');
- assertThat(sb.toString()).isEqualTo("o");
+ assertEquals("o", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft("foo", 2, '-');
- assertThat(sb.toString()).isEqualTo("oo");
+ assertEquals("oo", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft("foo", 3, '-');
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft("foo", 4, '-');
- assertThat(sb.toString()).isEqualTo("-foo");
+ assertEquals("-foo", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft("foo", 10, '-');
- assertThat(sb.length()).isEqualTo(10);
- // 1234567890
- assertThat(sb.toString()).isEqualTo("-------foo");
+ assertEquals(10, sb.length());
+ // 1234567890
+ assertEquals("-------foo", sb.toString());
sb.clear();
sb.setNullText("null");
sb.appendFixedWidthPadLeft(null, 5, '-');
- assertThat(sb.toString()).isEqualTo("-null");
+ assertEquals("-null", sb.toString());
}
@Test
public void testAppendFixedWidthPadLeft_int() {
final StrBuilder sb = new StrBuilder();
sb.appendFixedWidthPadLeft(123, -1, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft(123, 0, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft(123, 1, '-');
- assertThat(sb.toString()).isEqualTo("3");
+ assertEquals("3", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft(123, 2, '-');
- assertThat(sb.toString()).isEqualTo("23");
+ assertEquals("23", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft(123, 3, '-');
- assertThat(sb.toString()).isEqualTo("123");
+ assertEquals("123", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft(123, 4, '-');
- assertThat(sb.toString()).isEqualTo("-123");
+ assertEquals("-123", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft(123, 10, '-');
- assertThat(sb.length()).isEqualTo(10);
- // 1234567890
- assertThat(sb.toString()).isEqualTo("-------123");
+ assertEquals(10, sb.length());
+ // 1234567890
+ assertEquals("-------123", sb.toString());
}
@Test
public void testAppendFixedWidthPadRight() {
final StrBuilder sb = new StrBuilder();
sb.appendFixedWidthPadRight("foo", -1, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight("foo", 0, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight("foo", 1, '-');
- assertThat(sb.toString()).isEqualTo("f");
+ assertEquals("f", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight("foo", 2, '-');
- assertThat(sb.toString()).isEqualTo("fo");
+ assertEquals("fo", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight("foo", 3, '-');
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight("foo", 4, '-');
- assertThat(sb.toString()).isEqualTo("foo-");
+ assertEquals("foo-", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight("foo", 10, '-');
- assertThat(sb.length()).isEqualTo(10);
- // 1234567890
- assertThat(sb.toString()).isEqualTo("foo-------");
+ assertEquals(10, sb.length());
+ // 1234567890
+ assertEquals("foo-------", sb.toString());
sb.clear();
sb.setNullText("null");
sb.appendFixedWidthPadRight(null, 5, '-');
- assertThat(sb.toString()).isEqualTo("null-");
+ assertEquals("null-", sb.toString());
}
@Test
public void testAppendFixedWidthPadRight_int() {
final StrBuilder sb = new StrBuilder();
sb.appendFixedWidthPadRight(123, -1, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight(123, 0, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight(123, 1, '-');
- assertThat(sb.toString()).isEqualTo("1");
+ assertEquals("1", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight(123, 2, '-');
- assertThat(sb.toString()).isEqualTo("12");
+ assertEquals("12", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight(123, 3, '-');
- assertThat(sb.toString()).isEqualTo("123");
+ assertEquals("123", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight(123, 4, '-');
- assertThat(sb.toString()).isEqualTo("123-");
+ assertEquals("123-", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight(123, 10, '-');
- assertThat(sb.length()).isEqualTo(10);
- // 1234567890
- assertThat(sb.toString()).isEqualTo("123-------");
+ assertEquals(10, sb.length());
+ // 1234567890
+ assertEquals("123-------", sb.toString());
}
@Test
public void testAppendln_Boolean() {
final StrBuilder sb = new StrBuilder();
sb.appendln(true);
- assertThat(sb.toString()).isEqualTo("true" + SEP);
+ assertEquals("true" + SEP, sb.toString());
sb.clear();
sb.appendln(false);
- assertThat(sb.toString()).isEqualTo("false" + SEP);
+ assertEquals("false" + SEP, sb.toString());
}
@Test
@@ -726,6 +726,7 @@ public class StrBuilderAppendInsertTest {
count[0]++;
return super.append(str);
}
+
@Override
public StrBuilder appendNewLine() {
count[1]++;
@@ -733,9 +734,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln("foo".toCharArray());
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
- assertThat(count[0]).isEqualTo(1);
- assertThat(count[1]).isEqualTo(1);
+ assertEquals("foo" + SEP, sb.toString());
+ assertEquals(1, count[0]);
+ assertEquals(1, count[1]);
}
@Test
@@ -749,6 +750,7 @@ public class StrBuilderAppendInsertTest {
count[0]++;
return super.append(str, startIndex, length);
}
+
@Override
public StrBuilder appendNewLine() {
count[1]++;
@@ -756,9 +758,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln("foo".toCharArray(), 0, 3);
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
- assertThat(count[0]).isEqualTo(1);
- assertThat(count[1]).isEqualTo(1);
+ assertEquals("foo" + SEP, sb.toString());
+ assertEquals(1, count[0]);
+ assertEquals(1, count[1]);
}
@Test
@@ -772,6 +774,7 @@ public class StrBuilderAppendInsertTest {
count[0]++;
return super.append(str);
}
+
@Override
public StrBuilder appendNewLine() {
count[1]++;
@@ -779,41 +782,41 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln("Hello %s", "Alice");
- assertThat(sb.toString()).isEqualTo("Hello Alice" + SEP);
- assertThat(count[0]).isEqualTo(2); // appendNewLine() calls append(String)
- assertThat(count[1]).isEqualTo(1);
+ assertEquals("Hello Alice" + SEP, sb.toString());
+ assertEquals(2, count[0]); // appendNewLine() calls append(String)
+ assertEquals(1, count[1]);
}
@Test
public void testAppendln_Object() {
final StrBuilder sb = new StrBuilder();
sb.appendln((Object) null);
- assertThat(sb.toString()).isEqualTo("" + SEP);
+ assertEquals("" + SEP, sb.toString());
sb.appendln(FOO);
- assertThat(sb.toString()).isEqualTo(SEP + "foo" + SEP);
+ assertEquals(SEP + "foo" + SEP, sb.toString());
sb.appendln(Integer.valueOf(6));
- assertThat(sb.toString()).isEqualTo(SEP + "foo" + SEP + "6" + SEP);
+ assertEquals(SEP + "foo" + SEP + "6" + SEP, sb.toString());
}
@Test
public void testAppendln_PrimitiveNumber() {
final StrBuilder sb = new StrBuilder();
sb.appendln(0);
- assertThat(sb.toString()).isEqualTo("0" + SEP);
+ assertEquals("0" + SEP, sb.toString());
sb.clear();
sb.appendln(1L);
- assertThat(sb.toString()).isEqualTo("1" + SEP);
+ assertEquals("1" + SEP, sb.toString());
sb.clear();
sb.appendln(2.3f);
- assertThat(sb.toString()).isEqualTo("2.3" + SEP);
+ assertEquals("2.3" + SEP, sb.toString());
sb.clear();
sb.appendln(4.5d);
- assertThat(sb.toString()).isEqualTo("4.5" + SEP);
+ assertEquals("4.5" + SEP, sb.toString());
}
@Test
@@ -827,6 +830,7 @@ public class StrBuilderAppendInsertTest {
count[0]++;
return super.append(str);
}
+
@Override
public StrBuilder appendNewLine() {
count[1]++;
@@ -834,9 +838,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln(new StrBuilder("foo"));
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
- assertThat(count[0]).isEqualTo(1);
- assertThat(count[1]).isEqualTo(1);
+ assertEquals("foo" + SEP, sb.toString());
+ assertEquals(1, count[0]);
+ assertEquals(1, count[1]);
}
@Test
@@ -850,6 +854,7 @@ public class StrBuilderAppendInsertTest {
count[0]++;
return super.append(str, startIndex, length);
}
+
@Override
public StrBuilder appendNewLine() {
count[1]++;
@@ -857,9 +862,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln(new StrBuilder("foo"), 0, 3);
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
- assertThat(count[0]).isEqualTo(1);
- assertThat(count[1]).isEqualTo(1);
+ assertEquals("foo" + SEP, sb.toString());
+ assertEquals(1, count[0]);
+ assertEquals(1, count[1]);
}
@Test
@@ -873,6 +878,7 @@ public class StrBuilderAppendInsertTest {
count[0]++;
return super.append(str);
}
+
@Override
public StrBuilder appendNewLine() {
count[1]++;
@@ -880,9 +886,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln("foo");
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
- assertThat(count[0]).isEqualTo(2); // appendNewLine() calls append(String)
- assertThat(count[1]).isEqualTo(1);
+ assertEquals("foo" + SEP, sb.toString());
+ assertEquals(2, count[0]); // appendNewLine() calls append(String)
+ assertEquals(1, count[1]);
}
@Test
@@ -896,6 +902,7 @@ public class StrBuilderAppendInsertTest {
count[0]++;
return super.append(str, startIndex, length);
}
+
@Override
public StrBuilder appendNewLine() {
count[1]++;
@@ -903,9 +910,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln("foo", 0, 3);
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
- assertThat(count[0]).isEqualTo(1);
- assertThat(count[1]).isEqualTo(1);
+ assertEquals("foo" + SEP, sb.toString());
+ assertEquals(1, count[0]);
+ assertEquals(1, count[1]);
}
@Test
@@ -919,6 +926,7 @@ public class StrBuilderAppendInsertTest {
count[0]++;
return super.append(str);
}
+
@Override
public StrBuilder appendNewLine() {
count[1]++;
@@ -926,9 +934,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln(new StringBuffer("foo"));
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
- assertThat(count[0]).isEqualTo(1);
- assertThat(count[1]).isEqualTo(1);
+ assertEquals("foo" + SEP, sb.toString());
+ assertEquals(1, count[0]);
+ assertEquals(1, count[1]);
}
@Test
@@ -942,6 +950,7 @@ public class StrBuilderAppendInsertTest {
count[0]++;
return super.append(str, startIndex, length);
}
+
@Override
public StrBuilder appendNewLine() {
count[1]++;
@@ -949,9 +958,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln(new StringBuffer("foo"), 0, 3);
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
- assertThat(count[0]).isEqualTo(1);
- assertThat(count[1]).isEqualTo(1);
+ assertEquals("foo" + SEP, sb.toString());
+ assertEquals(1, count[0]);
+ assertEquals(1, count[1]);
}
@Test
@@ -965,6 +974,7 @@ public class StrBuilderAppendInsertTest {
count[0]++;
return super.append(str);
}
+
@Override
public StrBuilder appendNewLine() {
count[1]++;
@@ -972,9 +982,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln(new StringBuilder("foo"));
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
- assertThat(count[0]).isEqualTo(1);
- assertThat(count[1]).isEqualTo(1);
+ assertEquals("foo" + SEP, sb.toString());
+ assertEquals(1, count[0]);
+ assertEquals(1, count[1]);
}
@Test
@@ -988,6 +998,7 @@ public class StrBuilderAppendInsertTest {
count[0]++;
return super.append(str, startIndex, length);
}
+
@Override
public StrBuilder appendNewLine() {
count[1]++;
@@ -995,52 +1006,52 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln(new StringBuilder("foo"), 0, 3);
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
- assertThat(count[0]).isEqualTo(1);
- assertThat(count[1]).isEqualTo(1);
+ assertEquals("foo" + SEP, sb.toString());
+ assertEquals(1, count[0]);
+ assertEquals(1, count[1]);
}
@Test
public void testAppendNewLine() {
StrBuilder sb = new StrBuilder("---");
sb.appendNewLine().append("+++");
- assertThat(sb.toString()).isEqualTo("---" + SEP + "+++");
+ assertEquals("---" + SEP + "+++", sb.toString());
sb = new StrBuilder("---");
sb.setNewLineText("#").appendNewLine().setNewLineText(null).appendNewLine();
- assertThat(sb.toString()).isEqualTo("---#" + SEP);
+ assertEquals("---#" + SEP, sb.toString());
}
@Test
public void testAppendPadding() {
final StrBuilder sb = new StrBuilder();
sb.append("foo");
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.appendPadding(-1, '-');
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.appendPadding(0, '-');
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.appendPadding(1, '-');
- assertThat(sb.toString()).isEqualTo("foo-");
+ assertEquals("foo-", sb.toString());
sb.appendPadding(16, '-');
- assertThat(sb.length()).isEqualTo(20);
- // 12345678901234567890
- assertThat(sb.toString()).isEqualTo("foo-----------------");
+ assertEquals(20, sb.length());
+ // 12345678901234567890
+ assertEquals("foo-----------------", sb.toString());
}
@Test
public void testAppendSeparator_char() {
final StrBuilder sb = new StrBuilder();
- sb.appendSeparator(','); // no effect
- assertThat(sb.toString()).isEqualTo("");
+ sb.appendSeparator(','); // no effect
+ assertEquals("", sb.toString());
sb.append("foo");
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.appendSeparator(',');
- assertThat(sb.toString()).isEqualTo("foo,");
+ assertEquals("foo,", sb.toString());
}
@Test
@@ -1049,51 +1060,51 @@ public class StrBuilderAppendInsertTest {
final char startSeparator = ':';
final char standardSeparator = ',';
final String foo = "foo";
- sb.appendSeparator(standardSeparator, startSeparator); // no effect
- assertThat(sb.toString()).isEqualTo(String.valueOf(startSeparator));
+ sb.appendSeparator(standardSeparator, startSeparator); // no effect
+ assertEquals(String.valueOf(startSeparator), sb.toString());
sb.append(foo);
- assertThat(sb.toString()).isEqualTo(String.valueOf(startSeparator) + foo);
+ assertEquals(String.valueOf(startSeparator) + foo, sb.toString());
sb.appendSeparator(standardSeparator, startSeparator);
- assertThat(sb.toString()).isEqualTo(String.valueOf(startSeparator) + foo + standardSeparator);
+ assertEquals(String.valueOf(startSeparator) + foo + standardSeparator, sb.toString());
}
@Test
public void testAppendSeparator_char_int() {
final StrBuilder sb = new StrBuilder();
- sb.appendSeparator(',', 0); // no effect
- assertThat(sb.toString()).isEqualTo("");
+ sb.appendSeparator(',', 0); // no effect
+ assertEquals("", sb.toString());
sb.append("foo");
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.appendSeparator(',', 1);
- assertThat(sb.toString()).isEqualTo("foo,");
+ assertEquals("foo,", sb.toString());
- sb.appendSeparator(',', -1); // no effect
- assertThat(sb.toString()).isEqualTo("foo,");
+ sb.appendSeparator(',', -1); // no effect
+ assertEquals("foo,", sb.toString());
}
@Test
public void testAppendSeparator_String() {
final StrBuilder sb = new StrBuilder();
- sb.appendSeparator(","); // no effect
- assertThat(sb.toString()).isEqualTo("");
+ sb.appendSeparator(","); // no effect
+ assertEquals("", sb.toString());
sb.append("foo");
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.appendSeparator(",");
- assertThat(sb.toString()).isEqualTo("foo,");
+ assertEquals("foo,", sb.toString());
}
@Test
public void testAppendSeparator_String_int() {
final StrBuilder sb = new StrBuilder();
- sb.appendSeparator(",", 0); // no effect
- assertThat(sb.toString()).isEqualTo("");
+ sb.appendSeparator(",", 0); // no effect
+ assertEquals("", sb.toString());
sb.append("foo");
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.appendSeparator(",", 1);
- assertThat(sb.toString()).isEqualTo("foo,");
+ assertEquals("foo,", sb.toString());
- sb.appendSeparator(",", -1); // no effect
- assertThat(sb.toString()).isEqualTo("foo,");
+ sb.appendSeparator(",", -1); // no effect
+ assertEquals("foo,", sb.toString());
}
@Test
@@ -1103,130 +1114,131 @@ public class StrBuilderAppendInsertTest {
final String standardSeparator = ",";
final String foo = "foo";
sb.appendSeparator(null, null);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.appendSeparator(standardSeparator, null);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.appendSeparator(standardSeparator, startSeparator);
- assertThat(sb.toString()).isEqualTo(startSeparator);
+ assertEquals(startSeparator, sb.toString());
sb.appendSeparator(null, null);
- assertThat(sb.toString()).isEqualTo(startSeparator);
+ assertEquals(startSeparator, sb.toString());
sb.appendSeparator(null, startSeparator);
- assertThat(sb.toString()).isEqualTo(startSeparator);
+ assertEquals(startSeparator, sb.toString());
sb.append(foo);
- assertThat(sb.toString()).isEqualTo(startSeparator + foo);
+ assertEquals(startSeparator + foo, sb.toString());
sb.appendSeparator(standardSeparator, startSeparator);
- assertThat(sb.toString()).isEqualTo(startSeparator + foo + standardSeparator);
+ assertEquals(startSeparator + foo + standardSeparator, sb.toString());
}
@Test
public void testAppendWithNullText() {
final StrBuilder sb = new StrBuilder();
sb.setNullText("NULL");
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.appendNull();
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb.append((Object) null);
- assertThat(sb.toString()).isEqualTo("NULLNULL");
+ assertEquals("NULLNULL", sb.toString());
sb.append(FOO);
- assertThat(sb.toString()).isEqualTo("NULLNULLfoo");
+ assertEquals("NULLNULLfoo", sb.toString());
sb.append((String) null);
- assertThat(sb.toString()).isEqualTo("NULLNULLfooNULL");
+ assertEquals("NULLNULLfooNULL", sb.toString());
sb.append("");
- assertThat(sb.toString()).isEqualTo("NULLNULLfooNULL");
+ assertEquals("NULLNULLfooNULL", sb.toString());
sb.append("bar");
- assertThat(sb.toString()).isEqualTo("NULLNULLfooNULLbar");
+ assertEquals("NULLNULLfooNULLbar", sb.toString());
sb.append((StringBuffer) null);
- assertThat(sb.toString()).isEqualTo("NULLNULLfooNULLbarNULL");
+ assertEquals("NULLNULLfooNULLbarNULL", sb.toString());
sb.append(new StringBuffer("baz"));
- assertThat(sb.toString()).isEqualTo("NULLNULLfooNULLbarNULLbaz");
+ assertEquals("NULLNULLfooNULLbarNULLbaz", sb.toString());
}
@Test
public void testAppendWithSeparators_Array() {
final StrBuilder sb = new StrBuilder();
sb.appendWithSeparators((Object[]) null, ",");
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendWithSeparators(ArrayUtils.EMPTY_OBJECT_ARRAY, ",");
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
- sb.appendWithSeparators(new Object[]{"foo", "bar", "baz"}, ",");
- assertThat(sb.toString()).isEqualTo("foo,bar,baz");
+ sb.appendWithSeparators(new Object[] { "foo", "bar", "baz" }, ",");
+ assertEquals("foo,bar,baz", sb.toString());
sb.clear();
- sb.appendWithSeparators(new Object[]{"foo", "bar", "baz"}, null);
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ sb.appendWithSeparators(new Object[] { "foo", "bar", "baz" }, null);
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
- sb.appendWithSeparators(new Object[]{"foo", null, "baz"}, ",");
- assertThat(sb.toString()).isEqualTo("foo,,baz");
+ sb.appendWithSeparators(new Object[] { "foo", null, "baz" }, ",");
+ assertEquals("foo,,baz", sb.toString());
}
@Test
public void testAppendWithSeparators_Collection() {
final StrBuilder sb = new StrBuilder();
sb.appendWithSeparators((Collection<?>) null, ",");
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendWithSeparators(Collections.EMPTY_LIST, ",");
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz"), ",");
- assertThat(sb.toString()).isEqualTo("foo,bar,baz");
+ assertEquals("foo,bar,baz", sb.toString());
sb.clear();
sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz"), null);
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.appendWithSeparators(Arrays.asList("foo", null, "baz"), ",");
- assertThat(sb.toString()).isEqualTo("foo,,baz");
+ assertEquals("foo,,baz", sb.toString());
}
+
@Test
public void testAppendWithSeparators_Iterator() {
final StrBuilder sb = new StrBuilder();
sb.appendWithSeparators((Iterator<?>) null, ",");
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendWithSeparators(Collections.EMPTY_LIST.iterator(), ",");
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz").iterator(), ",");
- assertThat(sb.toString()).isEqualTo("foo,bar,baz");
+ assertEquals("foo,bar,baz", sb.toString());
sb.clear();
sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz").iterator(), null);
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.appendWithSeparators(Arrays.asList("foo", null, "baz").iterator(), ",");
- assertThat(sb.toString()).isEqualTo("foo,,baz");
+ assertEquals("foo,,baz", sb.toString());
}
@Test
public void testAppendWithSeparatorsWithNullText() {
final StrBuilder sb = new StrBuilder();
sb.setNullText("null");
- sb.appendWithSeparators(new Object[]{"foo", null, "baz"}, ",");
- assertThat(sb.toString()).isEqualTo("foo,null,baz");
+ sb.appendWithSeparators(new Object[] { "foo", null, "baz" }, ",");
+ assertEquals("foo,null,baz", sb.toString());
sb.clear();
sb.appendWithSeparators(Arrays.asList("foo", null, "baz"), ",");
- assertThat(sb.toString()).isEqualTo("foo,null,baz");
+ assertEquals("foo,null,baz", sb.toString());
}
@Test
@@ -1234,151 +1246,145 @@ public class StrBuilderAppendInsertTest {
final StrBuilder sb = new StrBuilder();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, FOO));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, FOO));
sb.insert(0, (Object) null);
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
sb.insert(0, FOO);
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, "foo"));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, "foo"));
sb.insert(0, (String) null);
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
sb.insert(0, "foo");
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
- assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, new char[]{'f', 'o', 'o'}));
+ assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, new char[] { 'f', 'o', 'o' }));
- assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, new char[]{'f', 'o', 'o'}));
+ assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, new char[] { 'f', 'o', 'o' }));
sb.insert(0, (char[]) null);
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
sb.insert(0, ArrayUtils.EMPTY_CHAR_ARRAY);
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
- sb.insert(0, new char[]{'f', 'o', 'o'});
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ sb.insert(0, new char[] { 'f', 'o', 'o' });
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
- assertThrows(IndexOutOfBoundsException.class,
- () -> sb.insert(-1, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 3, 3));
+ assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 3, 3));
- assertThrows(IndexOutOfBoundsException.class,
- () -> sb.insert(7, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 3, 3));
+ assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 3, 3));
sb.insert(0, (char[]) null, 0, 0);
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
sb.insert(0, ArrayUtils.EMPTY_CHAR_ARRAY, 0, 0);
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
- assertThrows(IndexOutOfBoundsException.class,
- () -> sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, -1, 3));
+ assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, -1, 3));
- assertThrows(IndexOutOfBoundsException.class,
- () -> sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 10, 3));
+ assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 10, 3));
- assertThrows(IndexOutOfBoundsException.class,
- () -> sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 0, -1));
+ assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 0, -1));
- assertThrows(IndexOutOfBoundsException.class,
- () -> sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 0, 10));
+ assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 0, 10));
- sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 0, 0);
- assertThat(sb.toString()).isEqualTo("barbaz");
+ sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 0, 0);
+ assertEquals("barbaz", sb.toString());
- sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 3, 3);
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 3, 3);
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, true));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, true));
sb.insert(0, true);
- assertThat(sb.toString()).isEqualTo("truebarbaz");
+ assertEquals("truebarbaz", sb.toString());
sb.insert(0, false);
- assertThat(sb.toString()).isEqualTo("falsetruebarbaz");
+ assertEquals("falsetruebarbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, '!'));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, '!'));
sb.insert(0, '!');
- assertThat(sb.toString()).isEqualTo("!barbaz");
+ assertEquals("!barbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, 0));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, 0));
sb.insert(0, '0');
- assertThat(sb.toString()).isEqualTo("0barbaz");
+ assertEquals("0barbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, 1L));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, 1L));
sb.insert(0, 1L);
- assertThat(sb.toString()).isEqualTo("1barbaz");
+ assertEquals("1barbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, 2.3F));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, 2.3F));
sb.insert(0, 2.3F);
- assertThat(sb.toString()).isEqualTo("2.3barbaz");
+ assertEquals("2.3barbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, 4.5D));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, 4.5D));
sb.insert(0, 4.5D);
- assertThat(sb.toString()).isEqualTo("4.5barbaz");
+ assertEquals("4.5barbaz", sb.toString());
}
@Test
@@ -1386,37 +1392,37 @@ public class StrBuilderAppendInsertTest {
final StrBuilder sb = new StrBuilder();
sb.setNullText("null");
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, FOO));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, FOO));
sb.insert(0, (Object) null);
- assertThat(sb.toString()).isEqualTo("nullbarbaz");
+ assertEquals("nullbarbaz", sb.toString());
sb.insert(0, FOO);
- assertThat(sb.toString()).isEqualTo("foonullbarbaz");
+ assertEquals("foonullbarbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, "foo"));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, "foo"));
sb.insert(0, (String) null);
- assertThat(sb.toString()).isEqualTo("nullbarbaz");
+ assertEquals("nullbarbaz", sb.toString());
sb.insert(0, "foo");
- assertThat(sb.toString()).isEqualTo("foonullbarbaz");
+ assertEquals("foonullbarbaz", sb.toString());
sb.insert(0, (char[]) null);
- assertThat(sb.toString()).isEqualTo("nullfoonullbarbaz");
+ assertEquals("nullfoonullbarbaz", sb.toString());
sb.insert(0, (char[]) null, 0, 0);
- assertThat(sb.toString()).isEqualTo("nullnullfoonullbarbaz");
+ assertEquals("nullnullfoonullbarbaz", sb.toString());
}
/** See: https://issues.apache.org/jira/browse/LANG-299 */
@@ -1424,6 +1430,6 @@ public class StrBuilderAppendInsertTest {
public void testLang299() {
final StrBuilder sb = new StrBuilder(1);
sb.appendFixedWidthPadRight("foo", 1, '-');
- assertThat(sb.toString()).isEqualTo("f");
+ assertEquals("f", sb.toString());
}
}
diff --git a/src/test/java/org/apache/commons/text/StrBuilderTest.java b/src/test/java/org/apache/commons/text/StrBuilderTest.java
index 24ee1a02..54799953 100644
--- a/src/test/java/org/apache/commons/text/StrBuilderTest.java
+++ b/src/test/java/org/apache/commons/text/StrBuilderTest.java
@@ -17,8 +17,6 @@
package org.apache.commons.text;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-import static org.assertj.core.api.Assertions.fail;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -29,6 +27,7 @@ import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.IOException;
import java.io.Reader;
@@ -84,7 +83,7 @@ public class StrBuilderTest {
assertFalse(sb.equals(other));
}
- @Test
+ @Test
public void testAppendCharBuffer() {
final StrBuilder sb1 = new StrBuilder();
final CharBuffer buf = CharBuffer.allocate(10);
@@ -180,22 +179,20 @@ public class StrBuilderTest {
@Test
public void testAppendTakingTwoIntsWithIndexOutOfBoundsThrowsStringIndexOutOfBoundsExceptionTwo() {
- assertThatExceptionOfType(StringIndexOutOfBoundsException.class).isThrownBy(() -> {
+ assertThrows(StringIndexOutOfBoundsException.class, () -> {
final Charset charset = Charset.defaultCharset();
final ByteBuffer byteBuffer = charset.encode("asdf");
final CharBuffer charBuffer = charset.decode(byteBuffer);
-
new StrBuilder().append(charBuffer, 933, 654);
});
}
@Test
public void testAppendTakingTwoIntsWithZeroThrowsStringIndexOutOfBoundsException() {
- assertThatExceptionOfType(StringIndexOutOfBoundsException.class).isThrownBy(() -> {
+ assertThrows(StringIndexOutOfBoundsException.class, () -> {
final Charset charset = Charset.defaultCharset();
final ByteBuffer byteBuffer = charset.encode("end < start");
final CharBuffer charBuffer = charset.decode(byteBuffer);
-
new StrBuilder(630).append(charBuffer, 0, 630);
});
}
@@ -233,7 +230,7 @@ public class StrBuilderTest {
assertEquals("Test 1234567890", builder.toString());
}
- @Test
+ @Test
public void testAppendToWriter() throws Exception {
final StrBuilder sb = new StrBuilder("1234567890");
final StringWriter writer = new StringWriter();
@@ -250,7 +247,7 @@ public class StrBuilderTest {
assertEquals(sb.toString(), sb.build());
}
- @Test
+ @Test
public void testAsReader() throws Exception {
final StrBuilder sb = new StrBuilder("some text");
try (Reader reader = sb.asReader()) {
@@ -333,7 +330,7 @@ public class StrBuilderTest {
}
}
- @Test
+ @Test
public void testAsTokenizer() throws Exception {
// from Javadoc
final StrBuilder b = new StrBuilder();
@@ -371,7 +368,7 @@ public class StrBuilderTest {
assertEquals("a b c d ", t.getContent());
}
- @Test
+ @Test
public void testAsWriter() throws Exception {
final StrBuilder sb = new StrBuilder("base");
try (Writer writer = sb.asWriter()) {
@@ -379,10 +376,10 @@ public class StrBuilderTest {
writer.write('l');
assertEquals("basel", sb.toString());
- writer.write(new char[] {'i', 'n'});
+ writer.write(new char[] { 'i', 'n' });
assertEquals("baselin", sb.toString());
- writer.write(new char[] {'n', 'e', 'r'}, 1, 2);
+ writer.write(new char[] { 'n', 'e', 'r' }, 1, 2);
assertEquals("baseliner", sb.toString());
writer.write(" rout");
@@ -406,7 +403,7 @@ public class StrBuilderTest {
}
}
- @Test
+ @Test
public void testCapacity() {
final StrBuilder sb = new StrBuilder();
assertEquals(sb.buffer.length, sb.capacity());
@@ -415,7 +412,7 @@ public class StrBuilderTest {
assertEquals(sb.buffer.length, sb.capacity());
}
- @Test
+ @Test
public void testCapacityAndLength() {
final StrBuilder sb = new StrBuilder();
assertEquals(32, sb.capacity());
@@ -494,7 +491,7 @@ public class StrBuilderTest {
assertTrue(sb.isEmpty());
}
- @Test
+ @Test
public void testChaining() {
final StrBuilder sb = new StrBuilder();
assertSame(sb, sb.setNewLineText(null));
@@ -508,7 +505,7 @@ public class StrBuilderTest {
assertSame(sb, sb.trim());
}
- @Test
+ @Test
public void testCharAt() {
final StrBuilder sb = new StrBuilder();
assertThrows(IndexOutOfBoundsException.class, () -> sb.charAt(0));
@@ -530,7 +527,7 @@ public class StrBuilderTest {
assertTrue(sb.buffer.length >= 5);
}
- @Test
+ @Test
public void testConstructors() {
final StrBuilder sb0 = new StrBuilder();
assertEquals(32, sb0.capacity());
@@ -573,7 +570,7 @@ public class StrBuilderTest {
assertEquals(3, sb7.size());
}
- @Test
+ @Test
public void testContains_char() {
final StrBuilder sb = new StrBuilder("abcdefghijklmnopqrstuvwxyz");
assertTrue(sb.contains('a'));
@@ -607,7 +604,7 @@ public class StrBuilderTest {
assertTrue(sb.contains(A_NUMBER_MATCHER));
}
- @Test
+ @Test
public void testDeleteAll_char() {
StrBuilder sb = new StrBuilder("abcbccba");
sb.deleteAll('X');
@@ -624,7 +621,7 @@ public class StrBuilderTest {
assertEquals("", sb.toString());
}
- @Test
+ @Test
public void testDeleteAll_String() {
StrBuilder sb = new StrBuilder("abcbccba");
sb.deleteAll((String) null);
@@ -650,7 +647,7 @@ public class StrBuilderTest {
assertEquals("", sb.toString());
}
- @Test
+ @Test
public void testDeleteAll_StrMatcher() {
StrBuilder sb = new StrBuilder("A0xA1A2yA3");
sb.deleteAll((StrMatcher) null);
@@ -667,7 +664,7 @@ public class StrBuilderTest {
assertEquals("", sb.toString());
}
- @Test
+ @Test
public void testDeleteCharAt() {
final StrBuilder sb = new StrBuilder("abc");
sb.deleteCharAt(0);
@@ -678,7 +675,7 @@ public class StrBuilderTest {
@Test
public void testDeleteCharAtWithNegative() {
- assertThatExceptionOfType(StringIndexOutOfBoundsException.class).isThrownBy(() -> new StrBuilder().deleteCharAt(-1258));
+ assertThrows(StringIndexOutOfBoundsException.class, () -> new StrBuilder().deleteCharAt(-1258));
}
@Test
@@ -741,7 +738,7 @@ public class StrBuilderTest {
assertEquals("", sb.toString());
}
- @Test
+ @Test
public void testDeleteIntInt() {
final StrBuilder sb = new StrBuilder("abc");
sb.delete(0, 1);
@@ -790,7 +787,7 @@ public class StrBuilderTest {
assertTrue(sb.capacity() >= 40);
}
- @Test
+ @Test
public void testEquals() {
final StrBuilder sb1 = new StrBuilder();
final StrBuilder sb2 = new StrBuilder();
@@ -815,7 +812,7 @@ public class StrBuilderTest {
assertNotEquals("abc", sb1);
}
- @Test
+ @Test
public void testEqualsIgnoreCase() {
final StrBuilder sb1 = new StrBuilder();
final StrBuilder sb2 = new StrBuilder();
@@ -850,7 +847,7 @@ public class StrBuilderTest {
sb.append("junit");
a = sb.getChars(input);
assertSame(input, a);
- assertArrayEquals(new char[] {'j', 'u', 'n', 'i', 't', 0, 0, 0, 0, 0 }, a);
+ assertArrayEquals(new char[] { 'j', 'u', 'n', 'i', 't', 0, 0, 0, 0, 0 }, a);
a = sb.getChars(null);
assertNotSame(input, a);
@@ -873,11 +870,11 @@ public class StrBuilderTest {
sb.append("junit");
char[] a = new char[5];
sb.getChars(0, 5, a, 0);
- assertArrayEquals(new char[] {'j', 'u', 'n', 'i', 't' }, a);
+ assertArrayEquals(new char[] { 'j', 'u', 'n', 'i', 't' }, a);
a = new char[5];
sb.getChars(0, 2, a, 3);
- assertArrayEquals(new char[] {0, 0, 0, 'j', 'u' }, a);
+ assertArrayEquals(new char[] { 0, 0, 0, 'j', 'u' }, a);
try {
sb.getChars(-1, 0, a, 0);
@@ -908,7 +905,7 @@ public class StrBuilderTest {
}
}
- @Test
+ @Test
public void testGetSetNewLineText() {
final StrBuilder sb = new StrBuilder();
assertNull(sb.getNewLineText());
@@ -923,7 +920,7 @@ public class StrBuilderTest {
assertNull(sb.getNewLineText());
}
- @Test
+ @Test
public void testGetSetNullText() {
final StrBuilder sb = new StrBuilder();
assertNull(sb.getNullText());
@@ -941,7 +938,7 @@ public class StrBuilderTest {
assertNull(sb.getNullText());
}
- @Test
+ @Test
public void testHashCode() {
final StrBuilder sb = new StrBuilder();
final int hc1a = sb.hashCode();
@@ -956,7 +953,7 @@ public class StrBuilderTest {
assertEquals(hc2a, hc2b);
}
- @Test
+ @Test
public void testIndexOf_char() {
final StrBuilder sb = new StrBuilder("abab");
assertEquals(0, sb.indexOf('a'));
@@ -992,7 +989,7 @@ public class StrBuilderTest {
assertEquals(-1, sb.indexOf('z', 3));
}
- @Test
+ @Test
public void testIndexOf_String() {
final StrBuilder sb = new StrBuilder("abab");
@@ -1052,7 +1049,7 @@ public class StrBuilderTest {
assertEquals(-1, sb.indexOf((String) null, 2));
}
- @Test
+ @Test
public void testIndexOf_StrMatcher() {
final StrBuilder sb = new StrBuilder();
assertEquals(-1, sb.indexOf((StrMatcher) null));
@@ -1129,14 +1126,14 @@ public class StrBuilderTest {
assertTrue(sb.isEmpty());
}
- @Test
+ @Test
public void testLang294() {
final StrBuilder sb = new StrBuilder("\n%BLAH%\nDo more stuff\neven more stuff\n%BLAH%\n");
sb.deleteAll("\n%BLAH%");
assertEquals("\nDo more stuff\neven more stuff\n", sb.toString());
}
- @Test
+ @Test
public void testLang295() {
final StrBuilder sb = new StrBuilder("onetwothree");
sb.deleteFirst("three");
@@ -1151,7 +1148,7 @@ public class StrBuilderTest {
assertEquals("**********", sb.toString(), "Failed to invoke appendFixedWidthPadLeft correctly");
}
- @Test
+ @Test
public void testLang412Right() {
final StrBuilder sb = new StrBuilder();
sb.appendFixedWidthPadRight(null, 10, '*');
@@ -1324,7 +1321,7 @@ public class StrBuilderTest {
assertEquals("left right", sb.leftString(15));
}
- @Test
+ @Test
public void testLength() {
final StrBuilder sb = new StrBuilder();
assertEquals(0, sb.length());
@@ -1333,7 +1330,7 @@ public class StrBuilderTest {
assertEquals(5, sb.length());
}
- @Test
+ @Test
public void testMidString() {
final StrBuilder sb = new StrBuilder("hello goodbye hello");
assertEquals("goodbye", sb.midString(6, 7));
@@ -1397,7 +1394,7 @@ public class StrBuilderTest {
assertEquals("Test 123", sb.toString());
}
- @Test
+ @Test
public void testReadFromReader() throws Exception {
String s = "";
for (int i = 0; i < 100; ++i) {
@@ -1418,7 +1415,7 @@ public class StrBuilderTest {
assertEquals("Test 123", sb.toString());
}
- @Test
+ @Test
public void testReplace_int_int_String() {
StrBuilder sb = new StrBuilder("abc");
sb.replace(0, 1, "d");
@@ -1546,7 +1543,7 @@ public class StrBuilderTest {
assertEquals("aaxaaaayaa", sb.toString());
}
- @Test
+ @Test
public void testReplace_StrMatcher_String_int_int_int_VaryMatcher() {
StrBuilder sb = new StrBuilder("abcbccba");
sb.replace((StrMatcher) null, "x", 0, sb.length(), -1);
@@ -1655,7 +1652,7 @@ public class StrBuilderTest {
assertEquals("aaxaaaayaa", sb.toString());
}
- @Test
+ @Test
public void testReplaceAll_char_char() {
final StrBuilder sb = new StrBuilder("abcbccba");
sb.replaceAll('x', 'y');
@@ -1670,7 +1667,7 @@ public class StrBuilderTest {
assertEquals("defeffed", sb.toString());
}
- @Test
+ @Test
public void testReplaceAll_String_String() {
StrBuilder sb = new StrBuilder("abcbccba");
sb.replaceAll((String) null, null);
@@ -1700,7 +1697,7 @@ public class StrBuilderTest {
assertEquals("xbxxbx", sb.toString());
}
- @Test
+ @Test
public void testReplaceAll_StrMatcher_String() {
StrBuilder sb = new StrBuilder("abcbccba");
sb.replaceAll((StrMatcher) null, null);
@@ -1738,7 +1735,7 @@ public class StrBuilderTest {
assertEquals("Dear 012345678901234567, hello 012345678901234567.", sb.toString());
}
- @Test
+ @Test
public void testReplaceFirst_char_char() {
final StrBuilder sb = new StrBuilder("abcbccba");
sb.replaceFirst('x', 'y');
@@ -1817,7 +1814,7 @@ public class StrBuilderTest {
assertEquals("***-A2A3-A4", sb.toString());
}
- @Test
+ @Test
public void testReverse() {
final StrBuilder sb = new StrBuilder();
assertEquals("", sb.reverse().toString());
@@ -1836,7 +1833,7 @@ public class StrBuilderTest {
assertEquals("left right", sb.rightString(15));
}
- @Test
+ @Test
public void testSetCharAt() {
final StrBuilder sb = new StrBuilder();
assertThrows(IndexOutOfBoundsException.class, () -> sb.setCharAt(0, 'f'));
@@ -1863,7 +1860,7 @@ public class StrBuilderTest {
assertThrows(IndexOutOfBoundsException.class, () -> sb.setLength(-1));
}
- @Test
+ @Test
public void testSize() {
final StrBuilder sb = new StrBuilder();
assertEquals(0, sb.size());
@@ -1872,7 +1869,7 @@ public class StrBuilderTest {
assertEquals(5, sb.size());
}
- @Test
+ @Test
public void testStartsWith() {
final StrBuilder sb = new StrBuilder();
assertFalse(sb.startsWith("a"));
@@ -1885,7 +1882,7 @@ public class StrBuilderTest {
assertFalse(sb.startsWith("cba"));
}
- @Test
+ @Test
public void testSubSequenceIntInt() {
final StrBuilder sb = new StrBuilder("hello goodbye");
// Start index is negative
@@ -1935,7 +1932,7 @@ public class StrBuilderTest {
assertThrows(IndexOutOfBoundsException.class, () -> sb.substring(15, 20));
}
- @Test
+ @Test
public void testToCharArray() {
final StrBuilder sb = new StrBuilder();
assertEquals(0, sb.toCharArray().length);
@@ -1976,13 +1973,13 @@ public class StrBuilderTest {
assertThrows(IndexOutOfBoundsException.class, () -> sb.toCharArray(6, 5));
}
- @Test
+ @Test
public void testToString() {
final StrBuilder sb = new StrBuilder("abc");
assertEquals("abc", sb.toString());
}
- @Test
+ @Test
public void testToStringBuffer() {
final StrBuilder sb = new StrBuilder();
assertEquals(new StringBuffer().toString(), sb.toStringBuffer().toString());
@@ -1991,7 +1988,7 @@ public class StrBuilderTest {
assertEquals(new StringBuffer("junit").toString(), sb.toStringBuffer().toString());
}
- @Test
+ @Test
public void testToStringBuilder() {
final StrBuilder sb = new StrBuilder();
assertEquals(new StringBuilder().toString(), sb.toStringBuilder().toString());
@@ -2000,7 +1997,7 @@ public class StrBuilderTest {
assertEquals(new StringBuilder("junit").toString(), sb.toStringBuilder().toString());
}
- @Test
+ @Test
public void testTrim() {
final StrBuilder sb = new StrBuilder();
assertEquals("", sb.reverse().toString());
diff --git a/src/test/java/org/apache/commons/text/StrMatcherTest.java b/src/test/java/org/apache/commons/text/StrMatcherTest.java
index d2398538..f70a8d01 100644
--- a/src/test/java/org/apache/commons/text/StrMatcherTest.java
+++ b/src/test/java/org/apache/commons/text/StrMatcherTest.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.text;
-import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
import org.junit.jupiter.api.Test;
@@ -48,57 +48,57 @@ public class StrMatcherTest {
@Test
public void testCharMatcher_char() {
final StrMatcher matcher = StrMatcher.charMatcher('c');
- assertThat(matcher.isMatch(BUFFER2, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 1)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 2)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 5)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(BUFFER2, 0));
+ assertEquals(0, matcher.isMatch(BUFFER2, 1));
+ assertEquals(1, matcher.isMatch(BUFFER2, 2));
+ assertEquals(0, matcher.isMatch(BUFFER2, 3));
+ assertEquals(0, matcher.isMatch(BUFFER2, 4));
+ assertEquals(0, matcher.isMatch(BUFFER2, 5));
}
@Test
public void testCharSetMatcher_charArray() {
final StrMatcher matcher = StrMatcher.charSetMatcher("ace".toCharArray());
- assertThat(matcher.isMatch(BUFFER2, 0)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 1)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 2)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 4)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 5)).isEqualTo(0);
- assertThat(StrMatcher.charSetMatcher()).isSameAs(StrMatcher.noneMatcher());
- assertThat(StrMatcher.charSetMatcher((char[]) null)).isSameAs(StrMatcher.noneMatcher());
+ assertEquals(1, matcher.isMatch(BUFFER2, 0));
+ assertEquals(0, matcher.isMatch(BUFFER2, 1));
+ assertEquals(1, matcher.isMatch(BUFFER2, 2));
+ assertEquals(0, matcher.isMatch(BUFFER2, 3));
+ assertEquals(1, matcher.isMatch(BUFFER2, 4));
+ assertEquals(0, matcher.isMatch(BUFFER2, 5));
+ assertSame(StrMatcher.charSetMatcher(), StrMatcher.noneMatcher());
+ assertSame(StrMatcher.charSetMatcher((char[]) null), StrMatcher.noneMatcher());
StrMatcherTest.assertStrMatcherImpl("CharMatcher", StrMatcher.charSetMatcher("a".toCharArray()));
}
@Test
public void testCharSetMatcher_String() {
final StrMatcher matcher = StrMatcher.charSetMatcher("ace");
- assertThat(matcher.isMatch(BUFFER2, 0)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 1)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 2)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 4)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 5)).isEqualTo(0);
- assertThat(StrMatcher.charSetMatcher("")).isSameAs(StrMatcher.noneMatcher());
- assertThat(StrMatcher.charSetMatcher((String) null)).isSameAs(StrMatcher.noneMatcher());
+ assertEquals(1, matcher.isMatch(BUFFER2, 0));
+ assertEquals(0, matcher.isMatch(BUFFER2, 1));
+ assertEquals(1, matcher.isMatch(BUFFER2, 2));
+ assertEquals(0, matcher.isMatch(BUFFER2, 3));
+ assertEquals(1, matcher.isMatch(BUFFER2, 4));
+ assertEquals(0, matcher.isMatch(BUFFER2, 5));
+ assertSame(StrMatcher.charSetMatcher(""), StrMatcher.noneMatcher());
+ assertSame(StrMatcher.charSetMatcher((String) null), StrMatcher.noneMatcher());
StrMatcherTest.assertStrMatcherImpl("CharMatcher", StrMatcher.charSetMatcher("a"));
}
@Test
public void testCommaMatcher() {
final StrMatcher matcher = StrMatcher.commaMatcher();
- assertThat(StrMatcher.commaMatcher()).isSameAs(matcher);
- assertThat(matcher.isMatch(BUFFER1, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 1)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 2)).isEqualTo(0);
+ assertSame(StrMatcher.commaMatcher(), matcher);
+ assertEquals(0, matcher.isMatch(BUFFER1, 0));
+ assertEquals(1, matcher.isMatch(BUFFER1, 1));
+ assertEquals(0, matcher.isMatch(BUFFER1, 2));
}
@Test
public void testDoubleQuoteMatcher() {
final StrMatcher matcher = StrMatcher.doubleQuoteMatcher();
- assertThat(StrMatcher.doubleQuoteMatcher()).isSameAs(matcher);
- assertThat(matcher.isMatch(BUFFER1, 11)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(1);
+ assertSame(StrMatcher.doubleQuoteMatcher(), matcher);
+ assertEquals(0, matcher.isMatch(BUFFER1, 11));
+ assertEquals(1, matcher.isMatch(BUFFER1, 12));
}
@Test
@@ -107,107 +107,107 @@ public class StrMatcherTest {
// all the onus is on the caller, so invalid inputs are not
// the concern of StrMatcher, and are not bugs
final StrMatcher matcher = StrMatcher.stringMatcher("bc");
- assertThat(matcher.isMatch(BUFFER2, 1, 1, BUFFER2.length)).isEqualTo(2);
- assertThat(matcher.isMatch(BUFFER2, 1, 0, 3)).isEqualTo(2);
- assertThat(matcher.isMatch(BUFFER2, 1, 0, 2)).isEqualTo(0);
+ assertEquals(2, matcher.isMatch(BUFFER2, 1, 1, BUFFER2.length));
+ assertEquals(2, matcher.isMatch(BUFFER2, 1, 0, 3));
+ assertEquals(0, matcher.isMatch(BUFFER2, 1, 0, 2));
}
@Test
public void testNoneMatcher() {
final StrMatcher matcher = StrMatcher.noneMatcher();
- assertThat(StrMatcher.noneMatcher()).isSameAs(matcher);
- assertThat(matcher.isMatch(BUFFER1, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 1)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 5)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 6)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 7)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 8)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 9)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 10)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 11)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(0);
+ assertSame(StrMatcher.noneMatcher(), matcher);
+ assertEquals(0, matcher.isMatch(BUFFER1, 0));
+ assertEquals(0, matcher.isMatch(BUFFER1, 1));
+ assertEquals(0, matcher.isMatch(BUFFER1, 2));
+ assertEquals(0, matcher.isMatch(BUFFER1, 3));
+ assertEquals(0, matcher.isMatch(BUFFER1, 4));
+ assertEquals(0, matcher.isMatch(BUFFER1, 5));
+ assertEquals(0, matcher.isMatch(BUFFER1, 6));
+ assertEquals(0, matcher.isMatch(BUFFER1, 7));
+ assertEquals(0, matcher.isMatch(BUFFER1, 8));
+ assertEquals(0, matcher.isMatch(BUFFER1, 9));
+ assertEquals(0, matcher.isMatch(BUFFER1, 10));
+ assertEquals(0, matcher.isMatch(BUFFER1, 11));
+ assertEquals(0, matcher.isMatch(BUFFER1, 12));
}
@Test
public void testQuoteMatcher() {
final StrMatcher matcher = StrMatcher.quoteMatcher();
- assertThat(StrMatcher.quoteMatcher()).isSameAs(matcher);
- assertThat(matcher.isMatch(BUFFER1, 10)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 11)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(1);
+ assertSame(StrMatcher.quoteMatcher(), matcher);
+ assertEquals(0, matcher.isMatch(BUFFER1, 10));
+ assertEquals(1, matcher.isMatch(BUFFER1, 11));
+ assertEquals(1, matcher.isMatch(BUFFER1, 12));
}
@Test
public void testSingleQuoteMatcher() {
final StrMatcher matcher = StrMatcher.singleQuoteMatcher();
- assertThat(StrMatcher.singleQuoteMatcher()).isSameAs(matcher);
- assertThat(matcher.isMatch(BUFFER1, 10)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 11)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(0);
+ assertSame(StrMatcher.singleQuoteMatcher(), matcher);
+ assertEquals(0, matcher.isMatch(BUFFER1, 10));
+ assertEquals(1, matcher.isMatch(BUFFER1, 11));
+ assertEquals(0, matcher.isMatch(BUFFER1, 12));
}
@Test
public void testSpaceMatcher() {
final StrMatcher matcher = StrMatcher.spaceMatcher();
- assertThat(StrMatcher.spaceMatcher()).isSameAs(matcher);
- assertThat(matcher.isMatch(BUFFER1, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 5)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 6)).isEqualTo(0);
+ assertSame(StrMatcher.spaceMatcher(), matcher);
+ assertEquals(0, matcher.isMatch(BUFFER1, 4));
+ assertEquals(1, matcher.isMatch(BUFFER1, 5));
+ assertEquals(0, matcher.isMatch(BUFFER1, 6));
}
@Test
public void testSplitMatcher() {
final StrMatcher matcher = StrMatcher.splitMatcher();
- assertThat(StrMatcher.splitMatcher()).isSameAs(matcher);
- assertThat(matcher.isMatch(BUFFER1, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 3)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 5)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 6)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 7)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 8)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 9)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 10)).isEqualTo(0);
+ assertSame(StrMatcher.splitMatcher(), matcher);
+ assertEquals(0, matcher.isMatch(BUFFER1, 2));
+ assertEquals(1, matcher.isMatch(BUFFER1, 3));
+ assertEquals(0, matcher.isMatch(BUFFER1, 4));
+ assertEquals(1, matcher.isMatch(BUFFER1, 5));
+ assertEquals(0, matcher.isMatch(BUFFER1, 6));
+ assertEquals(1, matcher.isMatch(BUFFER1, 7));
+ assertEquals(1, matcher.isMatch(BUFFER1, 8));
+ assertEquals(1, matcher.isMatch(BUFFER1, 9));
+ assertEquals(0, matcher.isMatch(BUFFER1, 10));
}
@Test
public void testStringMatcher_String() {
final StrMatcher matcher = StrMatcher.stringMatcher("bc");
- assertThat(matcher.isMatch(BUFFER2, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 1)).isEqualTo(2);
- assertThat(matcher.isMatch(BUFFER2, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 5)).isEqualTo(0);
- assertThat(StrMatcher.stringMatcher("")).isSameAs(StrMatcher.noneMatcher());
- assertThat(StrMatcher.stringMatcher((String) null)).isSameAs(StrMatcher.noneMatcher());
+ assertEquals(0, matcher.isMatch(BUFFER2, 0));
+ assertEquals(2, matcher.isMatch(BUFFER2, 1));
+ assertEquals(0, matcher.isMatch(BUFFER2, 2));
+ assertEquals(0, matcher.isMatch(BUFFER2, 3));
+ assertEquals(0, matcher.isMatch(BUFFER2, 4));
+ assertEquals(0, matcher.isMatch(BUFFER2, 5));
+ assertSame(StrMatcher.stringMatcher(""), StrMatcher.noneMatcher());
+ assertSame(StrMatcher.stringMatcher((String) null), StrMatcher.noneMatcher());
}
@Test
public void testTabMatcher() {
final StrMatcher matcher = StrMatcher.tabMatcher();
- assertThat(StrMatcher.tabMatcher()).isSameAs(matcher);
- assertThat(matcher.isMatch(BUFFER1, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 3)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 4)).isEqualTo(0);
+ assertSame(StrMatcher.tabMatcher(), matcher);
+ assertEquals(0, matcher.isMatch(BUFFER1, 2));
+ assertEquals(1, matcher.isMatch(BUFFER1, 3));
+ assertEquals(0, matcher.isMatch(BUFFER1, 4));
}
@Test
public void testTrimMatcher() {
final StrMatcher matcher = StrMatcher.trimMatcher();
- assertThat(StrMatcher.trimMatcher()).isSameAs(matcher);
- assertThat(matcher.isMatch(BUFFER1, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 3)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 5)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 6)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 7)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 8)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 9)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 10)).isEqualTo(1);
+ assertSame(StrMatcher.trimMatcher(), matcher);
+ assertEquals(0, matcher.isMatch(BUFFER1, 2));
+ assertEquals(1, matcher.isMatch(BUFFER1, 3));
+ assertEquals(0, matcher.isMatch(BUFFER1, 4));
+ assertEquals(1, matcher.isMatch(BUFFER1, 5));
+ assertEquals(0, matcher.isMatch(BUFFER1, 6));
+ assertEquals(1, matcher.isMatch(BUFFER1, 7));
+ assertEquals(1, matcher.isMatch(BUFFER1, 8));
+ assertEquals(1, matcher.isMatch(BUFFER1, 9));
+ assertEquals(1, matcher.isMatch(BUFFER1, 10));
}
}
diff --git a/src/test/java/org/apache/commons/text/StrSubstitutorTest.java b/src/test/java/org/apache/commons/text/StrSubstitutorTest.java
index c5768b33..051d8d3c 100644
--- a/src/test/java/org/apache/commons/text/StrSubstitutorTest.java
+++ b/src/test/java/org/apache/commons/text/StrSubstitutorTest.java
@@ -17,7 +17,6 @@
package org.apache.commons.text;
-import static org.assertj.core.api.Assertions.assertThatNullPointerException;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
@@ -657,7 +656,7 @@ public class StrSubstitutorTest {
@Test
public void testReplaceTakingThreeArgumentsThrowsNullPointerException() {
- assertThatNullPointerException().isThrownBy(() -> StrSubstitutor.replace(null, (Properties) null));
+ assertThrows(NullPointerException.class, () -> StrSubstitutor.replace(null, (Properties) null));
}
/**
diff --git a/src/test/java/org/apache/commons/text/StringSubstitutorTest.java b/src/test/java/org/apache/commons/text/StringSubstitutorTest.java
index f4f51d05..97b18dde 100644
--- a/src/test/java/org/apache/commons/text/StringSubstitutorTest.java
+++ b/src/test/java/org/apache/commons/text/StringSubstitutorTest.java
@@ -17,13 +17,11 @@
package org.apache.commons.text;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
-import static org.assertj.core.api.Assertions.assertThatNullPointerException;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.IOException;
@@ -60,21 +58,19 @@ public class StringSubstitutorTest {
protected Map<String, String> values;
private void assertEqualsCharSeq(final CharSequence expected, final CharSequence actual) {
- assertEquals(expected, actual, () -> String.format("expected.length()=%,d, actual.length()=%,d",
- StringUtils.length(expected), StringUtils.length(actual)));
+ assertEquals(expected, actual,
+ () -> String.format("expected.length()=%,d, actual.length()=%,d", StringUtils.length(expected), StringUtils.length(actual)));
}
protected void doNotReplace(final String replaceTemplate) throws IOException {
doTestNoReplace(new StringSubstitutor(values), replaceTemplate);
}
- protected void doReplace(final String expectedResult, final String replaceTemplate, final boolean substring)
- throws IOException {
+ protected void doReplace(final String expectedResult, final String replaceTemplate, final boolean substring) throws IOException {
doTestReplace(new StringSubstitutor(values), expectedResult, replaceTemplate, substring);
}
- protected void doTestNoReplace(final StringSubstitutor substitutor, final String replaceTemplate)
- throws IOException {
+ protected void doTestNoReplace(final StringSubstitutor substitutor, final String replaceTemplate) throws IOException {
if (replaceTemplate == null) {
assertNull(replace(substitutor, (String) null));
assertNull(substitutor.replace((String) null, 0, 100));
@@ -97,15 +93,13 @@ public class StringSubstitutorTest {
}
}
- protected void doTestReplace(final StringSubstitutor sub, final String expectedResult, final String replaceTemplate,
- final boolean substring) throws IOException {
- final String expectedShortResult = substring ? expectedResult.substring(1, expectedResult.length() - 1)
- : expectedResult;
+ protected void doTestReplace(final StringSubstitutor sub, final String expectedResult, final String replaceTemplate, final boolean substring)
+ throws IOException {
+ final String expectedShortResult = substring ? expectedResult.substring(1, expectedResult.length() - 1) : expectedResult;
// replace using String
final String actual = replace(sub, replaceTemplate);
- assertEquals(expectedResult, actual,
- () -> String.format("Index of difference: %,d", StringUtils.indexOfDifference(expectedResult, actual)));
+ assertEquals(expectedResult, actual, () -> String.format("Index of difference: %,d", StringUtils.indexOfDifference(expectedResult, actual)));
if (substring) {
assertEquals(expectedShortResult, sub.replace(replaceTemplate, 1, replaceTemplate.length() - 2));
}
@@ -228,12 +222,9 @@ public class StringSubstitutorTest {
assertTrue(target.isEnableSubstitutionInVariables());
assertTrue(target.isEnableUndefinedVariableException());
assertEquals('e', target.getEscapeChar());
- assertTrue(target.getValueDelimiterMatcher().toString().endsWith("['d']"),
- target.getValueDelimiterMatcher().toString());
- assertTrue(target.getVariablePrefixMatcher().toString().endsWith("['p']"),
- target.getValueDelimiterMatcher().toString());
- assertTrue(target.getVariableSuffixMatcher().toString().endsWith("['s']"),
- target.getValueDelimiterMatcher().toString());
+ assertTrue(target.getValueDelimiterMatcher().toString().endsWith("['d']"), target.getValueDelimiterMatcher().toString());
+ assertTrue(target.getVariablePrefixMatcher().toString().endsWith("['p']"), target.getValueDelimiterMatcher().toString());
+ assertTrue(target.getVariableSuffixMatcher().toString().endsWith("['s']"), target.getValueDelimiterMatcher().toString());
}
/**
@@ -335,8 +326,7 @@ public class StringSubstitutorTest {
doReplace("${11}", "$${${aa}}", false);
doReplace("${111}", "$${${aaa}}", false);
doReplace("${quick brown fox}", "$${${animal}}", false);
- doReplace("The ${quick brown fox} jumps over the lazy dog.", "The $${${animal}} jumps over the ${target}.",
- true);
+ doReplace("The ${quick brown fox} jumps over the lazy dog.", "The $${${animal}} jumps over the ${target}.", true);
doReplace("${${a}}", "$${$${a}}", false);
doReplace("${${aa}}", "$${$${aa}}", false);
doReplace("${${aaa}}", "$${$${aaa}}", false);
@@ -346,7 +336,7 @@ public class StringSubstitutorTest {
doReplace(".${${animal}}.", ".$${$${animal}}.", false);
doReplace("The ${${animal}} jumps over the lazy dog.", "The $${$${animal}} jumps over the ${target}.", true);
doReplace("The ${quick brown fox} jumps over the lazy dog. ${1234567890}.",
- "The $${${animal}} jumps over the ${target}. $${${undefined.number:-1234567890}}.", true);
+ "The $${${animal}} jumps over the ${target}. $${${undefined.number:-1234567890}}.", true);
}
/**
@@ -451,24 +441,20 @@ public class StringSubstitutorTest {
final StringSubstitutor sub = new StringSubstitutor(values);
sub.setEnableUndefinedVariableException(true);
- assertThatIllegalArgumentException()
- .isThrownBy(() -> replace(sub, "The ${animal.${species}} jumps over the ${target}."))
- .withMessage("Cannot resolve variable 'animal.${species' (enableSubstitutionInVariables=false).");
+ assertEquals("Cannot resolve variable 'animal.${species' (enableSubstitutionInVariables=false).",
+ assertThrows(IllegalArgumentException.class, () -> replace(sub, "The ${animal.${species}} jumps over the ${target}.")).getMessage());
- assertThatIllegalArgumentException()
- .isThrownBy(() -> replace(sub, "The ${animal.${species:-1}} jumps over the ${target}."))
- .withMessage("Cannot resolve variable 'animal.${species:-1' (enableSubstitutionInVariables=false).");
+ assertEquals("Cannot resolve variable 'animal.${species:-1' (enableSubstitutionInVariables=false).",
+ assertThrows(IllegalArgumentException.class, () -> replace(sub, "The ${animal.${species:-1}} jumps over the ${target}.")).getMessage());
- assertThatIllegalArgumentException()
- .isThrownBy(() -> replace(sub, "The ${test:-statement} is a sample for missing ${unknown}."))
- .withMessage("Cannot resolve variable 'unknown' (enableSubstitutionInVariables=false).");
+ assertEquals("Cannot resolve variable 'unknown' (enableSubstitutionInVariables=false).",
+ assertThrows(IllegalArgumentException.class, () -> replace(sub, "The ${test:-statement} is a sample for missing ${unknown}.")).getMessage());
// if default value is available, exception will not be thrown
assertEqualsCharSeq("The statement is a sample for missing variable.",
- replace(sub, "The ${test:-statement} is a sample for missing ${unknown:-variable}."));
+ replace(sub, "The ${test:-statement} is a sample for missing ${unknown:-variable}."));
- assertEqualsCharSeq("The fox jumps over the lazy dog.",
- replace(sub, "The ${animal.1} jumps over the ${target}."));
+ assertEqualsCharSeq("The fox jumps over the lazy dog.", replace(sub, "The ${animal.1} jumps over the ${target}."));
}
/**
@@ -487,28 +473,25 @@ public class StringSubstitutorTest {
sub.setEnableUndefinedVariableException(true);
sub.setEnableSubstitutionInVariables(true);
- assertEqualsCharSeq("The mouse jumps over the lazy dog.",
- replace(sub, "The ${animal.${species}} jumps over the ${target}."));
+ assertEqualsCharSeq("The mouse jumps over the lazy dog.", replace(sub, "The ${animal.${species}} jumps over the ${target}."));
values.put("species", "1");
- assertEqualsCharSeq("The fox jumps over the lazy dog.",
- replace(sub, "The ${animal.${species}} jumps over the ${target}."));
+ assertEqualsCharSeq("The fox jumps over the lazy dog.", replace(sub, "The ${animal.${species}} jumps over the ${target}."));
// exception is thrown here because variable with name test.1 is missing
- assertThatIllegalArgumentException()
- .isThrownBy(() -> replace(sub, "The ${test.${statement}} is a sample for missing ${word}."))
- .withMessage("Cannot resolve variable 'statement' (enableSubstitutionInVariables=true).");
+ assertEquals("Cannot resolve variable 'statement' (enableSubstitutionInVariables=true).",
+ assertThrows(IllegalArgumentException.class, () -> replace(sub, "The ${test.${statement}} is a sample for missing ${word}.")).getMessage());
// exception is thrown here because variable with name test.2 is missing
- assertThatIllegalArgumentException()
- .isThrownBy(() -> replace(sub, "The ${test.${statement.${recursive}}} is a sample for missing ${word}."))
- .withMessage("Cannot resolve variable 'test.2' (enableSubstitutionInVariables=true).");
+ assertEquals("Cannot resolve variable 'test.2' (enableSubstitutionInVariables=true).",
+ assertThrows(IllegalArgumentException.class, () -> replace(sub, "The ${test.${statement.${recursive}}} is a sample for missing ${word}."))
+ .getMessage());
assertEqualsCharSeq("statement", replace(sub, "${testok.${statement.${recursive}}}"));
assertEqualsCharSeq("${testok.2}", replace(sub, "$${testok.${statement.${recursive}}}"));
assertEqualsCharSeq("The statement is a sample for missing variable.",
- replace(sub, "The ${testok.${statement.${recursive}}} is a sample for missing ${word}."));
+ replace(sub, "The ${testok.${statement.${recursive}}} is a sample for missing ${word}."));
}
/**
@@ -521,8 +504,7 @@ public class StringSubstitutorTest {
@Test
public void testReplaceInTakingStringBufferWithNonNull() {
- final StringSubstitutor strSubstitutor = new StringSubstitutor(new HashMap<>(), "WV@i#y?N*[",
- "WV@i#y?N*[", '*');
+ final StringSubstitutor strSubstitutor = new StringSubstitutor(new HashMap<>(), "WV@i#y?N*[", "WV@i#y?N*[", '*');
assertFalse(strSubstitutor.isPreserveEscapes());
assertFalse(strSubstitutor.replaceIn(new StringBuffer("WV@i#y?N*[")));
@@ -542,8 +524,7 @@ public class StringSubstitutorTest {
@Test
public void testReplaceInTakingStringBuilderWithNull() {
final Map<String, Object> map = new HashMap<>();
- final StringSubstitutor strSubstitutor = new StringSubstitutor(map, StringUtils.EMPTY, StringUtils.EMPTY, 'T',
- "K+<'f");
+ final StringSubstitutor strSubstitutor = new StringSubstitutor(map, StringUtils.EMPTY, StringUtils.EMPTY, 'T', "K+<'f");
assertFalse(strSubstitutor.replaceIn((StringBuilder) null));
}
@@ -553,8 +534,7 @@ public class StringSubstitutorTest {
final Map<String, Object> hashMap = new HashMap<>();
final StringLookup mapStringLookup = StringLookupFactory.INSTANCE.mapStringLookup(hashMap);
final StringMatcher strMatcher = StringMatcherFactory.INSTANCE.tabMatcher();
- final StringSubstitutor strSubstitutor = new StringSubstitutor(mapStringLookup, strMatcher, strMatcher, 'b',
- strMatcher);
+ final StringSubstitutor strSubstitutor = new StringSubstitutor(mapStringLookup, strMatcher, strMatcher, 'b', strMatcher);
assertFalse(strSubstitutor.replaceIn((StringBuilder) null, 1315, -1369));
assertEquals('b', strSubstitutor.getEscapeChar());
@@ -571,13 +551,11 @@ public class StringSubstitutorTest {
values.put("species", "2");
final StringSubstitutor sub = new StringSubstitutor(values);
sub.setEnableSubstitutionInVariables(true);
- assertEqualsCharSeq("The mouse jumps over the lazy dog.",
- replace(sub, "The ${animal.${species}} jumps over the ${target}."));
+ assertEqualsCharSeq("The mouse jumps over the lazy dog.", replace(sub, "The ${animal.${species}} jumps over the ${target}."));
values.put("species", "1");
+ assertEqualsCharSeq("The fox jumps over the lazy dog.", replace(sub, "The ${animal.${species}} jumps over the ${target}."));
assertEqualsCharSeq("The fox jumps over the lazy dog.",
- replace(sub, "The ${animal.${species}} jumps over the ${target}."));
- assertEqualsCharSeq("The fox jumps over the lazy dog.", replace(sub,
- "The ${unknown.animal.${unknown.species:-1}:-fox} " + "jumps over the ${unknow.target:-lazy dog}."));
+ replace(sub, "The ${unknown.animal.${unknown.species:-1}:-fox} " + "jumps over the ${unknow.target:-lazy dog}."));
}
/**
@@ -589,10 +567,8 @@ public class StringSubstitutorTest {
values.put("animal.2", "mouse");
values.put("species", "2");
final StringSubstitutor sub = new StringSubstitutor(values);
- assertEqualsCharSeq("The ${animal.${species}} jumps over the lazy dog.",
- replace(sub, "The ${animal.${species}} jumps over the ${target}."));
- assertEqualsCharSeq("The ${animal.${species:-1}} jumps over the lazy dog.",
- replace(sub, "The ${animal.${species:-1}} jumps over the ${target}."));
+ assertEqualsCharSeq("The ${animal.${species}} jumps over the lazy dog.", replace(sub, "The ${animal.${species}} jumps over the ${target}."));
+ assertEqualsCharSeq("The ${animal.${species:-1}} jumps over the lazy dog.", replace(sub, "The ${animal.${species:-1}} jumps over the ${target}."));
}
/**
@@ -608,10 +584,9 @@ public class StringSubstitutorTest {
final StringSubstitutor sub = new StringSubstitutor(values);
sub.setEnableSubstitutionInVariables(true);
assertEqualsCharSeq("white mouse", replace(sub, "${animal.${species.${color}}}"));
- assertEqualsCharSeq("The white mouse jumps over the lazy dog.",
- replace(sub, "The ${animal.${species.${color}}} jumps over the ${target}."));
+ assertEqualsCharSeq("The white mouse jumps over the lazy dog.", replace(sub, "The ${animal.${species.${color}}} jumps over the ${target}."));
assertEqualsCharSeq("The brown fox jumps over the lazy dog.",
- replace(sub, "The ${animal.${species.${unknownColor:-brown}}} jumps over the ${target}."));
+ replace(sub, "The ${animal.${species.${unknownColor:-brown}}} jumps over the ${target}."));
}
/**
@@ -687,8 +662,7 @@ public class StringSubstitutorTest {
*/
@Test
public void testReplacePrefixNoSuffix() throws IOException {
- doReplace("The ${animal jumps over the ${target} lazy dog.", "The ${animal jumps over the ${target} ${target}.",
- true);
+ doReplace("The ${animal jumps over the ${target} lazy dog.", "The ${animal jumps over the ${target} ${target}.", true);
}
/**
@@ -753,7 +727,7 @@ public class StringSubstitutorTest {
@Test
public void testReplaceTakingThreeArgumentsThrowsNullPointerException() {
- assertThatNullPointerException().isThrownBy(() -> StringSubstitutor.replace(null, (Properties) null));
+ assertThrows(NullPointerException.class, () -> StringSubstitutor.replace(null, (Properties) null));
}
@Test
@@ -763,19 +737,15 @@ public class StringSubstitutorTest {
// replace(char[], int, int)
final char[] emptyCharArray = {};
// offset greater than array length
- assertThatExceptionOfType(StringIndexOutOfBoundsException.class).isThrownBy(
- () -> sub.replace(emptyCharArray, 0, 1));
+ assertThrows(StringIndexOutOfBoundsException.class, () -> sub.replace(emptyCharArray, 0, 1));
// source != null && (offset > source.length || offset < 0)
- assertThatExceptionOfType(StringIndexOutOfBoundsException.class).isThrownBy(
- () -> sub.replace(emptyCharArray, 1, 0));
+ assertThrows(StringIndexOutOfBoundsException.class, () -> sub.replace(emptyCharArray, 1, 0));
// replace(String, int, int)
// offset greater than source length
- assertThatExceptionOfType(StringIndexOutOfBoundsException.class).isThrownBy(
- () -> sub.replace("", 1, 1));
+ assertThrows(StringIndexOutOfBoundsException.class, () -> sub.replace("", 1, 1));
// source != null && offset >= 0 && offset <= source.length() && (length > -offset + source.length() || length < 0)
- assertThatExceptionOfType(StringIndexOutOfBoundsException.class).isThrownBy(
- () -> sub.replace("", 0, 1));
+ assertThrows(StringIndexOutOfBoundsException.class, () -> sub.replace("", 0, 1));
}
/**
@@ -801,8 +771,7 @@ public class StringSubstitutorTest {
*/
@Test
public void testReplaceUnknownKeyDefaultValue() throws IOException {
- doReplace("The ${person} jumps over the lazy dog. 1234567890.",
- "The ${person} jumps over the ${target}. ${undefined.number:-1234567890}.", true);
+ doReplace("The ${person} jumps over the lazy dog. 1234567890.", "The ${person} jumps over the ${target}. ${undefined.number:-1234567890}.", true);
}
/**
@@ -1007,8 +976,7 @@ public class StringSubstitutorTest {
map.put("name", "commons");
final StringSubstitutor sub = new StringSubstitutor(map) {
@Override
- protected String resolveVariable(final String variableName, final TextStringBuilder buf, final int startPos,
- final int endPos) {
+ protected String resolveVariable(final String variableName, final TextStringBuilder buf, final int startPos, final int endPos) {
assertEquals("name", variableName);
assertSame(builder, buf);
assertEquals(3, startPos);
@@ -1027,8 +995,7 @@ public class StringSubstitutorTest {
map.put(" there ", "XXX");
map.put("name", "commons");
assertEqualsCharSeq("Hi commons!", StringSubstitutor.replace("Hi @name@!", map, "@", "@"));
- assertEqualsCharSeq("Hello there commons!",
- StringSubstitutor.replace("@greeting@ there @name@!", map, "@", "@"));
+ assertEqualsCharSeq("Hello there commons!", StringSubstitutor.replace("@greeting@ there @name@!", map, "@", "@"));
}
/**
@@ -1062,8 +1029,8 @@ public class StringSubstitutorTest {
buf.append(SystemProperties.getOsName());
buf.append(", your home directory is ");
buf.append(SystemProperties.getUserHome()).append('.');
- assertEqualsCharSeq(buf.toString(), StringSubstitutor.replaceSystemProperties(
- "Hi ${user.name}, you are " + "working with ${os.name}, your home " + "directory is ${user.home}."));
+ assertEqualsCharSeq(buf.toString(),
+ StringSubstitutor.replaceSystemProperties("Hi ${user.name}, you are " + "working with ${os.name}, your home " + "directory is ${user.home}."));
}
/**
diff --git a/src/test/java/org/apache/commons/text/TextStringBuilderAppendInsertTest.java b/src/test/java/org/apache/commons/text/TextStringBuilderAppendInsertTest.java
index 3ea31f7a..ad021dd8 100644
--- a/src/test/java/org/apache/commons/text/TextStringBuilderAppendInsertTest.java
+++ b/src/test/java/org/apache/commons/text/TextStringBuilderAppendInsertTest.java
@@ -17,7 +17,7 @@
package org.apache.commons.text;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
@@ -55,38 +55,38 @@ public class TextStringBuilderAppendInsertTest {
public void testAppend_Boolean() {
final TextStringBuilder sb = new TextStringBuilder();
sb.append(true);
- assertThat(sb.toString()).isEqualTo("true");
+ assertEquals("true", sb.toString());
sb.append(false);
- assertThat(sb.toString()).isEqualTo("truefalse");
+ assertEquals("truefalse", sb.toString());
sb.append('!');
- assertThat(sb.toString()).isEqualTo("truefalse!");
+ assertEquals("truefalse!", sb.toString());
}
@Test
public void testAppend_CharArray() {
TextStringBuilder sb = new TextStringBuilder();
sb.setNullText("NULL").append((char[]) null);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new TextStringBuilder();
sb.append(ArrayUtils.EMPTY_CHAR_ARRAY);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.append(new char[] {'f', 'o', 'o'});
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
}
@Test
public void testAppend_CharArray_int_int() {
final TextStringBuilder sb0 = new TextStringBuilder();
sb0.setNullText("NULL").append((char[]) null, 0, 1);
- assertThat(sb0.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb0.toString());
final TextStringBuilder sb = new TextStringBuilder();
sb.append(new char[] {'f', 'o', 'o'}, 0, 3);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.append(new char[] {'b', 'a', 'r'}, -1, 1),
"append(char[], -1,) expected IndexOutOfBoundsException");
@@ -107,10 +107,10 @@ public class TextStringBuilderAppendInsertTest {
"append(char[], 4, 0) expected IndexOutOfBoundsException");
sb.append(new char[] {'b', 'a', 'r'}, 3, 0);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new char[] {'a', 'b', 'c', 'b', 'a', 'r', 'd', 'e', 'f'}, 3, 3);
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
}
@Test
@@ -119,94 +119,94 @@ public class TextStringBuilderAppendInsertTest {
sb = new TextStringBuilder();
sb.append("Hi", (Object[]) null);
- assertThat(sb.toString()).isEqualTo("Hi");
+ assertEquals("Hi", sb.toString());
sb = new TextStringBuilder();
sb.append("Hi", "Alice");
- assertThat(sb.toString()).isEqualTo("Hi");
+ assertEquals("Hi", sb.toString());
sb = new TextStringBuilder();
sb.append("Hi %s", "Alice");
- assertThat(sb.toString()).isEqualTo("Hi Alice");
+ assertEquals("Hi Alice", sb.toString());
sb = new TextStringBuilder();
sb.append("Hi %s %,d", "Alice", 5000);
// group separator depends on system locale
final char groupingSeparator = DecimalFormatSymbols.getInstance().getGroupingSeparator();
final String expected = "Hi Alice 5" + groupingSeparator + "000";
- assertThat(sb.toString()).isEqualTo(expected);
+ assertEquals(expected, sb.toString());
}
@Test
public void testAppend_Object() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendNull();
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.append((Object) null);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.append(FOO);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append((StringBuffer) null);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StringBuffer("baz"));
- assertThat(sb.toString()).isEqualTo("foobaz");
+ assertEquals("foobaz", sb.toString());
sb.append(new TextStringBuilder("yes"));
- assertThat(sb.toString()).isEqualTo("foobazyes");
+ assertEquals("foobazyes", sb.toString());
sb.append((CharSequence) "Seq");
- assertThat(sb.toString()).isEqualTo("foobazyesSeq");
+ assertEquals("foobazyesSeq", sb.toString());
sb.append(new StringBuilder("bld")); // Check it supports StringBuilder
- assertThat(sb.toString()).isEqualTo("foobazyesSeqbld");
+ assertEquals("foobazyesSeqbld", sb.toString());
}
@Test
public void testAppend_PrimitiveNumber() {
final TextStringBuilder sb = new TextStringBuilder();
sb.append(0);
- assertThat(sb.toString()).isEqualTo("0");
+ assertEquals("0", sb.toString());
sb.append(1L);
- assertThat(sb.toString()).isEqualTo("01");
+ assertEquals("01", sb.toString());
sb.append(2.3f);
- assertThat(sb.toString()).isEqualTo("012.3");
+ assertEquals("012.3", sb.toString());
sb.append(4.5d);
- assertThat(sb.toString()).isEqualTo("012.34.5");
+ assertEquals("012.34.5", sb.toString());
}
@Test
public void testAppend_String() {
TextStringBuilder sb = new TextStringBuilder();
sb.setNullText("NULL").append((String) null);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new TextStringBuilder();
sb.append("foo");
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append("");
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append("bar");
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
}
@Test
public void testAppend_String_int_int() {
final TextStringBuilder sb0 = new TextStringBuilder();
sb0.setNullText("NULL").append((String) null, 0, 1);
- assertThat(sb0.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb0.toString());
final TextStringBuilder sb = new TextStringBuilder();
sb.append("foo", 0, 3);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.append("bar", -1, 1), "append(char[], -1,) expected IndexOutOfBoundsException");
assertThrows(IndexOutOfBoundsException.class, () -> sb.append("bar", 3, 1), "append(char[], 3,) expected IndexOutOfBoundsException");
assertThrows(IndexOutOfBoundsException.class, () -> sb.append("bar", 1, -1), "append(char[],, -1) expected IndexOutOfBoundsException");
@@ -219,41 +219,41 @@ public class TextStringBuilderAppendInsertTest {
assertThrows(IndexOutOfBoundsException.class, () -> sb.append((CharSequence) "bar", 2, 0), "append(char[], 2, 0) expected IndexOutOfBoundsException");
sb.append("bar", 3, 0);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append("abcbardef", 3, 3);
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
sb.append((CharSequence) "abcbardef", 4, 7);
- assertThat(sb.toString()).isEqualTo("foobarard");
+ assertEquals("foobarard", sb.toString());
}
@Test
public void testAppend_StringBuffer() {
TextStringBuilder sb = new TextStringBuilder();
sb.setNullText("NULL").append((StringBuffer) null);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new TextStringBuilder();
sb.append(new StringBuffer("foo"));
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StringBuffer(""));
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StringBuffer("bar"));
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
}
@Test
public void testAppend_StringBuffer_int_int() {
final TextStringBuilder sb0 = new TextStringBuilder();
sb0.setNullText("NULL").append((StringBuffer) null, 0, 1);
- assertThat(sb0.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb0.toString());
final TextStringBuilder sb = new TextStringBuilder();
sb.append(new StringBuffer("foo"), 0, 3);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.append(new StringBuffer("bar"), -1, 1),
"append(char[], -1,) expected IndexOutOfBoundsException");
@@ -273,38 +273,38 @@ public class TextStringBuilderAppendInsertTest {
"append(char[], 4, 0) expected IndexOutOfBoundsException");
sb.append(new StringBuffer("bar"), 3, 0);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StringBuffer("abcbardef"), 3, 3);
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
}
@Test
public void testAppend_StringBuilder() {
TextStringBuilder sb = new TextStringBuilder();
sb.setNullText("NULL").append((String) null);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new TextStringBuilder();
sb.append(new StringBuilder("foo"));
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StringBuilder(""));
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StringBuilder("bar"));
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
}
@Test
public void testAppend_StringBuilder_int_int() {
final TextStringBuilder sb0 = new TextStringBuilder();
sb0.setNullText("NULL").append((String) null, 0, 1);
- assertThat(sb0.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb0.toString());
final TextStringBuilder sb = new TextStringBuilder();
sb.append(new StringBuilder("foo"), 0, 3);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.append(new StringBuilder("bar"), -1, 1),
"append(StringBuilder, -1,) expected IndexOutOfBoundsException");
@@ -325,41 +325,41 @@ public class TextStringBuilderAppendInsertTest {
"append(StringBuilder, 4, 0) expected IndexOutOfBoundsException");
sb.append(new StringBuilder("bar"), 3, 0);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new StringBuilder("abcbardef"), 3, 3);
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
sb.append(new StringBuilder("abcbardef"), 4, 3);
- assertThat(sb.toString()).isEqualTo("foobarard");
+ assertEquals("foobarard", sb.toString());
}
@Test
public void testAppend_TextStringBuilder() {
TextStringBuilder sb = new TextStringBuilder();
sb.setNullText("NULL").append((TextStringBuilder) null);
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb = new TextStringBuilder();
sb.append(new TextStringBuilder("foo"));
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new TextStringBuilder(""));
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new TextStringBuilder("bar"));
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
}
@Test
public void testAppend_TextStringBuilder_int_int() {
final TextStringBuilder sb0 = new TextStringBuilder();
sb0.setNullText("NULL").append((TextStringBuilder) null, 0, 1);
- assertThat(sb0.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb0.toString());
final TextStringBuilder sb = new TextStringBuilder();
sb.append(new TextStringBuilder("foo"), 0, 3);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.append(new TextStringBuilder("bar"), -1, 1),
"append(char[], -1,) expected IndexOutOfBoundsException");
@@ -380,212 +380,212 @@ public class TextStringBuilderAppendInsertTest {
"append(char[], 4, 0) expected IndexOutOfBoundsException");
sb.append(new TextStringBuilder("bar"), 3, 0);
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.append(new TextStringBuilder("abcbardef"), 3, 3);
- assertThat(sb.toString()).isEqualTo("foobar");
+ assertEquals("foobar", sb.toString());
}
@Test
public void testAppendAll_Array() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendAll((Object[]) null);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendAll();
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendAll("foo", "bar", "baz");
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.appendAll("foo", "bar", "baz");
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
}
@Test
public void testAppendAll_Collection() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendAll((Collection<?>) null);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendAll(Collections.EMPTY_LIST);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendAll(Arrays.asList("foo", "bar", "baz"));
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
}
@Test
public void testAppendAll_Iterator() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendAll((Iterator<?>) null);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendAll(Collections.EMPTY_LIST.iterator());
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendAll(Arrays.asList("foo", "bar", "baz").iterator());
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
}
@Test
public void testAppendFixedWidthPadLeft() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendFixedWidthPadLeft("foo", -1, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft("foo", 0, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft("foo", 1, '-');
- assertThat(sb.toString()).isEqualTo("o");
+ assertEquals("o", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft("foo", 2, '-');
- assertThat(sb.toString()).isEqualTo("oo");
+ assertEquals("oo", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft("foo", 3, '-');
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft("foo", 4, '-');
- assertThat(sb.toString()).isEqualTo("-foo");
+ assertEquals("-foo", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft("foo", 10, '-');
- assertThat(sb.length()).isEqualTo(10);
+ assertEquals(10, sb.length());
// 1234567890
- assertThat(sb.toString()).isEqualTo("-------foo");
+ assertEquals("-------foo", sb.toString());
sb.clear();
sb.setNullText("null");
sb.appendFixedWidthPadLeft(null, 5, '-');
- assertThat(sb.toString()).isEqualTo("-null");
+ assertEquals("-null", sb.toString());
}
@Test
public void testAppendFixedWidthPadLeft_int() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendFixedWidthPadLeft(123, -1, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft(123, 0, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft(123, 1, '-');
- assertThat(sb.toString()).isEqualTo("3");
+ assertEquals("3", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft(123, 2, '-');
- assertThat(sb.toString()).isEqualTo("23");
+ assertEquals("23", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft(123, 3, '-');
- assertThat(sb.toString()).isEqualTo("123");
+ assertEquals("123", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft(123, 4, '-');
- assertThat(sb.toString()).isEqualTo("-123");
+ assertEquals("-123", sb.toString());
sb.clear();
sb.appendFixedWidthPadLeft(123, 10, '-');
- assertThat(sb.length()).isEqualTo(10);
+ assertEquals(10, sb.length());
// 1234567890
- assertThat(sb.toString()).isEqualTo("-------123");
+ assertEquals("-------123", sb.toString());
}
@Test
public void testAppendFixedWidthPadRight() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendFixedWidthPadRight("foo", -1, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight("foo", 0, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight("foo", 1, '-');
- assertThat(sb.toString()).isEqualTo("f");
+ assertEquals("f", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight("foo", 2, '-');
- assertThat(sb.toString()).isEqualTo("fo");
+ assertEquals("fo", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight("foo", 3, '-');
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight("foo", 4, '-');
- assertThat(sb.toString()).isEqualTo("foo-");
+ assertEquals("foo-", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight("foo", 10, '-');
- assertThat(sb.length()).isEqualTo(10);
+ assertEquals(10, sb.length());
// 1234567890
- assertThat(sb.toString()).isEqualTo("foo-------");
+ assertEquals("foo-------", sb.toString());
sb.clear();
sb.setNullText("null");
sb.appendFixedWidthPadRight(null, 5, '-');
- assertThat(sb.toString()).isEqualTo("null-");
+ assertEquals("null-", sb.toString());
}
@Test
public void testAppendFixedWidthPadRight_int() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendFixedWidthPadRight(123, -1, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight(123, 0, '-');
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight(123, 1, '-');
- assertThat(sb.toString()).isEqualTo("1");
+ assertEquals("1", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight(123, 2, '-');
- assertThat(sb.toString()).isEqualTo("12");
+ assertEquals("12", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight(123, 3, '-');
- assertThat(sb.toString()).isEqualTo("123");
+ assertEquals("123", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight(123, 4, '-');
- assertThat(sb.toString()).isEqualTo("123-");
+ assertEquals("123-", sb.toString());
sb.clear();
sb.appendFixedWidthPadRight(123, 10, '-');
- assertThat(sb.length()).isEqualTo(10);
+ assertEquals(10, sb.length());
// 1234567890
- assertThat(sb.toString()).isEqualTo("123-------");
+ assertEquals("123-------", sb.toString());
}
@Test
public void testAppendln_Boolean() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendln(true);
- assertThat(sb.toString()).isEqualTo("true" + SEP);
+ assertEquals("true" + SEP, sb.toString());
sb.clear();
sb.appendln(false);
- assertThat(sb.toString()).isEqualTo("false" + SEP);
+ assertEquals("false" + SEP, sb.toString());
}
@Test
@@ -594,7 +594,7 @@ public class TextStringBuilderAppendInsertTest {
final char[] input = "foo".toCharArray();
sb.appendln(input);
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertEquals("foo" + SEP, sb.toString());
verify(sb, times(1)).append(input);
verify(sb, times(1)).appendNewLine();
@@ -606,7 +606,7 @@ public class TextStringBuilderAppendInsertTest {
final char[] input = "foo".toCharArray();
sb.appendln(input, 0, 3);
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertEquals("foo" + SEP, sb.toString());
verify(sb, times(1)).append(input, 0, 3);
verify(sb, times(1)).appendNewLine();
@@ -617,7 +617,7 @@ public class TextStringBuilderAppendInsertTest {
final TextStringBuilder sb = spy(new TextStringBuilder());
sb.appendln("Hello %s", "Alice");
- assertThat(sb.toString()).isEqualTo("Hello Alice" + SEP);
+ assertEquals("Hello Alice" + SEP, sb.toString());
verify(sb, times(2)).append(anyString()); // appendNewLine() calls append(String)
verify(sb, times(1)).appendNewLine();
@@ -627,32 +627,32 @@ public class TextStringBuilderAppendInsertTest {
public void testAppendln_Object() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendln((Object) null);
- assertThat(sb.toString()).isEqualTo("" + SEP);
+ assertEquals("" + SEP, sb.toString());
sb.appendln(FOO);
- assertThat(sb.toString()).isEqualTo(SEP + "foo" + SEP);
+ assertEquals(SEP + "foo" + SEP, sb.toString());
sb.appendln(Integer.valueOf(6));
- assertThat(sb.toString()).isEqualTo(SEP + "foo" + SEP + "6" + SEP);
+ assertEquals(SEP + "foo" + SEP + "6" + SEP, sb.toString());
}
@Test
public void testAppendln_PrimitiveNumber() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendln(0);
- assertThat(sb.toString()).isEqualTo("0" + SEP);
+ assertEquals("0" + SEP, sb.toString());
sb.clear();
sb.appendln(1L);
- assertThat(sb.toString()).isEqualTo("1" + SEP);
+ assertEquals("1" + SEP, sb.toString());
sb.clear();
sb.appendln(2.3f);
- assertThat(sb.toString()).isEqualTo("2.3" + SEP);
+ assertEquals("2.3" + SEP, sb.toString());
sb.clear();
sb.appendln(4.5d);
- assertThat(sb.toString()).isEqualTo("4.5" + SEP);
+ assertEquals("4.5" + SEP, sb.toString());
}
@Test
@@ -660,7 +660,7 @@ public class TextStringBuilderAppendInsertTest {
final TextStringBuilder sb = spy(new TextStringBuilder());
sb.appendln("foo");
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertEquals("foo" + SEP, sb.toString());
verify(sb, times(2)).append(anyString()); // appendNewLine() calls append(String)
verify(sb, times(1)).appendNewLine();
@@ -671,7 +671,7 @@ public class TextStringBuilderAppendInsertTest {
final TextStringBuilder sb = spy(new TextStringBuilder());
sb.appendln("foo", 0, 3);
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertEquals("foo" + SEP, sb.toString());
verify(sb, times(2)).append(anyString(), anyInt(), anyInt()); // appendNewLine() calls append(String)
verify(sb, times(1)).appendNewLine();
@@ -682,7 +682,7 @@ public class TextStringBuilderAppendInsertTest {
final TextStringBuilder sb = spy(new TextStringBuilder());
sb.appendln(new StringBuffer("foo"));
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertEquals("foo" + SEP, sb.toString());
verify(sb, times(1)).append(any(StringBuffer.class));
verify(sb, times(1)).appendNewLine();
@@ -693,7 +693,7 @@ public class TextStringBuilderAppendInsertTest {
final TextStringBuilder sb = spy(new TextStringBuilder());
sb.appendln(new StringBuffer("foo"), 0, 3);
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertEquals("foo" + SEP, sb.toString());
verify(sb, times(1)).append(any(StringBuffer.class), anyInt(), anyInt());
verify(sb, times(1)).appendNewLine();
@@ -704,7 +704,7 @@ public class TextStringBuilderAppendInsertTest {
final TextStringBuilder sb = spy(new TextStringBuilder());
sb.appendln(new StringBuilder("foo"));
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertEquals("foo" + SEP, sb.toString());
verify(sb, times(1)).append(any(StringBuilder.class));
verify(sb, times(1)).appendNewLine();
@@ -715,7 +715,7 @@ public class TextStringBuilderAppendInsertTest {
final TextStringBuilder sb = spy(new TextStringBuilder());
sb.appendln(new StringBuilder("foo"), 0, 3);
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertEquals("foo" + SEP, sb.toString());
verify(sb, times(1)).append(any(StringBuilder.class), anyInt(), anyInt());
verify(sb, times(1)).appendNewLine();
@@ -726,7 +726,7 @@ public class TextStringBuilderAppendInsertTest {
final TextStringBuilder sb = spy(new TextStringBuilder());
sb.appendln(new TextStringBuilder("foo"));
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertEquals("foo" + SEP, sb.toString());
verify(sb, times(1)).append(any(TextStringBuilder.class));
verify(sb, times(1)).appendNewLine();
@@ -737,7 +737,7 @@ public class TextStringBuilderAppendInsertTest {
final TextStringBuilder sb = spy(new TextStringBuilder());
sb.appendln(new TextStringBuilder("foo"), 0, 3);
- assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertEquals("foo" + SEP, sb.toString());
verify(sb, times(1)).append(any(TextStringBuilder.class), anyInt(), anyInt());
verify(sb, times(1)).appendNewLine();
@@ -747,43 +747,43 @@ public class TextStringBuilderAppendInsertTest {
public void testAppendNewLine() {
TextStringBuilder sb = new TextStringBuilder("---");
sb.appendNewLine().append("+++");
- assertThat(sb.toString()).isEqualTo("---" + SEP + "+++");
+ assertEquals("---" + SEP + "+++", sb.toString());
sb = new TextStringBuilder("---");
sb.setNewLineText("#").appendNewLine().setNewLineText(null).appendNewLine();
- assertThat(sb.toString()).isEqualTo("---#" + SEP);
+ assertEquals("---#" + SEP, sb.toString());
}
@Test
public void testAppendPadding() {
final TextStringBuilder sb = new TextStringBuilder();
sb.append("foo");
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.appendPadding(-1, '-');
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.appendPadding(0, '-');
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.appendPadding(1, '-');
- assertThat(sb.toString()).isEqualTo("foo-");
+ assertEquals("foo-", sb.toString());
sb.appendPadding(16, '-');
- assertThat(sb.length()).isEqualTo(20);
+ assertEquals(20, sb.length());
// 12345678901234567890
- assertThat(sb.toString()).isEqualTo("foo-----------------");
+ assertEquals("foo-----------------", sb.toString());
}
@Test
public void testAppendSeparator_char() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendSeparator(','); // no effect
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.append("foo");
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.appendSeparator(',');
- assertThat(sb.toString()).isEqualTo("foo,");
+ assertEquals("foo,", sb.toString());
}
@Test
@@ -793,58 +793,58 @@ public class TextStringBuilderAppendInsertTest {
final char standardSeparator = ',';
final String foo = "foo";
sb.appendSeparator(standardSeparator, startSeparator); // no effect
- assertThat(sb.toString()).isEqualTo(String.valueOf(startSeparator));
+ assertEquals(String.valueOf(startSeparator), sb.toString());
sb.append(foo);
- assertThat(sb.toString()).isEqualTo(String.valueOf(startSeparator) + foo);
+ assertEquals(String.valueOf(startSeparator) + foo, sb.toString());
sb.appendSeparator(standardSeparator, startSeparator);
- assertThat(sb.toString()).isEqualTo(String.valueOf(startSeparator) + foo + standardSeparator);
+ assertEquals(String.valueOf(startSeparator) + foo + standardSeparator, sb.toString());
}
@Test
public void testAppendSeparator_char_int() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendSeparator(',', 0); // no effect
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.append("foo");
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.appendSeparator(',', 1);
- assertThat(sb.toString()).isEqualTo("foo,");
+ assertEquals("foo,", sb.toString());
sb.appendSeparator(',', -1); // no effect
- assertThat(sb.toString()).isEqualTo("foo,");
+ assertEquals("foo,", sb.toString());
}
@Test
public void testAppendSeparator_String() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendSeparator(","); // no effect
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.append("foo");
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.appendSeparator(",");
- assertThat(sb.toString()).isEqualTo("foo,");
+ assertEquals("foo,", sb.toString());
}
@Test
public void testAppendSeparator_String_int() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendSeparator(null, -1); // no effect
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.appendSeparator(null, 0); // no effect
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.appendSeparator(null, 1); // no effect
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.appendSeparator(",", -1); // no effect
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.appendSeparator(",", 0); // no effect
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.append("foo");
- assertThat(sb.toString()).isEqualTo("foo");
+ assertEquals("foo", sb.toString());
sb.appendSeparator(",", 1);
- assertThat(sb.toString()).isEqualTo("foo,");
+ assertEquals("foo,", sb.toString());
sb.appendSeparator(",", -1); // no effect
- assertThat(sb.toString()).isEqualTo("foo,");
+ assertEquals("foo,", sb.toString());
}
@Test
@@ -854,119 +854,119 @@ public class TextStringBuilderAppendInsertTest {
final String standardSeparator = ",";
final String foo = "foo";
sb.appendSeparator(null, null);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.appendSeparator(standardSeparator, null);
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.appendSeparator(standardSeparator, startSeparator);
- assertThat(sb.toString()).isEqualTo(startSeparator);
+ assertEquals(startSeparator, sb.toString());
sb.appendSeparator(null, null);
- assertThat(sb.toString()).isEqualTo(startSeparator);
+ assertEquals(startSeparator, sb.toString());
sb.appendSeparator(null, startSeparator);
- assertThat(sb.toString()).isEqualTo(startSeparator);
+ assertEquals(startSeparator, sb.toString());
sb.append(foo);
- assertThat(sb.toString()).isEqualTo(startSeparator + foo);
+ assertEquals(startSeparator + foo, sb.toString());
sb.appendSeparator(standardSeparator, startSeparator);
- assertThat(sb.toString()).isEqualTo(startSeparator + foo + standardSeparator);
+ assertEquals(startSeparator + foo + standardSeparator, sb.toString());
}
@Test
public void testAppendWithNullText() {
final TextStringBuilder sb = new TextStringBuilder();
sb.setNullText("NULL");
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.appendNull();
- assertThat(sb.toString()).isEqualTo("NULL");
+ assertEquals("NULL", sb.toString());
sb.append((Object) null);
- assertThat(sb.toString()).isEqualTo("NULLNULL");
+ assertEquals("NULLNULL", sb.toString());
sb.append(FOO);
- assertThat(sb.toString()).isEqualTo("NULLNULLfoo");
+ assertEquals("NULLNULLfoo", sb.toString());
sb.append((String) null);
- assertThat(sb.toString()).isEqualTo("NULLNULLfooNULL");
+ assertEquals("NULLNULLfooNULL", sb.toString());
sb.append("");
- assertThat(sb.toString()).isEqualTo("NULLNULLfooNULL");
+ assertEquals("NULLNULLfooNULL", sb.toString());
sb.append("bar");
- assertThat(sb.toString()).isEqualTo("NULLNULLfooNULLbar");
+ assertEquals("NULLNULLfooNULLbar", sb.toString());
sb.append((StringBuffer) null);
- assertThat(sb.toString()).isEqualTo("NULLNULLfooNULLbarNULL");
+ assertEquals("NULLNULLfooNULLbarNULL", sb.toString());
sb.append(new StringBuffer("baz"));
- assertThat(sb.toString()).isEqualTo("NULLNULLfooNULLbarNULLbaz");
+ assertEquals("NULLNULLfooNULLbarNULLbaz", sb.toString());
}
@Test
public void testAppendWithSeparators_Array() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendWithSeparators((Object[]) null, ",");
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendWithSeparators(ArrayUtils.EMPTY_OBJECT_ARRAY, ",");
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendWithSeparators(new Object[] {"foo", "bar", "baz"}, ",");
- assertThat(sb.toString()).isEqualTo("foo,bar,baz");
+ assertEquals("foo,bar,baz", sb.toString());
sb.clear();
sb.appendWithSeparators(new Object[] {"foo", "bar", "baz"}, null);
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.appendWithSeparators(new Object[] {"foo", null, "baz"}, ",");
- assertThat(sb.toString()).isEqualTo("foo,,baz");
+ assertEquals("foo,,baz", sb.toString());
}
@Test
public void testAppendWithSeparators_Collection() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendWithSeparators((Collection<?>) null, ",");
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendWithSeparators(Collections.EMPTY_LIST, ",");
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz"), ",");
- assertThat(sb.toString()).isEqualTo("foo,bar,baz");
+ assertEquals("foo,bar,baz", sb.toString());
sb.clear();
sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz"), null);
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.appendWithSeparators(Arrays.asList("foo", null, "baz"), ",");
- assertThat(sb.toString()).isEqualTo("foo,,baz");
+ assertEquals("foo,,baz", sb.toString());
}
@Test
public void testAppendWithSeparators_Iterator() {
final TextStringBuilder sb = new TextStringBuilder();
sb.appendWithSeparators((Iterator<?>) null, ",");
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendWithSeparators(Collections.EMPTY_LIST.iterator(), ",");
- assertThat(sb.toString()).isEqualTo("");
+ assertEquals("", sb.toString());
sb.clear();
sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz").iterator(), ",");
- assertThat(sb.toString()).isEqualTo("foo,bar,baz");
+ assertEquals("foo,bar,baz", sb.toString());
sb.clear();
sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz").iterator(), null);
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.appendWithSeparators(Arrays.asList("foo", null, "baz").iterator(), ",");
- assertThat(sb.toString()).isEqualTo("foo,,baz");
+ assertEquals("foo,,baz", sb.toString());
}
@Test
@@ -974,11 +974,11 @@ public class TextStringBuilderAppendInsertTest {
final TextStringBuilder sb = new TextStringBuilder();
sb.setNullText("null");
sb.appendWithSeparators(new Object[] {"foo", null, "baz"}, ",");
- assertThat(sb.toString()).isEqualTo("foo,null,baz");
+ assertEquals("foo,null,baz", sb.toString());
sb.clear();
sb.appendWithSeparators(Arrays.asList("foo", null, "baz"), ",");
- assertThat(sb.toString()).isEqualTo("foo,null,baz");
+ assertEquals("foo,null,baz", sb.toString());
}
@Test
@@ -986,52 +986,52 @@ public class TextStringBuilderAppendInsertTest {
final TextStringBuilder sb = new TextStringBuilder();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, FOO));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, FOO));
sb.insert(0, (Object) null);
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
sb.insert(0, FOO);
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, "foo"));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, "foo"));
sb.insert(0, (String) null);
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
sb.insert(0, "foo");
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, new char[] {'f', 'o', 'o'}));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, new char[] {'f', 'o', 'o'}));
sb.insert(0, (char[]) null);
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
sb.insert(0, ArrayUtils.EMPTY_CHAR_ARRAY);
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
sb.insert(0, new char[] {'f', 'o', 'o'});
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class,
() -> sb.insert(-1, new char[] {'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 3, 3));
@@ -1040,10 +1040,10 @@ public class TextStringBuilderAppendInsertTest {
() -> sb.insert(7, new char[] {'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 3, 3));
sb.insert(0, (char[]) null, 0, 0);
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
sb.insert(0, ArrayUtils.EMPTY_CHAR_ARRAY, 0, 0);
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class,
() -> sb.insert(0, new char[] {'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, -1, 3));
@@ -1058,79 +1058,79 @@ public class TextStringBuilderAppendInsertTest {
() -> sb.insert(0, new char[] {'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 0, 10));
sb.insert(0, new char[] {'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 0, 0);
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
sb.insert(0, new char[] {'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 3, 3);
- assertThat(sb.toString()).isEqualTo("foobarbaz");
+ assertEquals("foobarbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, true));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, true));
sb.insert(0, true);
- assertThat(sb.toString()).isEqualTo("truebarbaz");
+ assertEquals("truebarbaz", sb.toString());
sb.insert(0, false);
- assertThat(sb.toString()).isEqualTo("falsetruebarbaz");
+ assertEquals("falsetruebarbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, '!'));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, '!'));
sb.insert(0, '!');
- assertThat(sb.toString()).isEqualTo("!barbaz");
+ assertEquals("!barbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, 0));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, 0));
sb.insert(0, '0');
- assertThat(sb.toString()).isEqualTo("0barbaz");
+ assertEquals("0barbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, 1L));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, 1L));
sb.insert(0, 1L);
- assertThat(sb.toString()).isEqualTo("1barbaz");
+ assertEquals("1barbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, 2.3F));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, 2.3F));
sb.insert(0, 2.3F);
- assertThat(sb.toString()).isEqualTo("2.3barbaz");
+ assertEquals("2.3barbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, 4.5D));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, 4.5D));
sb.insert(0, 4.5D);
- assertThat(sb.toString()).isEqualTo("4.5barbaz");
+ assertEquals("4.5barbaz", sb.toString());
}
@Test
@@ -1138,37 +1138,37 @@ public class TextStringBuilderAppendInsertTest {
final TextStringBuilder sb = new TextStringBuilder();
sb.setNullText("null");
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, FOO));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, FOO));
sb.insert(0, (Object) null);
- assertThat(sb.toString()).isEqualTo("nullbarbaz");
+ assertEquals("nullbarbaz", sb.toString());
sb.insert(0, FOO);
- assertThat(sb.toString()).isEqualTo("foonullbarbaz");
+ assertEquals("foonullbarbaz", sb.toString());
sb.clear();
sb.append("barbaz");
- assertThat(sb.toString()).isEqualTo("barbaz");
+ assertEquals("barbaz", sb.toString());
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, "foo"));
assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, "foo"));
sb.insert(0, (String) null);
- assertThat(sb.toString()).isEqualTo("nullbarbaz");
+ assertEquals("nullbarbaz", sb.toString());
sb.insert(0, "foo");
- assertThat(sb.toString()).isEqualTo("foonullbarbaz");
+ assertEquals("foonullbarbaz", sb.toString());
sb.insert(0, (char[]) null);
- assertThat(sb.toString()).isEqualTo("nullfoonullbarbaz");
+ assertEquals("nullfoonullbarbaz", sb.toString());
sb.insert(0, (char[]) null, 0, 0);
- assertThat(sb.toString()).isEqualTo("nullnullfoonullbarbaz");
+ assertEquals("nullnullfoonullbarbaz", sb.toString());
}
/** See: https://issues.apache.org/jira/browse/LANG-299 */
@@ -1176,6 +1176,6 @@ public class TextStringBuilderAppendInsertTest {
public void testLang299() {
final TextStringBuilder sb = new TextStringBuilder(1);
sb.appendFixedWidthPadRight("foo", 1, '-');
- assertThat(sb.toString()).isEqualTo("f");
+ assertEquals("f", sb.toString());
}
}
diff --git a/src/test/java/org/apache/commons/text/TextStringBuilderTest.java b/src/test/java/org/apache/commons/text/TextStringBuilderTest.java
index 524ae3c5..16d0c21c 100644
--- a/src/test/java/org/apache/commons/text/TextStringBuilderTest.java
+++ b/src/test/java/org/apache/commons/text/TextStringBuilderTest.java
@@ -17,7 +17,6 @@
package org.apache.commons.text;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -80,7 +79,7 @@ public class TextStringBuilderTest {
/**
* Clear the string builder and fill up to the specified length.
*
- * @param sb the string builder
+ * @param sb the string builder
* @param length the length
*/
private static void fill(final TextStringBuilder sb, final int length) {
@@ -202,7 +201,7 @@ public class TextStringBuilderTest {
@Test
public void testAppendTakingTwoIntsWithIndexOutOfBoundsThrowsStringIndexOutOfBoundsExceptionTwo() {
- assertThatExceptionOfType(StringIndexOutOfBoundsException.class).isThrownBy(() -> {
+ assertThrows(StringIndexOutOfBoundsException.class, () -> {
final Charset charset = Charset.defaultCharset();
final ByteBuffer byteBuffer = charset.encode("asdf");
final CharBuffer charBuffer = charset.decode(byteBuffer);
@@ -213,7 +212,7 @@ public class TextStringBuilderTest {
@Test
public void testAppendTakingTwoIntsWithZeroThrowsStringIndexOutOfBoundsException() {
- assertThatExceptionOfType(StringIndexOutOfBoundsException.class).isThrownBy(() -> {
+ assertThrows(StringIndexOutOfBoundsException.class, () -> {
final Charset charset = Charset.defaultCharset();
final ByteBuffer byteBuffer = charset.encode("end < start");
final CharBuffer charBuffer = charset.decode(byteBuffer);
@@ -323,8 +322,7 @@ public class TextStringBuilderTest {
assertThrows(IndexOutOfBoundsException.class, () -> reader.read(array, 0, -1));
assertThrows(IndexOutOfBoundsException.class, () -> reader.read(array, 100, 1));
assertThrows(IndexOutOfBoundsException.class, () -> reader.read(array, 0, 100));
- assertThrows(IndexOutOfBoundsException.class,
- () -> reader.read(array, Integer.MAX_VALUE, Integer.MAX_VALUE));
+ assertThrows(IndexOutOfBoundsException.class, () -> reader.read(array, Integer.MAX_VALUE, Integer.MAX_VALUE));
assertEquals(0, reader.read(array, 0, 0));
assertEquals(0, array[0]);
@@ -392,10 +390,10 @@ public class TextStringBuilderTest {
writer.write('l');
assertEquals("basel", sb.toString());
- writer.write(new char[] {'i', 'n'});
+ writer.write(new char[] { 'i', 'n' });
assertEquals("baselin", sb.toString());
- writer.write(new char[] {'n', 'e', 'r'}, 1, 2);
+ writer.write(new char[] { 'n', 'e', 'r' }, 1, 2);
assertEquals("baseliner", sb.toString());
writer.write(" rout");
@@ -724,7 +722,7 @@ public class TextStringBuilderTest {
@Test
public void testDeleteCharAtWithNegative() {
- assertThatExceptionOfType(StringIndexOutOfBoundsException.class).isThrownBy(() -> new TextStringBuilder().deleteCharAt(-1258));
+ assertThrows(StringIndexOutOfBoundsException.class, () -> new TextStringBuilder().deleteCharAt(-1258));
}
@Test
@@ -841,7 +839,7 @@ public class TextStringBuilderTest {
final char[] b = new char[5];
sb.set(data);
assertEquals(2, sb.drainChars(0, 2, b, 3));
- assertArrayEquals(new char[] {0, 0, 0, 'j', 'u'}, b);
+ assertArrayEquals(new char[] { 0, 0, 0, 'j', 'u' }, b);
assertThrows(IndexOutOfBoundsException.class, () -> sb.drainChars(-1, 0, b, 0));
assertThrows(IndexOutOfBoundsException.class, () -> sb.drainChars(0, -1, array, 0));
@@ -970,21 +968,16 @@ public class TextStringBuilderTest {
assertTrue(sb1.equalsIgnoreCase(sb2));
final Locale turkish = Locale.forLanguageTag("tr");
- assertTrue(
- new TextStringBuilder("title").equalsIgnoreCase(new TextStringBuilder("title".toLowerCase(turkish))));
- assertTrue(
- new TextStringBuilder("title").equalsIgnoreCase(new TextStringBuilder("TITLE".toLowerCase(turkish))));
- assertTrue(
- new TextStringBuilder("TITLE").equalsIgnoreCase(new TextStringBuilder("TITLE".toLowerCase(turkish))));
- assertTrue(
- new TextStringBuilder("TITLE").equalsIgnoreCase(new TextStringBuilder("title".toLowerCase(turkish))));
+ assertTrue(new TextStringBuilder("title").equalsIgnoreCase(new TextStringBuilder("title".toLowerCase(turkish))));
+ assertTrue(new TextStringBuilder("title").equalsIgnoreCase(new TextStringBuilder("TITLE".toLowerCase(turkish))));
+ assertTrue(new TextStringBuilder("TITLE").equalsIgnoreCase(new TextStringBuilder("TITLE".toLowerCase(turkish))));
+ assertTrue(new TextStringBuilder("TITLE").equalsIgnoreCase(new TextStringBuilder("title".toLowerCase(turkish))));
//
// assertTrue(new TextStringBuilder("title").equalsIgnoreCase(new
// TextStringBuilder("title".toUpperCase(turkish))));
// assertTrue(new TextStringBuilder("title").equalsIgnoreCase(new
// TextStringBuilder("TITLE".toUpperCase(turkish))));
- assertTrue(
- new TextStringBuilder("TITLE").equalsIgnoreCase(new TextStringBuilder("TITLE".toUpperCase(turkish))));
+ assertTrue(new TextStringBuilder("TITLE").equalsIgnoreCase(new TextStringBuilder("TITLE".toUpperCase(turkish))));
// assertTrue(new TextStringBuilder("TITLE").equalsIgnoreCase(new
// TextStringBuilder("title".toUpperCase(turkish))));
}
@@ -1001,7 +994,7 @@ public class TextStringBuilderTest {
sb.append("junit");
a = sb.getChars(input);
assertSame(input, a);
- assertArrayEquals(new char[] {'j', 'u', 'n', 'i', 't', 0, 0, 0, 0, 0}, a);
+ assertArrayEquals(new char[] { 'j', 'u', 'n', 'i', 't', 0, 0, 0, 0, 0 }, a);
a = sb.getChars(null);
assertNotSame(input, a);
@@ -1027,15 +1020,15 @@ public class TextStringBuilderTest {
sb.set("junit");
sb.getChars(0, 1, array1, 0);
- assertArrayEquals(new char[] {'j'}, array1);
+ assertArrayEquals(new char[] { 'j' }, array1);
final char[] array = new char[5];
sb.getChars(0, 5, array, 0);
- assertArrayEquals(new char[] {'j', 'u', 'n', 'i', 't'}, array);
+ assertArrayEquals(new char[] { 'j', 'u', 'n', 'i', 't' }, array);
final char[] b = new char[5];
sb.getChars(0, 2, b, 3);
- assertArrayEquals(new char[] {0, 0, 0, 'j', 'u'}, b);
+ assertArrayEquals(new char[] { 0, 0, 0, 'j', 'u' }, b);
assertThrows(IndexOutOfBoundsException.class, () -> sb.getChars(-1, 0, b, 0));
assertThrows(IndexOutOfBoundsException.class, () -> sb.getChars(0, -1, array, 0));
@@ -1852,8 +1845,7 @@ public class TextStringBuilderTest {
assertEquals("-x--y-", sb.toString());
final TextStringBuilder builder = new TextStringBuilder("aaxaaaayaa");
- assertThrows(IndexOutOfBoundsException.class,
- () -> builder.replace(StringMatcherFactory.INSTANCE.stringMatcher("aa"), "-", 2, 1, -1));
+ assertThrows(IndexOutOfBoundsException.class, () -> builder.replace(StringMatcherFactory.INSTANCE.stringMatcher("aa"), "-", 2, 1, -1));
assertEquals("aaxaaaayaa", builder.toString());
}
@@ -1948,13 +1940,11 @@ public class TextStringBuilderTest {
assertEquals("aaxaaaayaa", sb.toString());
final TextStringBuilder builder = new TextStringBuilder("aaxaaaayaa");
- assertThrows(IndexOutOfBoundsException.class,
- () -> builder.replace(StringMatcherFactory.INSTANCE.stringMatcher("aa"), "-", 11, builder.length(), -1));
+ assertThrows(IndexOutOfBoundsException.class, () -> builder.replace(StringMatcherFactory.INSTANCE.stringMatcher("aa"), "-", 11, builder.length(), -1));
assertEquals("aaxaaaayaa", builder.toString());
builder.set("aaxaaaayaa");
- assertThrows(IndexOutOfBoundsException.class,
- () -> builder.replace(StringMatcherFactory.INSTANCE.stringMatcher("aa"), "-", -1, builder.length(), -1));
+ assertThrows(IndexOutOfBoundsException.class, () -> builder.replace(StringMatcherFactory.INSTANCE.stringMatcher("aa"), "-", -1, builder.length(), -1));
assertEquals("aaxaaaayaa", builder.toString());
}
diff --git a/src/test/java/org/apache/commons/text/WordUtilsTest.java b/src/test/java/org/apache/commons/text/WordUtilsTest.java
index bb3c95df..eaae3ca7 100644
--- a/src/test/java/org/apache/commons/text/WordUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/WordUtilsTest.java
@@ -16,10 +16,11 @@
*/
package org.apache.commons.text;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.lang.reflect.Constructor;
@@ -40,81 +41,81 @@ public class WordUtilsTest {
@Test
public void testAbbreviateForLowerThanMinusOneValues() {
- assertThatIllegalArgumentException().isThrownBy(() -> assertThat(WordUtils.abbreviate("01 23 45 67 89", 9, -10, null)).isEqualTo("01 23 45 67"));
+ assertThrows(IllegalArgumentException.class, () -> WordUtils.abbreviate("01 23 45 67 89", 9, -10, null));
}
- @Test
+ @Test
public void testAbbreviateForLowerValue() {
- assertThat(WordUtils.abbreviate("012 3456789", 0, 5, null)).isEqualTo("012");
- assertThat(WordUtils.abbreviate("01234 56789", 5, 10, null)).isEqualTo("01234");
- assertThat(WordUtils.abbreviate("01 23 45 67 89", 9, -1, null)).isEqualTo("01 23 45 67");
- assertThat(WordUtils.abbreviate("01 23 45 67 89", 9, 10, null)).isEqualTo("01 23 45 6");
- assertThat(WordUtils.abbreviate("0123456789", 15, 20, null)).isEqualTo("0123456789");
+ assertEquals("012", WordUtils.abbreviate("012 3456789", 0, 5, null));
+ assertEquals("01234", WordUtils.abbreviate("01234 56789", 5, 10, null));
+ assertEquals("01 23 45 67", WordUtils.abbreviate("01 23 45 67 89", 9, -1, null));
+ assertEquals("01 23 45 6", WordUtils.abbreviate("01 23 45 67 89", 9, 10, null));
+ assertEquals("0123456789", WordUtils.abbreviate("0123456789", 15, 20, null));
}
- @Test
+ @Test
public void testAbbreviateForLowerValueAndAppendedString() {
- assertThat(WordUtils.abbreviate("012 3456789", 0, 5, null)).isEqualTo("012");
- assertThat(WordUtils.abbreviate("01234 56789", 5, 10, "-")).isEqualTo("01234-");
- assertThat(WordUtils.abbreviate("01 23 45 67 89", 9, -1, "abc")).isEqualTo("01 23 45 67abc");
- assertThat(WordUtils.abbreviate("01 23 45 67 89", 9, 10, "")).isEqualTo("01 23 45 6");
+ assertEquals("012", WordUtils.abbreviate("012 3456789", 0, 5, null));
+ assertEquals("01234-", WordUtils.abbreviate("01234 56789", 5, 10, "-"));
+ assertEquals("01 23 45 67abc", WordUtils.abbreviate("01 23 45 67 89", 9, -1, "abc"));
+ assertEquals("01 23 45 6", WordUtils.abbreviate("01 23 45 67 89", 9, 10, ""));
}
- @Test
+ @Test
public void testAbbreviateForNullAndEmptyString() {
- assertThat(WordUtils.abbreviate(null, 1, -1, "")).isNull();
- assertThat(WordUtils.abbreviate("", 1, -1, "")).isEqualTo(StringUtils.EMPTY);
- assertThat(WordUtils.abbreviate("0123456790", 0, 0, "")).isEqualTo("");
- assertThat(WordUtils.abbreviate(" 0123456790", 0, -1, "")).isEqualTo("");
+ assertNull(WordUtils.abbreviate(null, 1, -1, ""));
+ assertEquals(StringUtils.EMPTY, WordUtils.abbreviate("", 1, -1, ""));
+ assertEquals("", WordUtils.abbreviate("0123456790", 0, 0, ""));
+ assertEquals("", WordUtils.abbreviate(" 0123456790", 0, -1, ""));
}
- @Test
+ @Test
public void testAbbreviateForUpperLimit() {
- assertThat(WordUtils.abbreviate("0123456789", 0, 5, "")).isEqualTo("01234");
- assertThat(WordUtils.abbreviate("012 3456789", 2, 5, "")).isEqualTo("012");
- assertThat(WordUtils.abbreviate("0123456789", 0, -1, "")).isEqualTo("0123456789");
+ assertEquals("01234", WordUtils.abbreviate("0123456789", 0, 5, ""));
+ assertEquals("012", WordUtils.abbreviate("012 3456789", 2, 5, ""));
+ assertEquals("0123456789", WordUtils.abbreviate("0123456789", 0, -1, ""));
}
- @Test
+ @Test
public void testAbbreviateForUpperLimitAndAppendedString() {
- assertThat(WordUtils.abbreviate("0123456789", 0, 5, "-")).isEqualTo("01234-");
- assertThat(WordUtils.abbreviate("012 3456789", 2, 5, null)).isEqualTo("012");
- assertThat(WordUtils.abbreviate("0123456789", 0, -1, "")).isEqualTo("0123456789");
+ assertEquals("01234-", WordUtils.abbreviate("0123456789", 0, 5, "-"));
+ assertEquals("012", WordUtils.abbreviate("012 3456789", 2, 5, null));
+ assertEquals("0123456789", WordUtils.abbreviate("0123456789", 0, -1, ""));
}
@Test
public void testAbbreviateUpperLessThanLowerValues() {
- assertThatIllegalArgumentException().isThrownBy(() -> assertThat(WordUtils.abbreviate("0123456789", 5, 2, "")).isEqualTo("01234"));
+ assertThrows(IllegalArgumentException.class, () -> WordUtils.abbreviate("0123456789", 5, 2, ""));
}
- @Test
+ @Test
public void testCapitalize_String() {
- assertThat(WordUtils.capitalize(null)).isNull();
- assertThat(WordUtils.capitalize("")).isEqualTo("");
- assertThat(WordUtils.capitalize(" ")).isEqualTo(" ");
+ assertNull(WordUtils.capitalize(null));
+ assertEquals("", WordUtils.capitalize(""));
+ assertEquals(" ", WordUtils.capitalize(" "));
- assertThat(WordUtils.capitalize("I")).isEqualTo("I");
- assertThat(WordUtils.capitalize("i")).isEqualTo("I");
- assertThat(WordUtils.capitalize("i am here 123")).isEqualTo("I Am Here 123");
- assertThat(WordUtils.capitalize("I Am Here 123")).isEqualTo("I Am Here 123");
- assertThat(WordUtils.capitalize("i am HERE 123")).isEqualTo("I Am HERE 123");
- assertThat(WordUtils.capitalize("I AM HERE 123")).isEqualTo("I AM HERE 123");
+ assertEquals("I", WordUtils.capitalize("I"));
+ assertEquals("I", WordUtils.capitalize("i"));
+ assertEquals("I Am Here 123", WordUtils.capitalize("i am here 123"));
+ assertEquals("I Am Here 123", WordUtils.capitalize("I Am Here 123"));
+ assertEquals("I Am HERE 123", WordUtils.capitalize("i am HERE 123"));
+ assertEquals("I AM HERE 123", WordUtils.capitalize("I AM HERE 123"));
}
@Test
public void testCapitalizeFully_String() {
- assertThat(WordUtils.capitalizeFully(null)).isNull();
- assertThat(WordUtils.capitalizeFully("")).isEqualTo("");
- assertThat(WordUtils.capitalizeFully(" ")).isEqualTo(" ");
- assertThat(WordUtils.capitalizeFully("I")).isEqualTo("I");
- assertThat(WordUtils.capitalizeFully("i")).isEqualTo("I");
- assertThat(WordUtils.capitalizeFully("i am here 123")).isEqualTo("I Am Here 123");
- assertThat(WordUtils.capitalizeFully("I Am Here 123")).isEqualTo("I Am Here 123");
- assertThat(WordUtils.capitalizeFully("i am HERE 123")).isEqualTo("I Am Here 123");
- assertThat(WordUtils.capitalizeFully("I AM HERE 123")).isEqualTo("I Am Here 123");
- assertThat(WordUtils.capitalizeFully("alphabet")).isEqualTo("Alphabet"); // single word
- assertThat(WordUtils.capitalizeFully("a\tb\nc d")).isEqualTo("A\tB\nC D");
- assertThat(WordUtils.capitalizeFully("and \tbut \ncleat dome")).isEqualTo("And \tBut \nCleat Dome");
+ assertNull(WordUtils.capitalizeFully(null));
+ assertEquals("", WordUtils.capitalizeFully(""));
+ assertEquals(" ", WordUtils.capitalizeFully(" "));
+ assertEquals("I", WordUtils.capitalizeFully("I"));
+ assertEquals("I", WordUtils.capitalizeFully("i"));
+ assertEquals("I Am Here 123", WordUtils.capitalizeFully("i am here 123"));
+ assertEquals("I Am Here 123", WordUtils.capitalizeFully("I Am Here 123"));
+ assertEquals("I Am Here 123", WordUtils.capitalizeFully("i am HERE 123"));
+ assertEquals("I Am Here 123", WordUtils.capitalizeFully("I AM HERE 123"));
+ assertEquals("Alphabet", WordUtils.capitalizeFully("alphabet")); // single word
+ assertEquals("A\tB\nC D", WordUtils.capitalizeFully("a\tb\nc d"));
+ assertEquals("And \tBut \nCleat Dome", WordUtils.capitalizeFully("and \tbut \ncleat dome"));
// All whitespace
assertEquals(WHITESPACE, WordUtils.capitalizeFully(WHITESPACE));
assertEquals("A" + WHITESPACE + "B", WordUtils.capitalizeFully("a" + WHITESPACE + "b"));
@@ -123,55 +124,55 @@ public class WordUtilsTest {
@Test
public void testCapitalizeFully_Text88() {
- assertThat(WordUtils.capitalizeFully("i am fine now", new char[] {})).isEqualTo("I am fine now");
+ assertEquals("I am fine now", WordUtils.capitalizeFully("i am fine now", new char[] {}));
}
@Test
public void testCapitalizeFullyWithDelimiters_String() {
- assertThat(WordUtils.capitalizeFully(null, null)).isNull();
- assertThat(WordUtils.capitalizeFully("", ArrayUtils.EMPTY_CHAR_ARRAY)).isEqualTo("");
- assertThat(WordUtils.capitalizeFully(" ", ArrayUtils.EMPTY_CHAR_ARRAY)).isEqualTo(" ");
-
- char[] chars = {'-', '+', ' ', '@'};
- assertThat(WordUtils.capitalizeFully("I", chars)).isEqualTo("I");
- assertThat(WordUtils.capitalizeFully("i", chars)).isEqualTo("I");
- assertThat(WordUtils.capitalizeFully("i-am here+123", chars)).isEqualTo("I-Am Here+123");
- assertThat(WordUtils.capitalizeFully("I Am+Here-123", chars)).isEqualTo("I Am+Here-123");
- assertThat(WordUtils.capitalizeFully("i+am-HERE 123", chars)).isEqualTo("I+Am-Here 123");
- assertThat(WordUtils.capitalizeFully("I-AM HERE+123", chars)).isEqualTo("I-Am Here+123");
- chars = new char[] {'.'};
- assertThat(WordUtils.capitalizeFully("i aM.fine", chars)).isEqualTo("I am.Fine");
- assertThat(WordUtils.capitalizeFully("i am.fine", null)).isEqualTo("I Am.fine");
- assertThat(WordUtils.capitalizeFully("alphabet", null)).isEqualTo("Alphabet"); // single word
- assertThat(WordUtils.capitalizeFully("alphabet", new char[] {'!'})).isEqualTo("Alphabet"); // no matching delim
+ assertNull(WordUtils.capitalizeFully(null, null));
+ assertEquals("", WordUtils.capitalizeFully("", ArrayUtils.EMPTY_CHAR_ARRAY));
+ assertEquals(" ", WordUtils.capitalizeFully(" ", ArrayUtils.EMPTY_CHAR_ARRAY));
+
+ char[] chars = { '-', '+', ' ', '@' };
+ assertEquals("I", WordUtils.capitalizeFully("I", chars));
+ assertEquals("I", WordUtils.capitalizeFully("i", chars));
+ assertEquals("I-Am Here+123", WordUtils.capitalizeFully("i-am here+123", chars));
+ assertEquals("I Am+Here-123", WordUtils.capitalizeFully("I Am+Here-123", chars));
+ assertEquals("I+Am-Here 123", WordUtils.capitalizeFully("i+am-HERE 123", chars));
+ assertEquals("I-Am Here+123", WordUtils.capitalizeFully("I-AM HERE+123", chars));
+ chars = new char[] { '.' };
+ assertEquals("I am.Fine", WordUtils.capitalizeFully("i aM.fine", chars));
+ assertEquals("I Am.fine", WordUtils.capitalizeFully("i am.fine", null));
+ assertEquals("Alphabet", WordUtils.capitalizeFully("alphabet", null)); // single word
+ assertEquals("Alphabet", WordUtils.capitalizeFully("alphabet", new char[] { '!' })); // no matching delim
}
@Test
public void testCapitalizeWithDelimiters_String() {
- assertThat(WordUtils.capitalize(null, null)).isNull();
- assertThat(WordUtils.capitalize("", ArrayUtils.EMPTY_CHAR_ARRAY)).isEqualTo("");
- assertThat(WordUtils.capitalize(" ", ArrayUtils.EMPTY_CHAR_ARRAY)).isEqualTo(" ");
-
- char[] chars = {'-', '+', ' ', '@'};
- assertThat(WordUtils.capitalize("I", chars)).isEqualTo("I");
- assertThat(WordUtils.capitalize("i", chars)).isEqualTo("I");
- assertThat(WordUtils.capitalize("i-am here+123", chars)).isEqualTo("I-Am Here+123");
- assertThat(WordUtils.capitalize("I Am+Here-123", chars)).isEqualTo("I Am+Here-123");
- assertThat(WordUtils.capitalize("i+am-HERE 123", chars)).isEqualTo("I+Am-HERE 123");
- assertThat(WordUtils.capitalize("I-AM HERE+123", chars)).isEqualTo("I-AM HERE+123");
- chars = new char[] {'.'};
- assertThat(WordUtils.capitalize("i aM.fine", chars)).isEqualTo("I aM.Fine");
- assertThat(WordUtils.capitalize("i am.fine", null)).isEqualTo("I Am.fine");
- }
-
- @Test
+ assertNull(WordUtils.capitalize(null, null));
+ assertEquals("", WordUtils.capitalize("", ArrayUtils.EMPTY_CHAR_ARRAY));
+ assertEquals(" ", WordUtils.capitalize(" ", ArrayUtils.EMPTY_CHAR_ARRAY));
+
+ char[] chars = { '-', '+', ' ', '@' };
+ assertEquals("I", WordUtils.capitalize("I", chars));
+ assertEquals("I", WordUtils.capitalize("i", chars));
+ assertEquals("I-Am Here+123", WordUtils.capitalize("i-am here+123", chars));
+ assertEquals("I Am+Here-123", WordUtils.capitalize("I Am+Here-123", chars));
+ assertEquals("I+Am-HERE 123", WordUtils.capitalize("i+am-HERE 123", chars));
+ assertEquals("I-AM HERE+123", WordUtils.capitalize("I-AM HERE+123", chars));
+ chars = new char[] { '.' };
+ assertEquals("I aM.Fine", WordUtils.capitalize("i aM.fine", chars));
+ assertEquals("I Am.fine", WordUtils.capitalize("i am.fine", null));
+ }
+
+ @Test
public void testConstructor() {
- assertThat(new WordUtils()).isNotNull();
+ assertNotNull(new WordUtils());
final Constructor<?>[] cons = WordUtils.class.getDeclaredConstructors();
- assertThat(cons.length).isEqualTo(1);
- assertThat(Modifier.isPublic(cons[0].getModifiers())).isTrue();
- assertThat(Modifier.isPublic(WordUtils.class.getModifiers())).isTrue();
- assertThat(Modifier.isFinal(WordUtils.class.getModifiers())).isFalse();
+ assertEquals(1, cons.length);
+ assertTrue(Modifier.isPublic(cons[0].getModifiers()));
+ assertTrue(Modifier.isPublic(WordUtils.class.getModifiers()));
+ assertFalse(Modifier.isFinal(WordUtils.class.getModifiers()));
}
@Test
@@ -200,185 +201,178 @@ public class WordUtilsTest {
@Test
public void testContainsAllWordsWithNull() {
- assertThat(WordUtils.containsAllWords("M", (CharSequence) null)).isFalse();
+ assertFalse(WordUtils.containsAllWords("M", (CharSequence) null));
}
- @Test
+ @Test
public void testInitials_String() {
- assertThat(WordUtils.initials(null)).isNull();
- assertThat(WordUtils.initials("")).isEqualTo("");
- assertThat(WordUtils.initials(" ")).isEqualTo("");
+ assertNull(WordUtils.initials(null));
+ assertEquals("", WordUtils.initials(""));
+ assertEquals("", WordUtils.initials(" "));
- assertThat(WordUtils.initials("I")).isEqualTo("I");
- assertThat(WordUtils.initials("i")).isEqualTo("i");
- assertThat(WordUtils.initials("Ben John Lee")).isEqualTo("BJL");
- assertThat(WordUtils.initials(" Ben \n John\tLee\t")).isEqualTo("BJL");
- assertThat(WordUtils.initials("Ben J.Lee")).isEqualTo("BJ");
- assertThat(WordUtils.initials(" Ben John . Lee")).isEqualTo("BJ.L");
- assertThat(WordUtils.initials("i am here 123")).isEqualTo("iah1");
+ assertEquals("I", WordUtils.initials("I"));
+ assertEquals("i", WordUtils.initials("i"));
+ assertEquals("BJL", WordUtils.initials("Ben John Lee"));
+ assertEquals("BJL", WordUtils.initials(" Ben \n John\tLee\t"));
+ assertEquals("BJ", WordUtils.initials("Ben J.Lee"));
+ assertEquals("BJ.L", WordUtils.initials(" Ben John . Lee"));
+ assertEquals("iah1", WordUtils.initials("i am here 123"));
}
- @Test
+ @Test
public void testInitials_String_charArray() {
char[] array = null;
- assertThat(WordUtils.initials(null, array)).isNull();
- assertThat(WordUtils.initials("", array)).isEqualTo("");
- assertThat(WordUtils.initials(" ", array)).isEqualTo("");
- assertThat(WordUtils.initials("I", array)).isEqualTo("I");
- assertThat(WordUtils.initials("i", array)).isEqualTo("i");
- assertThat(WordUtils.initials("SJC", array)).isEqualTo("S");
- assertThat(WordUtils.initials("Ben John Lee", array)).isEqualTo("BJL");
- assertThat(WordUtils.initials(" Ben \n John\tLee\t", array)).isEqualTo("BJL");
- assertThat(WordUtils.initials("Ben J.Lee", array)).isEqualTo("BJ");
- assertThat(WordUtils.initials(" Ben John . Lee", array)).isEqualTo("BJ.L");
- assertThat(WordUtils.initials("Kay O'Murphy", array)).isEqualTo("KO");
- assertThat(WordUtils.initials("i am here 123", array)).isEqualTo("iah1");
+ assertNull(WordUtils.initials(null, array));
+ assertEquals("", WordUtils.initials("", array));
+ assertEquals("", WordUtils.initials(" ", array));
+ assertEquals("I", WordUtils.initials("I", array));
+ assertEquals("i", WordUtils.initials("i", array));
+ assertEquals("S", WordUtils.initials("SJC", array));
+ assertEquals("BJL", WordUtils.initials("Ben John Lee", array));
+ assertEquals("BJL", WordUtils.initials(" Ben \n John\tLee\t", array));
+ assertEquals("BJ", WordUtils.initials("Ben J.Lee", array));
+ assertEquals("BJ.L", WordUtils.initials(" Ben John . Lee", array));
+ assertEquals("KO", WordUtils.initials("Kay O'Murphy", array));
+ assertEquals("iah1", WordUtils.initials("i am here 123", array));
array = ArrayUtils.EMPTY_CHAR_ARRAY;
- assertThat(WordUtils.initials(null, array)).isNull();
- assertThat(WordUtils.initials("", array)).isEqualTo("");
- assertThat(WordUtils.initials(" ", array)).isEqualTo("");
- assertThat(WordUtils.initials("I", array)).isEqualTo("");
- assertThat(WordUtils.initials("i", array)).isEqualTo("");
- assertThat(WordUtils.initials("SJC", array)).isEqualTo("");
- assertThat(WordUtils.initials("Ben John Lee", array)).isEqualTo("");
- assertThat(WordUtils.initials(" Ben \n John\tLee\t", array)).isEqualTo("");
- assertThat(WordUtils.initials("Ben J.Lee", array)).isEqualTo("");
- assertThat(WordUtils.initials(" Ben John . Lee", array)).isEqualTo("");
- assertThat(WordUtils.initials("Kay O'Murphy", array)).isEqualTo("");
- assertThat(WordUtils.initials("i am here 123", array)).isEqualTo("");
+ assertNull(WordUtils.initials(null, array));
+ assertEquals("", WordUtils.initials("", array));
+ assertEquals("", WordUtils.initials(" ", array));
+ assertEquals("", WordUtils.initials("I", array));
+ assertEquals("", WordUtils.initials("i", array));
+ assertEquals("", WordUtils.initials("SJC", array));
+ assertEquals("", WordUtils.initials("Ben John Lee", array));
+ assertEquals("", WordUtils.initials(" Ben \n John\tLee\t", array));
+ assertEquals("", WordUtils.initials("Ben J.Lee", array));
+ assertEquals("", WordUtils.initials(" Ben John . Lee", array));
+ assertEquals("", WordUtils.initials("Kay O'Murphy", array));
+ assertEquals("", WordUtils.initials("i am here 123", array));
array = " ".toCharArray();
- assertThat(WordUtils.initials(null, array)).isNull();
- assertThat(WordUtils.initials("", array)).isEqualTo("");
- assertThat(WordUtils.initials(" ", array)).isEqualTo("");
- assertThat(WordUtils.initials("I", array)).isEqualTo("I");
- assertThat(WordUtils.initials("i", array)).isEqualTo("i");
- assertThat(WordUtils.initials("SJC", array)).isEqualTo("S");
- assertThat(WordUtils.initials("Ben John Lee", array)).isEqualTo("BJL");
- assertThat(WordUtils.initials("Ben J.Lee", array)).isEqualTo("BJ");
- assertThat(WordUtils.initials(" Ben \n John\tLee\t", array)).isEqualTo("B\nJ");
- assertThat(WordUtils.initials(" Ben John . Lee", array)).isEqualTo("BJ.L");
- assertThat(WordUtils.initials("Kay O'Murphy", array)).isEqualTo("KO");
- assertThat(WordUtils.initials("i am here 123", array)).isEqualTo("iah1");
+ assertNull(WordUtils.initials(null, array));
+ assertEquals("", WordUtils.initials("", array));
+ assertEquals("", WordUtils.initials(" ", array));
+ assertEquals("I", WordUtils.initials("I", array));
+ assertEquals("i", WordUtils.initials("i", array));
+ assertEquals("S", WordUtils.initials("SJC", array));
+ assertEquals("BJL", WordUtils.initials("Ben John Lee", array));
+ assertEquals("BJ", WordUtils.initials("Ben J.Lee", array));
+ assertEquals("B\nJ", WordUtils.initials(" Ben \n John\tLee\t", array));
+ assertEquals("BJ.L", WordUtils.initials(" Ben John . Lee", array));
+ assertEquals("KO", WordUtils.initials("Kay O'Murphy", array));
+ assertEquals("iah1", WordUtils.initials("i am here 123", array));
array = " .".toCharArray();
- assertThat(WordUtils.initials(null, array)).isNull();
- assertThat(WordUtils.initials("", array)).isEqualTo("");
- assertThat(WordUtils.initials(" ", array)).isEqualTo("");
- assertThat(WordUtils.initials("I", array)).isEqualTo("I");
- assertThat(WordUtils.initials("i", array)).isEqualTo("i");
- assertThat(WordUtils.initials("SJC", array)).isEqualTo("S");
- assertThat(WordUtils.initials("Ben John Lee", array)).isEqualTo("BJL");
- assertThat(WordUtils.initials("Ben J.Lee", array)).isEqualTo("BJL");
- assertThat(WordUtils.initials(" Ben John . Lee", array)).isEqualTo("BJL");
- assertThat(WordUtils.initials("Kay O'Murphy", array)).isEqualTo("KO");
- assertThat(WordUtils.initials("i am here 123", array)).isEqualTo("iah1");
+ assertNull(WordUtils.initials(null, array));
+ assertEquals("", WordUtils.initials("", array));
+ assertEquals("", WordUtils.initials(" ", array));
+ assertEquals("I", WordUtils.initials("I", array));
+ assertEquals("i", WordUtils.initials("i", array));
+ assertEquals("S", WordUtils.initials("SJC", array));
+ assertEquals("BJL", WordUtils.initials("Ben John Lee", array));
+ assertEquals("BJL", WordUtils.initials("Ben J.Lee", array));
+ assertEquals("BJL", WordUtils.initials(" Ben John . Lee", array));
+ assertEquals("KO", WordUtils.initials("Kay O'Murphy", array));
+ assertEquals("iah1", WordUtils.initials("i am here 123", array));
array = " .'".toCharArray();
- assertThat(WordUtils.initials(null, array)).isNull();
- assertThat(WordUtils.initials("", array)).isEqualTo("");
- assertThat(WordUtils.initials(" ", array)).isEqualTo("");
- assertThat(WordUtils.initials("I", array)).isEqualTo("I");
- assertThat(WordUtils.initials("i", array)).isEqualTo("i");
- assertThat(WordUtils.initials("SJC", array)).isEqualTo("S");
- assertThat(WordUtils.initials("Ben John Lee", array)).isEqualTo("BJL");
- assertThat(WordUtils.initials("Ben J.Lee", array)).isEqualTo("BJL");
- assertThat(WordUtils.initials(" Ben John . Lee", array)).isEqualTo("BJL");
- assertThat(WordUtils.initials("Kay O'Murphy", array)).isEqualTo("KOM");
- assertThat(WordUtils.initials("i am here 123", array)).isEqualTo("iah1");
+ assertNull(WordUtils.initials(null, array));
+ assertEquals("", WordUtils.initials("", array));
+ assertEquals("", WordUtils.initials(" ", array));
+ assertEquals("I", WordUtils.initials("I", array));
+ assertEquals("i", WordUtils.initials("i", array));
+ assertEquals("S", WordUtils.initials("SJC", array));
+ assertEquals("BJL", WordUtils.initials("Ben John Lee", array));
+ assertEquals("BJL", WordUtils.initials("Ben J.Lee", array));
+ assertEquals("BJL", WordUtils.initials(" Ben John . Lee", array));
+ assertEquals("KOM", WordUtils.initials("Kay O'Murphy", array));
+ assertEquals("iah1", WordUtils.initials("i am here 123", array));
array = "SIJo1".toCharArray();
- assertThat(WordUtils.initials(null, array)).isNull();
- assertThat(WordUtils.initials("", array)).isEqualTo("");
- assertThat(WordUtils.initials(" ", array)).isEqualTo(" ");
- assertThat(WordUtils.initials("I", array)).isEqualTo("");
- assertThat(WordUtils.initials("i", array)).isEqualTo("i");
- assertThat(WordUtils.initials("SJC", array)).isEqualTo("C");
- assertThat(WordUtils.initials("Ben John Lee", array)).isEqualTo("Bh");
- assertThat(WordUtils.initials("Ben J.Lee", array)).isEqualTo("B.");
- assertThat(WordUtils.initials(" Ben John . Lee", array)).isEqualTo(" h");
- assertThat(WordUtils.initials("Kay O'Murphy", array)).isEqualTo("K");
- assertThat(WordUtils.initials("i am here 123", array)).isEqualTo("i2");
+ assertNull(WordUtils.initials(null, array));
+ assertEquals("", WordUtils.initials("", array));
+ assertEquals(" ", WordUtils.initials(" ", array));
+ assertEquals("", WordUtils.initials("I", array));
+ assertEquals("i", WordUtils.initials("i", array));
+ assertEquals("C", WordUtils.initials("SJC", array));
+ assertEquals("Bh", WordUtils.initials("Ben John Lee", array));
+ assertEquals("B.", WordUtils.initials("Ben J.Lee", array));
+ assertEquals(" h", WordUtils.initials(" Ben John . Lee", array));
+ assertEquals("K", WordUtils.initials("Kay O'Murphy", array));
+ assertEquals("i2", WordUtils.initials("i am here 123", array));
}
@Test
public void testInitialsSurrogatePairs() {
// Tests with space as default delimiter
- assertThat(WordUtils.initials("\uD800\uDF00\uD800\uDF01 \uD800\uDF02\uD800\uDF03"))
- .isEqualTo("\uD800\uDF00\uD800\uDF02");
- assertThat(WordUtils.initials("\uD800\uDF00\uD800\uDF01 \uD800\uDF02\uD800\uDF03", null))
- .isEqualTo("\uD800\uDF00\uD800\uDF02");
- assertThat(WordUtils.initials("\uD800\uDF00 \uD800\uDF02 ", null)).isEqualTo("\uD800\uDF00\uD800\uDF02");
+ assertEquals("\uD800\uDF00\uD800\uDF02", WordUtils.initials("\uD800\uDF00\uD800\uDF01 \uD800\uDF02\uD800\uDF03"));
+ assertEquals("\uD800\uDF00\uD800\uDF02", WordUtils.initials("\uD800\uDF00\uD800\uDF01 \uD800\uDF02\uD800\uDF03", null));
+ assertEquals("\uD800\uDF00\uD800\uDF02", WordUtils.initials("\uD800\uDF00 \uD800\uDF02 ", null));
// Tests with UTF-16 as delimiters
- assertThat(WordUtils.initials("\uD800\uDF00\uD800\uDF01.\uD800\uDF02\uD800\uDF03", new char[] {'.'}))
- .isEqualTo("\uD800\uDF00\uD800\uDF02");
- assertThat(WordUtils.initials("\uD800\uDF00\uD800\uDF01A\uD800\uDF02\uD800\uDF03", new char[] {'A'}))
- .isEqualTo("\uD800\uDF00\uD800\uDF02");
+ assertEquals("\uD800\uDF00\uD800\uDF02", WordUtils.initials("\uD800\uDF00\uD800\uDF01.\uD800\uDF02\uD800\uDF03", new char[] { '.' }));
+ assertEquals("\uD800\uDF00\uD800\uDF02", WordUtils.initials("\uD800\uDF00\uD800\uDF01A\uD800\uDF02\uD800\uDF03", new char[] { 'A' }));
// Tests with UTF-32 as delimiters
- assertThat(WordUtils.initials(
- "\uD800\uDF00\uD800\uDF01\uD800\uDF14\uD800\uDF02\uD800\uDF03", new char[] {'\uD800', '\uDF14'}))
- .isEqualTo("\uD800\uDF00\uD800\uDF02");
- assertThat(WordUtils.initials("\uD800\uDF00\uD800\uDF01\uD800\uDF14\uD800\uDF18\uD800\uDF02\uD800\uDF03",
- new char[] {'\uD800', '\uDF14', '\uD800', '\uDF18'}))
- .isEqualTo("\uD800\uDF00\uD800\uDF02");
+ assertEquals("\uD800\uDF00\uD800\uDF02",
+ WordUtils.initials("\uD800\uDF00\uD800\uDF01\uD800\uDF14\uD800\uDF02\uD800\uDF03", new char[] { '\uD800', '\uDF14' }));
+ assertEquals("\uD800\uDF00\uD800\uDF02", WordUtils.initials("\uD800\uDF00\uD800\uDF01\uD800\uDF14\uD800\uDF18\uD800\uDF02\uD800\uDF03",
+ new char[] { '\uD800', '\uDF14', '\uD800', '\uDF18' }));
}
@Test
public void testLANG1292() {
// Prior to fix, this was throwing StringIndexOutOfBoundsException
- WordUtils.wrap("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
- + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
- + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 70);
+ WordUtils.wrap("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ 70);
}
@Test
public void testLANG673() {
- assertThat(WordUtils.abbreviate("01 23 45 67 89", 0, 40, "")).isEqualTo("01");
- assertThat(WordUtils.abbreviate("01 23 45 67 89", 10, 40, "")).isEqualTo("01 23 45 67");
- assertThat(WordUtils.abbreviate("01 23 45 67 89", 40, 40, "")).isEqualTo("01 23 45 67 89");
+ assertEquals("01", WordUtils.abbreviate("01 23 45 67 89", 0, 40, ""));
+ assertEquals("01 23 45 67", WordUtils.abbreviate("01 23 45 67 89", 10, 40, ""));
+ assertEquals("01 23 45 67 89", WordUtils.abbreviate("01 23 45 67 89", 40, 40, ""));
}
- @Test
+ @Test
public void testSwapCase_String() {
- assertThat(WordUtils.swapCase(null)).isNull();
- assertThat(WordUtils.swapCase("")).isEqualTo("");
- assertThat(WordUtils.swapCase(" ")).isEqualTo(" ");
+ assertNull(WordUtils.swapCase(null));
+ assertEquals("", WordUtils.swapCase(""));
+ assertEquals(" ", WordUtils.swapCase(" "));
- assertThat(WordUtils.swapCase("I")).isEqualTo("i");
- assertThat(WordUtils.swapCase("i")).isEqualTo("I");
- assertThat(WordUtils.swapCase("i am here 123")).isEqualTo("I AM HERE 123");
- assertThat(WordUtils.swapCase("I Am Here 123")).isEqualTo("i aM hERE 123");
- assertThat(WordUtils.swapCase("i am HERE 123")).isEqualTo("I AM here 123");
- assertThat(WordUtils.swapCase("I AM HERE 123")).isEqualTo("i am here 123");
+ assertEquals("i", WordUtils.swapCase("I"));
+ assertEquals("I", WordUtils.swapCase("i"));
+ assertEquals("I AM HERE 123", WordUtils.swapCase("i am here 123"));
+ assertEquals("i aM hERE 123", WordUtils.swapCase("I Am Here 123"));
+ assertEquals("I AM here 123", WordUtils.swapCase("i am HERE 123"));
+ assertEquals("i am here 123", WordUtils.swapCase("I AM HERE 123"));
final String test = "This String contains a TitleCase character: \u01C8";
final String expect = "tHIS sTRING CONTAINS A tITLEcASE CHARACTER: \u01C9";
- assertThat(WordUtils.swapCase(test)).isEqualTo(expect);
+ assertEquals(expect, WordUtils.swapCase(test));
}
@Test
public void testText123() throws Exception {
// Prior to fix, this was throwing StringIndexOutOfBoundsException
- WordUtils.wrap("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
- + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Integer.MAX_VALUE);
+ WordUtils.wrap("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ Integer.MAX_VALUE);
}
@Test
public void testUncapitalize_String() {
- assertThat(WordUtils.uncapitalize(null)).isNull();
- assertThat(WordUtils.uncapitalize("")).isEqualTo("");
- assertThat(WordUtils.uncapitalize(" ")).isEqualTo(" ");
- assertThat(WordUtils.uncapitalize("I")).isEqualTo("i");
- assertThat(WordUtils.uncapitalize("i")).isEqualTo("i");
- assertThat(WordUtils.uncapitalize("i am here 123")).isEqualTo("i am here 123");
- assertThat(WordUtils.uncapitalize("I Am Here 123")).isEqualTo("i am here 123");
- assertThat(WordUtils.uncapitalize("i am HERE 123")).isEqualTo("i am hERE 123");
- assertThat(WordUtils.uncapitalize("I AM HERE 123")).isEqualTo("i aM hERE 123");
- assertThat(WordUtils.uncapitalize("A\tB\nC D")).isEqualTo("a\tb\nc d");
- assertThat(WordUtils.uncapitalize("And \tBut \nCLEAT Dome")).isEqualTo("and \tbut \ncLEAT dome");
+ assertNull(WordUtils.uncapitalize(null));
+ assertEquals("", WordUtils.uncapitalize(""));
+ assertEquals(" ", WordUtils.uncapitalize(" "));
+ assertEquals("i", WordUtils.uncapitalize("I"));
+ assertEquals("i", WordUtils.uncapitalize("i"));
+ assertEquals("i am here 123", WordUtils.uncapitalize("i am here 123"));
+ assertEquals("i am here 123", WordUtils.uncapitalize("I Am Here 123"));
+ assertEquals("i am hERE 123", WordUtils.uncapitalize("i am HERE 123"));
+ assertEquals("i aM hERE 123", WordUtils.uncapitalize("I AM HERE 123"));
+ assertEquals("a\tb\nc d", WordUtils.uncapitalize("A\tB\nC D"));
+ assertEquals("and \tbut \ncLEAT dome", WordUtils.uncapitalize("And \tBut \nCLEAT Dome"));
// All whitespace
assertEquals(WHITESPACE, WordUtils.capitalizeFully(WHITESPACE));
assertEquals("A" + WHITESPACE + "B", WordUtils.capitalizeFully("a" + WHITESPACE + "b"));
@@ -386,136 +380,132 @@ public class WordUtilsTest {
@Test
public void testUnCapitalize_Text88() {
- assertThat(WordUtils.uncapitalize("I am fine now", new char[] {})).isEqualTo("i am fine now");
+ assertEquals("i am fine now", WordUtils.uncapitalize("I am fine now", new char[] {}));
}
@Test
public void testUncapitalizeWithDelimiters_String() {
- assertThat(WordUtils.uncapitalize(null, null)).isNull();
- assertThat(WordUtils.uncapitalize("", ArrayUtils.EMPTY_CHAR_ARRAY)).isEqualTo("");
- assertThat(WordUtils.uncapitalize(" ", ArrayUtils.EMPTY_CHAR_ARRAY)).isEqualTo(" ");
-
- char[] chars = {'-', '+', ' ', '@'};
- assertThat(WordUtils.uncapitalize("I", chars)).isEqualTo("i");
- assertThat(WordUtils.uncapitalize("i", chars)).isEqualTo("i");
- assertThat(WordUtils.uncapitalize("i am-here+123", chars)).isEqualTo("i am-here+123");
- assertThat(WordUtils.uncapitalize("I+Am Here-123", chars)).isEqualTo("i+am here-123");
- assertThat(WordUtils.uncapitalize("i-am+HERE 123", chars)).isEqualTo("i-am+hERE 123");
- assertThat(WordUtils.uncapitalize("I AM-HERE+123", chars)).isEqualTo("i aM-hERE+123");
- chars = new char[] {'.'};
- assertThat(WordUtils.uncapitalize("I AM.FINE", chars)).isEqualTo("i AM.fINE");
- assertThat(WordUtils.uncapitalize("I AM.FINE", null)).isEqualTo("i aM.FINE");
- }
-
- @Test
+ assertNull(WordUtils.uncapitalize(null, null));
+ assertEquals("", WordUtils.uncapitalize("", ArrayUtils.EMPTY_CHAR_ARRAY));
+ assertEquals(" ", WordUtils.uncapitalize(" ", ArrayUtils.EMPTY_CHAR_ARRAY));
+
+ char[] chars = { '-', '+', ' ', '@' };
+ assertEquals("i", WordUtils.uncapitalize("I", chars));
+ assertEquals("i", WordUtils.uncapitalize("i", chars));
+ assertEquals("i am-here+123", WordUtils.uncapitalize("i am-here+123", chars));
+ assertEquals("i+am here-123", WordUtils.uncapitalize("I+Am Here-123", chars));
+ assertEquals("i-am+hERE 123", WordUtils.uncapitalize("i-am+HERE 123", chars));
+ assertEquals("i aM-hERE+123", WordUtils.uncapitalize("I AM-HERE+123", chars));
+ chars = new char[] { '.' };
+ assertEquals("i AM.fINE", WordUtils.uncapitalize("I AM.FINE", chars));
+ assertEquals("i aM.FINE", WordUtils.uncapitalize("I AM.FINE", null));
+ }
+
+ @Test
public void testWrap_StringInt() {
- assertThat(WordUtils.wrap(null, 20)).isNull();
- assertThat(WordUtils.wrap(null, -1)).isNull();
+ assertNull(WordUtils.wrap(null, 20));
+ assertNull(WordUtils.wrap(null, -1));
- assertThat(WordUtils.wrap("", 20)).isEqualTo("");
- assertThat(WordUtils.wrap("", -1)).isEqualTo("");
+ assertEquals("", WordUtils.wrap("", 20));
+ assertEquals("", WordUtils.wrap("", -1));
// normal
final String systemNewLine = System.lineSeparator();
String input = "Here is one line of text that is going to be wrapped after 20 columns.";
- String expected = "Here is one line of" + systemNewLine + "text that is going" + systemNewLine
- + "to be wrapped after" + systemNewLine + "20 columns.";
- assertThat(WordUtils.wrap(input, 20)).isEqualTo(expected);
+ String expected = "Here is one line of" + systemNewLine + "text that is going" + systemNewLine + "to be wrapped after" + systemNewLine + "20 columns.";
+ assertEquals(expected, WordUtils.wrap(input, 20));
// long word at end
input = "Click here to jump to the commons website - https://commons.apache.org";
- expected = "Click here to jump" + systemNewLine + "to the commons" + systemNewLine + "website -" + systemNewLine
- + "https://commons.apache.org";
- assertThat(WordUtils.wrap(input, 20)).isEqualTo(expected);
+ expected = "Click here to jump" + systemNewLine + "to the commons" + systemNewLine + "website -" + systemNewLine + "https://commons.apache.org";
+ assertEquals(expected, WordUtils.wrap(input, 20));
// long word in middle
input = "Click here, https://commons.apache.org, to jump to the commons website";
- expected = "Click here," + systemNewLine + "https://commons.apache.org," + systemNewLine + "to jump to the"
- + systemNewLine + "commons website";
- assertThat(WordUtils.wrap(input, 20)).isEqualTo(expected);
+ expected = "Click here," + systemNewLine + "https://commons.apache.org," + systemNewLine + "to jump to the" + systemNewLine + "commons website";
+ assertEquals(expected, WordUtils.wrap(input, 20));
// leading spaces on a new line are stripped
// trailing spaces are not stripped
input = "word1 word2 word3";
expected = "word1 " + systemNewLine + "word2 " + systemNewLine + "word3";
- assertThat(WordUtils.wrap(input, 7)).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 7));
}
@Test
public void testWrap_StringIntStringBoolean() {
- assertThat(WordUtils.wrap(null, 20, "\n", false)).isNull();
- assertThat(WordUtils.wrap(null, 20, "\n", true)).isNull();
- assertThat(WordUtils.wrap(null, 20, null, true)).isNull();
- assertThat(WordUtils.wrap(null, 20, null, false)).isNull();
- assertThat(WordUtils.wrap(null, -1, null, true)).isNull();
- assertThat(WordUtils.wrap(null, -1, null, false)).isNull();
-
- assertThat(WordUtils.wrap("", 20, "\n", false)).isEqualTo("");
- assertThat(WordUtils.wrap("", 20, "\n", true)).isEqualTo("");
- assertThat(WordUtils.wrap("", 20, null, false)).isEqualTo("");
- assertThat(WordUtils.wrap("", 20, null, true)).isEqualTo("");
- assertThat(WordUtils.wrap("", -1, null, false)).isEqualTo("");
- assertThat(WordUtils.wrap("", -1, null, true)).isEqualTo("");
+ assertNull(WordUtils.wrap(null, 20, "\n", false));
+ assertNull(WordUtils.wrap(null, 20, "\n", true));
+ assertNull(WordUtils.wrap(null, 20, null, true));
+ assertNull(WordUtils.wrap(null, 20, null, false));
+ assertNull(WordUtils.wrap(null, -1, null, true));
+ assertNull(WordUtils.wrap(null, -1, null, false));
+
+ assertEquals("", WordUtils.wrap("", 20, "\n", false));
+ assertEquals("", WordUtils.wrap("", 20, "\n", true));
+ assertEquals("", WordUtils.wrap("", 20, null, false));
+ assertEquals("", WordUtils.wrap("", 20, null, true));
+ assertEquals("", WordUtils.wrap("", -1, null, false));
+ assertEquals("", WordUtils.wrap("", -1, null, true));
// normal
String input = "Here is one line of text that is going to be wrapped after 20 columns.";
String expected = "Here is one line of\ntext that is going\nto be wrapped after\n20 columns.";
- assertThat(WordUtils.wrap(input, 20, "\n", false)).isEqualTo(expected);
- assertThat(WordUtils.wrap(input, 20, "\n", true)).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 20, "\n", false));
+ assertEquals(expected, WordUtils.wrap(input, 20, "\n", true));
// unusual newline char
input = "Here is one line of text that is going to be wrapped after 20 columns.";
expected = "Here is one line of<br />text that is going<br />to be wrapped after<br />20 columns.";
- assertThat(WordUtils.wrap(input, 20, "<br />", false)).isEqualTo(expected);
- assertThat(WordUtils.wrap(input, 20, "<br />", true)).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 20, "<br />", false));
+ assertEquals(expected, WordUtils.wrap(input, 20, "<br />", true));
// short line length
input = "Here is one line";
expected = "Here\nis one\nline";
- assertThat(WordUtils.wrap(input, 6, "\n", false)).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 6, "\n", false));
expected = "Here\nis\none\nline";
- assertThat(WordUtils.wrap(input, 2, "\n", false)).isEqualTo(expected);
- assertThat(WordUtils.wrap(input, -1, "\n", false)).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 2, "\n", false));
+ assertEquals(expected, WordUtils.wrap(input, -1, "\n", false));
// system newline char
final String systemNewLine = System.lineSeparator();
input = "Here is one line of text that is going to be wrapped after 20 columns.";
- expected = "Here is one line of" + systemNewLine + "text that is going" + systemNewLine + "to be wrapped after"
- + systemNewLine + "20 columns.";
- assertThat(WordUtils.wrap(input, 20, null, false)).isEqualTo(expected);
- assertThat(WordUtils.wrap(input, 20, null, true)).isEqualTo(expected);
+ expected = "Here is one line of" + systemNewLine + "text that is going" + systemNewLine + "to be wrapped after" + systemNewLine + "20 columns.";
+ assertEquals(expected, WordUtils.wrap(input, 20, null, false));
+ assertEquals(expected, WordUtils.wrap(input, 20, null, true));
// with extra spaces
input = " Here: is one line of text that is going to be wrapped after 20 columns.";
expected = "Here: is one line\nof text that is \ngoing to be \nwrapped after 20 \ncolumns.";
- assertThat(WordUtils.wrap(input, 20, "\n", false)).isEqualTo(expected);
- assertThat(WordUtils.wrap(input, 20, "\n", true)).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 20, "\n", false));
+ assertEquals(expected, WordUtils.wrap(input, 20, "\n", true));
// with tab
input = "Here is\tone line of text that is going to be wrapped after 20 columns.";
expected = "Here is\tone line of\ntext that is going\nto be wrapped after\n20 columns.";
- assertThat(WordUtils.wrap(input, 20, "\n", false)).isEqualTo(expected);
- assertThat(WordUtils.wrap(input, 20, "\n", true)).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 20, "\n", false));
+ assertEquals(expected, WordUtils.wrap(input, 20, "\n", true));
// with tab at wrapColumn
input = "Here is one line of\ttext that is going to be wrapped after 20 columns.";
expected = "Here is one line\nof\ttext that is\ngoing to be wrapped\nafter 20 columns.";
- assertThat(WordUtils.wrap(input, 20, "\n", false)).isEqualTo(expected);
- assertThat(WordUtils.wrap(input, 20, "\n", true)).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 20, "\n", false));
+ assertEquals(expected, WordUtils.wrap(input, 20, "\n", true));
// difference because of long word
input = "Click here to jump to the commons website - https://commons.apache.org";
expected = "Click here to jump\nto the commons\nwebsite -\nhttps://commons.apache.org";
- assertThat(WordUtils.wrap(input, 20, "\n", false)).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 20, "\n", false));
expected = "Click here to jump\nto the commons\nwebsite -\nhttps://commons.apac\nhe.org";
- assertThat(WordUtils.wrap(input, 20, "\n", true)).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 20, "\n", true));
// difference because of long word in middle
input = "Click here, https://commons.apache.org, to jump to the commons website";
expected = "Click here,\nhttps://commons.apache.org,\nto jump to the\ncommons website";
- assertThat(WordUtils.wrap(input, 20, "\n", false)).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 20, "\n", false));
expected = "Click here,\nhttps://commons.apac\nhe.org, to jump to\nthe commons website";
- assertThat(WordUtils.wrap(input, 20, "\n", true)).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 20, "\n", true));
}
@Test
@@ -524,44 +514,44 @@ public class WordUtilsTest {
// no changes test
String input = "flammable/inflammable";
String expected = "flammable/inflammable";
- assertThat(WordUtils.wrap(input, 30, "\n", false, "/")).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 30, "\n", false, "/"));
// wrap on / and small width
expected = "flammable\ninflammable";
- assertThat(WordUtils.wrap(input, 2, "\n", false, "/")).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 2, "\n", false, "/"));
// wrap long words on / 1
expected = "flammable\ninflammab\nle";
- assertThat(WordUtils.wrap(input, 9, "\n", true, "/")).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 9, "\n", true, "/"));
// wrap long words on / 2
expected = "flammable\ninflammable";
- assertThat(WordUtils.wrap(input, 15, "\n", true, "/")).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 15, "\n", true, "/"));
// wrap long words on / 3
input = "flammableinflammable";
expected = "flammableinflam\nmable";
- assertThat(WordUtils.wrap(input, 15, "\n", true, "/")).isEqualTo(expected);
+ assertEquals(expected, WordUtils.wrap(input, 15, "\n", true, "/"));
}
@Test
public void testWrapAtMiddleTwice() {
- assertThat(WordUtils.wrap("abcdefggabcdef", 2, "\n", false, "(?=g)")).isEqualTo("abcdef\n\nabcdef");
+ assertEquals("abcdef\n\nabcdef", WordUtils.wrap("abcdefggabcdef", 2, "\n", false, "(?=g)"));
}
@Test
public void testWrapAtStartAndEnd() {
- assertThat(WordUtils.wrap("nabcdefabcdefn", 2, "\n", false, "(?=n)")).isEqualTo("\nabcdefabcdef\n");
+ assertEquals("\nabcdefabcdef\n", WordUtils.wrap("nabcdefabcdefn", 2, "\n", false, "(?=n)"));
}
@Test
public void testWrapWithMultipleRegexMatchOfLength0() {
- assertThat(WordUtils.wrap("abcdefabcdef", 2, "\n", false, "(?=d)")).isEqualTo("abc\ndefabc\ndef");
+ assertEquals("abc\ndefabc\ndef", WordUtils.wrap("abcdefabcdef", 2, "\n", false, "(?=d)"));
}
@Test
public void testWrapWithRegexMatchOfLength0() {
- assertThat(WordUtils.wrap("abcdef", 2, "\n", false, "(?=d)")).isEqualTo("abc\ndef");
+ assertEquals("abc\ndef", WordUtils.wrap("abcdef", 2, "\n", false, "(?=d)"));
}
}
diff --git a/src/test/java/org/apache/commons/text/diff/ReplacementsFinderTest.java b/src/test/java/org/apache/commons/text/diff/ReplacementsFinderTest.java
index b9e24755..8491effd 100644
--- a/src/test/java/org/apache/commons/text/diff/ReplacementsFinderTest.java
+++ b/src/test/java/org/apache/commons/text/diff/ReplacementsFinderTest.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.text.diff;
-import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.ArrayList;
import java.util.List;
@@ -86,7 +86,7 @@ public class ReplacementsFinderTest {
final StringsComparator sc = new StringsComparator(left, right);
final ReplacementsFinder<Character> replacementFinder = new ReplacementsFinder<>(handler);
sc.getScript().visit(replacementFinder);
- assertThat(handler.getSkipped()).as("Skipped characters do not match").isEqualTo(skipped);
+ assertEquals(skipped, handler.getSkipped(), "Skipped characters do not match");
assertArrayEquals(handler.getFrom().toArray(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY), from,
"From characters do not match");
assertArrayEquals(to, handler.getTo().toArray(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY),
diff --git a/src/test/java/org/apache/commons/text/diff/StringsComparatorTest.java b/src/test/java/org/apache/commons/text/diff/StringsComparatorTest.java
index 29326ce8..5a82945b 100644
--- a/src/test/java/org/apache/commons/text/diff/StringsComparatorTest.java
+++ b/src/test/java/org/apache/commons/text/diff/StringsComparatorTest.java
@@ -15,7 +15,8 @@
* limitations under the License.
*/
package org.apache.commons.text.diff;
-import static org.assertj.core.api.Assertions.assertThat;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.Arrays;
import java.util.List;
@@ -118,7 +119,7 @@ public class StringsComparatorTest {
for (int i = 0; i < before.size(); ++i) {
final ExecutionVisitor<Character> ev = new ExecutionVisitor<>();
new StringsComparator(before.get(i), after.get(i)).getScript().visit(ev);
- assertThat(ev.getString()).isEqualTo(after.get(i));
+ assertEquals(after.get(i), ev.getString());
}
}
@@ -126,14 +127,14 @@ public class StringsComparatorTest {
public void testLength() {
for (int i = 0; i < before.size(); ++i) {
final StringsComparator comparator = new StringsComparator(before.get(i), after.get(i));
- assertThat(comparator.getScript().getModifications()).isEqualTo(length[i]);
+ assertEquals(length[i], comparator.getScript().getModifications());
}
}
@Test
public void testLongestCommonSubsequence() {
for (int i = 0; i < before.size(); ++i) {
final StringsComparator comparator = new StringsComparator(before.get(i), after.get(i));
- assertThat(comparator.getScript().getLCSLength()).isEqualTo(lcs[i]);
+ assertEquals(lcs[i], comparator.getScript().getLCSLength());
}
}
}
diff --git a/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharArrayTest.java b/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharArrayTest.java
index 70143010..1d982df2 100644
--- a/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharArrayTest.java
+++ b/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharArrayTest.java
@@ -16,8 +16,9 @@
*/
package org.apache.commons.text.matcher;
-import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertSame;
import org.junit.jupiter.api.Test;
@@ -33,31 +34,30 @@ public class StringMatcherOnCharArrayTest {
private static final int INPUT2_LENGTH = INPUT2.length;
private void checkAndMatcher_char(final StringMatcher matcher) {
- assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(3);
- assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
+ assertEquals(3, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
//
- assertThat(matcher.isMatch(INPUT2, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(3);
- assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT2, 0));
+ assertEquals(0, matcher.isMatch(INPUT2, 1));
+ assertEquals(3, matcher.isMatch(INPUT2, 2));
+ assertEquals(0, matcher.isMatch(INPUT2, 3));
+ assertEquals(0, matcher.isMatch(INPUT2, 4));
+ assertEquals(0, matcher.isMatch(INPUT2, 5));
}
@Test
public void testAndMatcher_char() {
- final StringMatcher matcher1 = StringMatcherFactory.INSTANCE.andMatcher(
- StringMatcherFactory.INSTANCE.charMatcher('c'), StringMatcherFactory.INSTANCE.stringMatcher("de"));
+ final StringMatcher matcher1 = StringMatcherFactory.INSTANCE.andMatcher(StringMatcherFactory.INSTANCE.charMatcher('c'),
+ StringMatcherFactory.INSTANCE.stringMatcher("de"));
assertEquals(3, matcher1.size());
checkAndMatcher_char(matcher1);
//
- final StringMatcher matcher2 = StringMatcherFactory.INSTANCE.andMatcher(null,
- StringMatcherFactory.INSTANCE.charMatcher('c'), null, StringMatcherFactory.INSTANCE.stringMatcher("de"),
- null);
+ final StringMatcher matcher2 = StringMatcherFactory.INSTANCE.andMatcher(null, StringMatcherFactory.INSTANCE.charMatcher('c'), null,
+ StringMatcherFactory.INSTANCE.stringMatcher("de"), null);
assertEquals(3, matcher2.size());
checkAndMatcher_char(matcher2);
}
@@ -67,19 +67,19 @@ public class StringMatcherOnCharArrayTest {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.charMatcher('c');
assertEquals(1, matcher.size());
//
- assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
+ assertEquals(1, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
//
- assertThat(matcher.isMatch(INPUT2, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT2, 0));
+ assertEquals(0, matcher.isMatch(INPUT2, 1));
+ assertEquals(1, matcher.isMatch(INPUT2, 2));
+ assertEquals(0, matcher.isMatch(INPUT2, 3));
+ assertEquals(0, matcher.isMatch(INPUT2, 4));
+ assertEquals(0, matcher.isMatch(INPUT2, 5));
}
@Test
@@ -87,26 +87,23 @@ public class StringMatcherOnCharArrayTest {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.charSetMatcher("ace".toCharArray());
assertEquals(1, matcher.size());
//
- assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertEquals(1, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
+ assertEquals(1, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
+ assertEquals(1, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
//
- assertThat(matcher.isMatch(INPUT2, 0)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
+ assertEquals(1, matcher.isMatch(INPUT2, 0));
+ assertEquals(0, matcher.isMatch(INPUT2, 1));
+ assertEquals(1, matcher.isMatch(INPUT2, 2));
+ assertEquals(0, matcher.isMatch(INPUT2, 3));
+ assertEquals(1, matcher.isMatch(INPUT2, 4));
+ assertEquals(0, matcher.isMatch(INPUT2, 5));
//
- assertThat(StringMatcherFactory.INSTANCE.charSetMatcher())
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
- assertThat(StringMatcherFactory.INSTANCE.charSetMatcher((char[]) null))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
- assertThat(StringMatcherFactory.INSTANCE
- .charSetMatcher("a".toCharArray()) instanceof AbstractStringMatcher.CharMatcher).isTrue();
+ assertSame(StringMatcherFactory.INSTANCE.charSetMatcher(), StringMatcherFactory.INSTANCE.noneMatcher());
+ assertSame(StringMatcherFactory.INSTANCE.charSetMatcher((char[]) null), StringMatcherFactory.INSTANCE.noneMatcher());
+ assertInstanceOf(AbstractStringMatcher.CharMatcher.class, StringMatcherFactory.INSTANCE.charSetMatcher("a".toCharArray()));
}
@Test
@@ -114,54 +111,51 @@ public class StringMatcherOnCharArrayTest {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.charSetMatcher("ace");
assertEquals(1, matcher.size());
//
- assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertEquals(1, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
+ assertEquals(1, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
+ assertEquals(1, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
//
- assertThat(matcher.isMatch(INPUT2, 0)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
+ assertEquals(1, matcher.isMatch(INPUT2, 0));
+ assertEquals(0, matcher.isMatch(INPUT2, 1));
+ assertEquals(1, matcher.isMatch(INPUT2, 2));
+ assertEquals(0, matcher.isMatch(INPUT2, 3));
+ assertEquals(1, matcher.isMatch(INPUT2, 4));
+ assertEquals(0, matcher.isMatch(INPUT2, 5));
//
- assertThat(StringMatcherFactory.INSTANCE.charSetMatcher(""))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
- assertThat(StringMatcherFactory.INSTANCE.charSetMatcher((String) null))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
- assertThat(StringMatcherFactory.INSTANCE.charSetMatcher("a") instanceof AbstractStringMatcher.CharMatcher)
- .isTrue();
+ assertSame(StringMatcherFactory.INSTANCE.charSetMatcher(""), StringMatcherFactory.INSTANCE.noneMatcher());
+ assertSame(StringMatcherFactory.INSTANCE.charSetMatcher((String) null), StringMatcherFactory.INSTANCE.noneMatcher());
+ assertInstanceOf(AbstractStringMatcher.CharMatcher.class, StringMatcherFactory.INSTANCE.charSetMatcher("a"));
}
@Test
public void testCommaMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.commaMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.commaMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.commaMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 0, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 1, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 0, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 1, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length));
//
- assertThat(matcher.isMatch(INPUT1, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 1)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 0));
+ assertEquals(1, matcher.isMatch(INPUT1, 1));
+ assertEquals(0, matcher.isMatch(INPUT1, 2));
}
@Test
public void testDoubleQuoteMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.doubleQuoteMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.doubleQuoteMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.doubleQuoteMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 11, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 12, 0, INPUT1.length)).isEqualTo(1);
+ assertEquals(0, matcher.isMatch(INPUT1, 11, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 12, 0, INPUT1.length));
//
- assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(1);
+ assertEquals(0, matcher.isMatch(INPUT1, 11));
+ assertEquals(1, matcher.isMatch(INPUT1, 12));
}
@Test
@@ -171,145 +165,143 @@ public class StringMatcherOnCharArrayTest {
// the concern of StringMatcher, and are not bugs
final StringMatcher matcher = StringMatcherFactory.INSTANCE.stringMatcher("bc");
assertEquals(2, matcher.size());
- assertThat(matcher.isMatch(INPUT2, 1, 1, INPUT2_LENGTH)).isEqualTo(2);
- assertThat(matcher.isMatch(INPUT2, 1, 0, 3)).isEqualTo(2);
- assertThat(matcher.isMatch(INPUT2, 1, 0, 2)).isEqualTo(0);
+ assertEquals(2, matcher.isMatch(INPUT2, 1, 1, INPUT2_LENGTH));
+ assertEquals(2, matcher.isMatch(INPUT2, 1, 0, 3));
+ assertEquals(0, matcher.isMatch(INPUT2, 1, 0, 2));
}
@Test
public void testNoneMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.noneMatcher();
assertEquals(0, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.noneMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.noneMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 0, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 1, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 6, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 7, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 8, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 9, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 11, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 12, 0, INPUT1.length)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 0, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 1, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 3, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 5, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 6, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 7, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 8, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 9, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 10, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 11, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 12, 0, INPUT1.length));
//
- assertThat(matcher.isMatch(INPUT1, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 1)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 7)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 8)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 9)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 0));
+ assertEquals(0, matcher.isMatch(INPUT1, 1));
+ assertEquals(0, matcher.isMatch(INPUT1, 2));
+ assertEquals(0, matcher.isMatch(INPUT1, 3));
+ assertEquals(0, matcher.isMatch(INPUT1, 4));
+ assertEquals(0, matcher.isMatch(INPUT1, 5));
+ assertEquals(0, matcher.isMatch(INPUT1, 6));
+ assertEquals(0, matcher.isMatch(INPUT1, 7));
+ assertEquals(0, matcher.isMatch(INPUT1, 8));
+ assertEquals(0, matcher.isMatch(INPUT1, 9));
+ assertEquals(0, matcher.isMatch(INPUT1, 10));
+ assertEquals(0, matcher.isMatch(INPUT1, 11));
+ assertEquals(0, matcher.isMatch(INPUT1, 12));
}
@Test
public void testQuoteMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.quoteMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.quoteMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.quoteMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 11, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 12, 0, INPUT1.length)).isEqualTo(1);
+ assertEquals(0, matcher.isMatch(INPUT1, 10, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 11, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 12, 0, INPUT1.length));
//
- assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(1);
+ assertEquals(0, matcher.isMatch(INPUT1, 10));
+ assertEquals(1, matcher.isMatch(INPUT1, 11));
+ assertEquals(1, matcher.isMatch(INPUT1, 12));
}
@Test
public void testSingleQuoteMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.singleQuoteMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.singleQuoteMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.singleQuoteMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 11, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 12, 0, INPUT1.length)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 10, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 11, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 12, 0, INPUT1.length));
//
- assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 10));
+ assertEquals(1, matcher.isMatch(INPUT1, 11));
+ assertEquals(0, matcher.isMatch(INPUT1, 12));
}
@Test
public void testSpaceMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.spaceMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.spaceMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.spaceMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 6, 0, INPUT1.length)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 5, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 6, 0, INPUT1.length));
//
- assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 4));
+ assertEquals(1, matcher.isMatch(INPUT1, 5));
+ assertEquals(0, matcher.isMatch(INPUT1, 6));
}
@Test
public void testSplitMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.splitMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.splitMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.splitMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 6, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 7, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 8, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 9, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 3, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 5, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 6, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 7, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 8, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 9, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 10, 0, INPUT1.length));
//
- assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 7)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 8)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 9)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 2));
+ assertEquals(1, matcher.isMatch(INPUT1, 3));
+ assertEquals(0, matcher.isMatch(INPUT1, 4));
+ assertEquals(1, matcher.isMatch(INPUT1, 5));
+ assertEquals(0, matcher.isMatch(INPUT1, 6));
+ assertEquals(1, matcher.isMatch(INPUT1, 7));
+ assertEquals(1, matcher.isMatch(INPUT1, 8));
+ assertEquals(1, matcher.isMatch(INPUT1, 9));
+ assertEquals(0, matcher.isMatch(INPUT1, 10));
}
private void testStringMatcher_String(final StringMatcher matcher) {
assertEquals(2, matcher.size());
//
- assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(2);
- assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
+ assertEquals(2, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
//
- assertThat(matcher.isMatch(INPUT2, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(2);
- assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT2, 0));
+ assertEquals(2, matcher.isMatch(INPUT2, 1));
+ assertEquals(0, matcher.isMatch(INPUT2, 2));
+ assertEquals(0, matcher.isMatch(INPUT2, 3));
+ assertEquals(0, matcher.isMatch(INPUT2, 4));
+ assertEquals(0, matcher.isMatch(INPUT2, 5));
//
- assertThat(StringMatcherFactory.INSTANCE.stringMatcher(""))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
- assertThat(StringMatcherFactory.INSTANCE.stringMatcher((String) null))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
+ assertSame(StringMatcherFactory.INSTANCE.stringMatcher(""), StringMatcherFactory.INSTANCE.noneMatcher());
+ assertSame(StringMatcherFactory.INSTANCE.stringMatcher((String) null), StringMatcherFactory.INSTANCE.noneMatcher());
}
@Test
public void testStringMatcher_String_fromChars() {
testStringMatcher_String(StringMatcherFactory.INSTANCE.stringMatcher('b', 'c'));
- testStringMatcher_String(StringMatcherFactory.INSTANCE.stringMatcher(new char[] {'b', 'c'}));
+ testStringMatcher_String(StringMatcherFactory.INSTANCE.stringMatcher(new char[] { 'b', 'c' }));
}
@Test
@@ -317,46 +309,46 @@ public class StringMatcherOnCharArrayTest {
testStringMatcher_String(StringMatcherFactory.INSTANCE.stringMatcher("bc"));
}
- @Test
+ @Test
public void testTabMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.tabMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.tabMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.tabMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 3, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length));
//
- assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 2));
+ assertEquals(1, matcher.isMatch(INPUT1, 3));
+ assertEquals(0, matcher.isMatch(INPUT1, 4));
}
@Test
public void testTrimMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.trimMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.trimMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.trimMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 6, 0, INPUT1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 7, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 8, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 9, 0, INPUT1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length)).isEqualTo(1);
+ assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 3, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 5, 0, INPUT1.length));
+ assertEquals(0, matcher.isMatch(INPUT1, 6, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 7, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 8, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 9, 0, INPUT1.length));
+ assertEquals(1, matcher.isMatch(INPUT1, 10, 0, INPUT1.length));
//
- assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 7)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 8)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 9)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(1);
+ assertEquals(0, matcher.isMatch(INPUT1, 2));
+ assertEquals(1, matcher.isMatch(INPUT1, 3));
+ assertEquals(0, matcher.isMatch(INPUT1, 4));
+ assertEquals(1, matcher.isMatch(INPUT1, 5));
+ assertEquals(0, matcher.isMatch(INPUT1, 6));
+ assertEquals(1, matcher.isMatch(INPUT1, 7));
+ assertEquals(1, matcher.isMatch(INPUT1, 8));
+ assertEquals(1, matcher.isMatch(INPUT1, 9));
+ assertEquals(1, matcher.isMatch(INPUT1, 10));
}
}
diff --git a/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharSequenceStringTest.java b/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharSequenceStringTest.java
index 1c71fe1c..cce37553 100644
--- a/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharSequenceStringTest.java
+++ b/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharSequenceStringTest.java
@@ -16,8 +16,9 @@
*/
package org.apache.commons.text.matcher;
-import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertSame;
import org.junit.jupiter.api.Test;
@@ -33,31 +34,30 @@ public class StringMatcherOnCharSequenceStringTest {
private static final int INPUT2_LENGTH = INPUT2.length();
private void checkAndMatcher_char(final StringMatcher matcher) {
- assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(3);
- assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
+ assertEquals(3, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
//
- assertThat(matcher.isMatch(INPUT2, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(3);
- assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT2, 0));
+ assertEquals(0, matcher.isMatch(INPUT2, 1));
+ assertEquals(3, matcher.isMatch(INPUT2, 2));
+ assertEquals(0, matcher.isMatch(INPUT2, 3));
+ assertEquals(0, matcher.isMatch(INPUT2, 4));
+ assertEquals(0, matcher.isMatch(INPUT2, 5));
}
@Test
public void testAndMatcher_char() {
- final StringMatcher matcher1 = StringMatcherFactory.INSTANCE.andMatcher(
- StringMatcherFactory.INSTANCE.charMatcher('c'), StringMatcherFactory.INSTANCE.stringMatcher("de"));
+ final StringMatcher matcher1 = StringMatcherFactory.INSTANCE.andMatcher(StringMatcherFactory.INSTANCE.charMatcher('c'),
+ StringMatcherFactory.INSTANCE.stringMatcher("de"));
assertEquals(3, matcher1.size());
checkAndMatcher_char(matcher1);
//
- final StringMatcher matcher2 = StringMatcherFactory.INSTANCE.andMatcher(null,
- StringMatcherFactory.INSTANCE.charMatcher('c'), null, StringMatcherFactory.INSTANCE.stringMatcher("de"),
- null);
+ final StringMatcher matcher2 = StringMatcherFactory.INSTANCE.andMatcher(null, StringMatcherFactory.INSTANCE.charMatcher('c'), null,
+ StringMatcherFactory.INSTANCE.stringMatcher("de"), null);
assertEquals(3, matcher2.size());
checkAndMatcher_char(matcher2);
}
@@ -67,19 +67,19 @@ public class StringMatcherOnCharSequenceStringTest {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.charMatcher('c');
assertEquals(1, matcher.size());
//
- assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
+ assertEquals(1, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
//
- assertThat(matcher.isMatch(INPUT2, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT2, 0));
+ assertEquals(0, matcher.isMatch(INPUT2, 1));
+ assertEquals(1, matcher.isMatch(INPUT2, 2));
+ assertEquals(0, matcher.isMatch(INPUT2, 3));
+ assertEquals(0, matcher.isMatch(INPUT2, 4));
+ assertEquals(0, matcher.isMatch(INPUT2, 5));
}
@Test
@@ -87,26 +87,23 @@ public class StringMatcherOnCharSequenceStringTest {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.charSetMatcher("ace".toCharArray());
assertEquals(1, matcher.size());
//
- assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertEquals(1, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
+ assertEquals(1, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
+ assertEquals(1, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
//
- assertThat(matcher.isMatch(INPUT2, 0)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
+ assertEquals(1, matcher.isMatch(INPUT2, 0));
+ assertEquals(0, matcher.isMatch(INPUT2, 1));
+ assertEquals(1, matcher.isMatch(INPUT2, 2));
+ assertEquals(0, matcher.isMatch(INPUT2, 3));
+ assertEquals(1, matcher.isMatch(INPUT2, 4));
+ assertEquals(0, matcher.isMatch(INPUT2, 5));
//
- assertThat(StringMatcherFactory.INSTANCE.charSetMatcher())
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
- assertThat(StringMatcherFactory.INSTANCE.charSetMatcher((char[]) null))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
- assertThat(StringMatcherFactory.INSTANCE
- .charSetMatcher("a".toCharArray()) instanceof AbstractStringMatcher.CharMatcher).isTrue();
+ assertSame(StringMatcherFactory.INSTANCE.charSetMatcher(), StringMatcherFactory.INSTANCE.noneMatcher());
+ assertSame(StringMatcherFactory.INSTANCE.charSetMatcher((char[]) null), StringMatcherFactory.INSTANCE.noneMatcher());
+ assertInstanceOf(AbstractStringMatcher.CharMatcher.class, StringMatcherFactory.INSTANCE.charSetMatcher("a".toCharArray()));
}
@Test
@@ -114,54 +111,51 @@ public class StringMatcherOnCharSequenceStringTest {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.charSetMatcher("ace");
assertEquals(1, matcher.size());
//
- assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertEquals(1, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
+ assertEquals(1, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
+ assertEquals(1, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
//
- assertThat(matcher.isMatch(INPUT2, 0)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
+ assertEquals(1, matcher.isMatch(INPUT2, 0));
+ assertEquals(0, matcher.isMatch(INPUT2, 1));
+ assertEquals(1, matcher.isMatch(INPUT2, 2));
+ assertEquals(0, matcher.isMatch(INPUT2, 3));
+ assertEquals(1, matcher.isMatch(INPUT2, 4));
+ assertEquals(0, matcher.isMatch(INPUT2, 5));
//
- assertThat(StringMatcherFactory.INSTANCE.charSetMatcher(""))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
- assertThat(StringMatcherFactory.INSTANCE.charSetMatcher((String) null))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
- assertThat(StringMatcherFactory.INSTANCE.charSetMatcher("a") instanceof AbstractStringMatcher.CharMatcher)
- .isTrue();
+ assertSame(StringMatcherFactory.INSTANCE.charSetMatcher(""), StringMatcherFactory.INSTANCE.noneMatcher());
+ assertSame(StringMatcherFactory.INSTANCE.charSetMatcher((String) null), StringMatcherFactory.INSTANCE.noneMatcher());
+ assertInstanceOf(AbstractStringMatcher.CharMatcher.class, StringMatcherFactory.INSTANCE.charSetMatcher("a"));
}
@Test
public void testCommaMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.commaMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.commaMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.commaMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 0, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 1, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length())).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 0, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 1, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length()));
//
- assertThat(matcher.isMatch(INPUT1, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 1)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 0));
+ assertEquals(1, matcher.isMatch(INPUT1, 1));
+ assertEquals(0, matcher.isMatch(INPUT1, 2));
}
@Test
public void testDoubleQuoteMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.doubleQuoteMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.doubleQuoteMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.doubleQuoteMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 11, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 12, 0, INPUT1.length())).isEqualTo(1);
+ assertEquals(0, matcher.isMatch(INPUT1, 11, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 12, 0, INPUT1.length()));
//
- assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(1);
+ assertEquals(0, matcher.isMatch(INPUT1, 11));
+ assertEquals(1, matcher.isMatch(INPUT1, 12));
}
@Test
@@ -171,116 +165,116 @@ public class StringMatcherOnCharSequenceStringTest {
// the concern of StringMatcher, and are not bugs
final StringMatcher matcher = StringMatcherFactory.INSTANCE.stringMatcher("bc");
assertEquals(2, matcher.size());
- assertThat(matcher.isMatch(INPUT2, 1, 1, INPUT2_LENGTH)).isEqualTo(2);
- assertThat(matcher.isMatch(INPUT2, 1, 0, 3)).isEqualTo(2);
- assertThat(matcher.isMatch(INPUT2, 1, 0, 2)).isEqualTo(0);
+ assertEquals(2, matcher.isMatch(INPUT2, 1, 1, INPUT2_LENGTH));
+ assertEquals(2, matcher.isMatch(INPUT2, 1, 0, 3));
+ assertEquals(0, matcher.isMatch(INPUT2, 1, 0, 2));
}
@Test
public void testNoneMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.noneMatcher();
assertEquals(0, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.noneMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.noneMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 0, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 1, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 6, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 7, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 8, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 9, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 11, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 12, 0, INPUT1.length())).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 0, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 1, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 3, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 5, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 6, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 7, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 8, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 9, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 10, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 11, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 12, 0, INPUT1.length()));
//
- assertThat(matcher.isMatch(INPUT1, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 1)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 7)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 8)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 9)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 0));
+ assertEquals(0, matcher.isMatch(INPUT1, 1));
+ assertEquals(0, matcher.isMatch(INPUT1, 2));
+ assertEquals(0, matcher.isMatch(INPUT1, 3));
+ assertEquals(0, matcher.isMatch(INPUT1, 4));
+ assertEquals(0, matcher.isMatch(INPUT1, 5));
+ assertEquals(0, matcher.isMatch(INPUT1, 6));
+ assertEquals(0, matcher.isMatch(INPUT1, 7));
+ assertEquals(0, matcher.isMatch(INPUT1, 8));
+ assertEquals(0, matcher.isMatch(INPUT1, 9));
+ assertEquals(0, matcher.isMatch(INPUT1, 10));
+ assertEquals(0, matcher.isMatch(INPUT1, 11));
+ assertEquals(0, matcher.isMatch(INPUT1, 12));
}
@Test
public void testQuoteMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.quoteMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.quoteMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.quoteMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 11, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 12, 0, INPUT1.length())).isEqualTo(1);
+ assertEquals(0, matcher.isMatch(INPUT1, 10, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 11, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 12, 0, INPUT1.length()));
//
- assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(1);
+ assertEquals(0, matcher.isMatch(INPUT1, 10));
+ assertEquals(1, matcher.isMatch(INPUT1, 11));
+ assertEquals(1, matcher.isMatch(INPUT1, 12));
}
@Test
public void testSingleQuoteMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.singleQuoteMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.singleQuoteMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.singleQuoteMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 11, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 12, 0, INPUT1.length())).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 10, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 11, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 12, 0, INPUT1.length()));
//
- assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 10));
+ assertEquals(1, matcher.isMatch(INPUT1, 11));
+ assertEquals(0, matcher.isMatch(INPUT1, 12));
}
@Test
public void testSpaceMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.spaceMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.spaceMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.spaceMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 6, 0, INPUT1.length())).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 5, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 6, 0, INPUT1.length()));
//
- assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 4));
+ assertEquals(1, matcher.isMatch(INPUT1, 5));
+ assertEquals(0, matcher.isMatch(INPUT1, 6));
}
@Test
public void testSplitMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.splitMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.splitMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.splitMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 6, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 7, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 8, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 9, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length())).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 3, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 5, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 6, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 7, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 8, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 9, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 10, 0, INPUT1.length()));
//
- assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 7)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 8)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 9)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 2));
+ assertEquals(1, matcher.isMatch(INPUT1, 3));
+ assertEquals(0, matcher.isMatch(INPUT1, 4));
+ assertEquals(1, matcher.isMatch(INPUT1, 5));
+ assertEquals(0, matcher.isMatch(INPUT1, 6));
+ assertEquals(1, matcher.isMatch(INPUT1, 7));
+ assertEquals(1, matcher.isMatch(INPUT1, 8));
+ assertEquals(1, matcher.isMatch(INPUT1, 9));
+ assertEquals(0, matcher.isMatch(INPUT1, 10));
}
@Test
@@ -288,66 +282,64 @@ public class StringMatcherOnCharSequenceStringTest {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.stringMatcher("bc");
assertEquals(2, matcher.size());
//
- assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(2);
- assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH));
+ assertEquals(2, matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH));
+ assertEquals(0, matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH));
//
- assertThat(matcher.isMatch(INPUT2, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(2);
- assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT2, 0));
+ assertEquals(2, matcher.isMatch(INPUT2, 1));
+ assertEquals(0, matcher.isMatch(INPUT2, 2));
+ assertEquals(0, matcher.isMatch(INPUT2, 3));
+ assertEquals(0, matcher.isMatch(INPUT2, 4));
+ assertEquals(0, matcher.isMatch(INPUT2, 5));
//
- assertThat(StringMatcherFactory.INSTANCE.stringMatcher(""))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
- assertThat(StringMatcherFactory.INSTANCE.stringMatcher((String) null))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
+ assertSame(StringMatcherFactory.INSTANCE.stringMatcher(""), StringMatcherFactory.INSTANCE.noneMatcher());
+ assertSame(StringMatcherFactory.INSTANCE.stringMatcher((String) null), StringMatcherFactory.INSTANCE.noneMatcher());
}
- @Test
+ @Test
public void testTabMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.tabMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.tabMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.tabMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length())).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 3, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length()));
//
- assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
+ assertEquals(0, matcher.isMatch(INPUT1, 2));
+ assertEquals(1, matcher.isMatch(INPUT1, 3));
+ assertEquals(0, matcher.isMatch(INPUT1, 4));
}
@Test
public void testTrimMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.trimMatcher();
assertEquals(1, matcher.size());
- assertThat(StringMatcherFactory.INSTANCE.trimMatcher()).isSameAs(matcher);
+ assertSame(StringMatcherFactory.INSTANCE.trimMatcher(), matcher);
//
- assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 6, 0, INPUT1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 7, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 8, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 9, 0, INPUT1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length())).isEqualTo(1);
+ assertEquals(0, matcher.isMatch(INPUT1, 2, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 3, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 4, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 5, 0, INPUT1.length()));
+ assertEquals(0, matcher.isMatch(INPUT1, 6, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 7, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 8, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 9, 0, INPUT1.length()));
+ assertEquals(1, matcher.isMatch(INPUT1, 10, 0, INPUT1.length()));
//
- assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
- assertThat(matcher.isMatch(INPUT1, 7)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 8)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 9)).isEqualTo(1);
- assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(1);
+ assertEquals(0, matcher.isMatch(INPUT1, 2));
+ assertEquals(1, matcher.isMatch(INPUT1, 3));
+ assertEquals(0, matcher.isMatch(INPUT1, 4));
+ assertEquals(1, matcher.isMatch(INPUT1, 5));
+ assertEquals(0, matcher.isMatch(INPUT1, 6));
+ assertEquals(1, matcher.isMatch(INPUT1, 7));
+ assertEquals(1, matcher.isMatch(INPUT1, 8));
+ assertEquals(1, matcher.isMatch(INPUT1, 9));
+ assertEquals(1, matcher.isMatch(INPUT1, 10));
}
}
diff --git a/src/test/java/org/apache/commons/text/similarity/CosineDistanceTest.java b/src/test/java/org/apache/commons/text/similarity/CosineDistanceTest.java
index 2781e776..b914c4ae 100644
--- a/src/test/java/org/apache/commons/text/similarity/CosineDistanceTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/CosineDistanceTest.java
@@ -16,7 +16,7 @@
*/
package org.apache.commons.text.similarity;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.math.BigDecimal;
import java.math.RoundingMode;
@@ -57,13 +57,12 @@ public class CosineDistanceTest {
*/
@Test
public void testCosineDistance() {
- assertThat(roundValue(cosineDistance.apply("the house", "da house"))).isEqualTo(Double.valueOf(0.5d));
- assertThat(roundValue(cosineDistance.apply("AB", "AB"))).isEqualTo(Double.valueOf(0.0d));
- assertThat(roundValue(cosineDistance.apply("AB", "BA"))).isEqualTo(Double.valueOf(1.0d));
- assertThat(roundValue(cosineDistance.apply(
+ assertEquals(Double.valueOf(0.5d), roundValue(cosineDistance.apply("the house", "da house")));
+ assertEquals(Double.valueOf(0.0d), roundValue(cosineDistance.apply("AB", "AB")));
+ assertEquals(Double.valueOf(1.0d), roundValue(cosineDistance.apply("AB", "BA")));
+ assertEquals(Double.valueOf(0.08d), roundValue(cosineDistance.apply(
"the boy was from tamana shi, kumamoto ken, and the girl was from rio de janeiro, rio",
- "the boy was from tamana shi, kumamoto, and the boy was from rio de janeiro, rio de janeiro")))
- .isEqualTo(Double.valueOf(0.08d));
+ "the boy was from tamana shi, kumamoto, and the boy was from rio de janeiro, rio de janeiro")));
}
}
diff --git a/src/test/java/org/apache/commons/text/similarity/CosineSimilarityTest.java b/src/test/java/org/apache/commons/text/similarity/CosineSimilarityTest.java
index 8d968e89..b5380a99 100644
--- a/src/test/java/org/apache/commons/text/similarity/CosineSimilarityTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/CosineSimilarityTest.java
@@ -17,9 +17,8 @@
package org.apache.commons.text.similarity;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
-import static org.assertj.core.api.Assertions.within;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.HashMap;
import java.util.Map;
@@ -31,15 +30,12 @@ public class CosineSimilarityTest {
@Test
public void testCosineSimilarityReturningDoubleWhereByteValueIsZero() {
final Map<CharSequence, Integer> hashMap = new HashMap<>();
- assertThat(CosineSimilarity.INSTANCE.cosineSimilarity(hashMap, hashMap)).isEqualTo(0.0, within(0.01));
+ assertEquals(0.0, CosineSimilarity.INSTANCE.cosineSimilarity(hashMap, hashMap), 0.01);
}
@Test
public void testCosineSimilarityThrowsIllegalArgumentException() {
- assertThatIllegalArgumentException().isThrownBy(() -> {
- final Map<CharSequence, Integer> map = new HashMap<>();
- CosineSimilarity.INSTANCE.cosineSimilarity(map, null);
- });
+ assertThrows(IllegalArgumentException.class, () -> CosineSimilarity.INSTANCE.cosineSimilarity(new HashMap<>(), null));
}
@Test
@@ -48,15 +44,12 @@ public class CosineSimilarityTest {
final Integer integer = -397;
hashMap.put("3J/$3.L", integer);
final Map<CharSequence, Integer> hashMapTwo = new HashMap<>();
-
- assertThat(CosineSimilarity.INSTANCE.cosineSimilarity(hashMap, hashMapTwo)).isEqualTo(0.0, within(0.01));
+ assertEquals(0.0, CosineSimilarity.INSTANCE.cosineSimilarity(hashMap, hashMapTwo), 0.01);
}
@Test
public void testCosineSimilarityWithNull() {
- assertThatIllegalArgumentException().isThrownBy(() -> {
- CosineSimilarity.INSTANCE.cosineSimilarity(null, null);
- });
+ assertThrows(IllegalArgumentException.class, () -> CosineSimilarity.INSTANCE.cosineSimilarity(null, null));
}
}
diff --git a/src/test/java/org/apache/commons/text/similarity/FuzzyScoreTest.java b/src/test/java/org/apache/commons/text/similarity/FuzzyScoreTest.java
index 3a5ac0d2..b1acb4de 100644
--- a/src/test/java/org/apache/commons/text/similarity/FuzzyScoreTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/FuzzyScoreTest.java
@@ -16,8 +16,9 @@
*/
package org.apache.commons.text.similarity;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.Locale;
@@ -32,28 +33,28 @@ public class FuzzyScoreTest {
@Test
public void testGetFuzzyScore() {
- assertThat(ENGLISH_SCORE.fuzzyScore("", "")).isEqualTo(0);
- assertThat(ENGLISH_SCORE.fuzzyScore("Workshop", "b")).isEqualTo(0);
- assertThat(ENGLISH_SCORE.fuzzyScore("Room", "o")).isEqualTo(1);
- assertThat(ENGLISH_SCORE.fuzzyScore("Workshop", "w")).isEqualTo(1);
- assertThat(ENGLISH_SCORE.fuzzyScore("Workshop", "ws")).isEqualTo(2);
- assertThat(ENGLISH_SCORE.fuzzyScore("Workshop", "wo")).isEqualTo(4);
- assertThat(ENGLISH_SCORE.fuzzyScore("Apache Software Foundation", "asf")).isEqualTo(3);
+ assertEquals(0, ENGLISH_SCORE.fuzzyScore("", ""));
+ assertEquals(0, ENGLISH_SCORE.fuzzyScore("Workshop", "b"));
+ assertEquals(1, ENGLISH_SCORE.fuzzyScore("Room", "o"));
+ assertEquals(1, ENGLISH_SCORE.fuzzyScore("Workshop", "w"));
+ assertEquals(2, ENGLISH_SCORE.fuzzyScore("Workshop", "ws"));
+ assertEquals(4, ENGLISH_SCORE.fuzzyScore("Workshop", "wo"));
+ assertEquals(3, ENGLISH_SCORE.fuzzyScore("Apache Software Foundation", "asf"));
}
@Test
public void testGetFuzzyScore_NullNullLocale() {
- assertThatIllegalArgumentException().isThrownBy(() -> ENGLISH_SCORE.fuzzyScore(null, null));
+ assertThrows(IllegalArgumentException.class, () -> ENGLISH_SCORE.fuzzyScore(null, null));
}
@Test
public void testGetFuzzyScore_NullStringLocale() {
- assertThatIllegalArgumentException().isThrownBy(() -> ENGLISH_SCORE.fuzzyScore(null, "not null"));
+ assertThrows(IllegalArgumentException.class, () -> ENGLISH_SCORE.fuzzyScore(null, "not null"));
}
@Test
public void testGetFuzzyScore_StringNullLocale() {
- assertThatIllegalArgumentException().isThrownBy(() -> ENGLISH_SCORE.fuzzyScore("not null", null));
+ assertThrows(IllegalArgumentException.class, () -> ENGLISH_SCORE.fuzzyScore("not null", null));
}
@Test
@@ -61,13 +62,12 @@ public class FuzzyScoreTest {
final Locale locale = Locale.CANADA_FRENCH;
final FuzzyScore fuzzyScore = new FuzzyScore(locale);
final Locale localeTwo = fuzzyScore.getLocale();
-
- assertThat(localeTwo).isSameAs(locale);
+ assertSame(localeTwo, locale);
}
@Test
public void testMissingLocale() {
- assertThatIllegalArgumentException().isThrownBy(() -> new FuzzyScore((Locale) null));
+ assertThrows(IllegalArgumentException.class, () -> new FuzzyScore((Locale) null));
}
}
diff --git a/src/test/java/org/apache/commons/text/similarity/HammingDistanceTest.java b/src/test/java/org/apache/commons/text/similarity/HammingDistanceTest.java
index 1fa1f0b3..8e5cebb8 100644
--- a/src/test/java/org/apache/commons/text/similarity/HammingDistanceTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/HammingDistanceTest.java
@@ -49,6 +49,16 @@ public class HammingDistanceTest {
assertEquals(2, distance.apply(SimilarityInputTest.build(cls, "ATCG"), SimilarityInputTest.build(cls, "ACCC")));
}
+ @Test
+ public void testHammingDistance_nullLeftValue() {
+ assertThrows(IllegalArgumentException.class, () -> distance.apply(null, ""));
+ }
+
+ @Test
+ public void testHammingDistance_nullRightValue() {
+ assertThrows(IllegalArgumentException.class, () -> distance.apply("", null));
+ }
+
@Test
public void testHammingDistanceCharSequence() {
assertEquals(0, distance.apply("", ""));
@@ -61,14 +71,4 @@ public class HammingDistanceTest {
assertEquals(2, distance.apply("ATCG", "ACCC"));
}
- @Test
- public void testHammingDistance_nullLeftValue() {
- assertThrows(IllegalArgumentException.class, () -> distance.apply(null, ""));
- }
-
- @Test
- public void testHammingDistance_nullRightValue() {
- assertThrows(IllegalArgumentException.class, () -> distance.apply("", null));
- }
-
}
diff --git a/src/test/java/org/apache/commons/text/similarity/IntersectionSimilarityTest.java b/src/test/java/org/apache/commons/text/similarity/IntersectionSimilarityTest.java
index 76b1d92c..1236fec7 100644
--- a/src/test/java/org/apache/commons/text/similarity/IntersectionSimilarityTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/IntersectionSimilarityTest.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.text.similarity;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.ArrayList;
import java.util.Collection;
@@ -36,7 +36,7 @@ import org.junit.jupiter.api.Test;
*/
public class IntersectionSimilarityTest {
private static <T> void assertIntersection(final IntersectionSimilarity<T> similarity, final CharSequence cs1, final CharSequence cs2, final int sizeA,
- final int sizeB, final int intersection) {
+ final int sizeB, final int intersection) {
final IntersectionResult result = similarity.apply(cs1, cs2);
assertEquals(sizeA, result.getSizeA(), "Size A error");
assertEquals(sizeB, result.getSizeB(), "Size B error");
@@ -44,8 +44,7 @@ public class IntersectionSimilarityTest {
}
/**
- * Convert the {@link CharSequence} to a {@link List} of bigrams (pairs of characters). These are represented using 2
- * 16-bit chars packed into a 32-bit int.
+ * Convert the {@link CharSequence} to a {@link List} of bigrams (pairs of characters). These are represented using 2 16-bit chars packed into a 32-bit int.
*
* @param sequence the sequence
* @return the list
@@ -65,8 +64,7 @@ public class IntersectionSimilarityTest {
}
/**
- * Convert the {@link CharSequence} to a {@link Set} of bigrams (pairs of characters). These are represented using 2
- * 16-bit chars packed into a 32-bit int.
+ * Convert the {@link CharSequence} to a {@link Set} of bigrams (pairs of characters). These are represented using 2 16-bit chars packed into a 32-bit int.
*
* @param sequence the sequence
* @return the set
@@ -123,25 +121,24 @@ public class IntersectionSimilarityTest {
@Test
public void testApplyNullNull() {
- assertThatIllegalArgumentException()
- .isThrownBy(() -> new IntersectionSimilarity<>(cs -> new HashSet<>(Collections.singletonList(cs))).apply(null, null));
+ assertThrows(IllegalArgumentException.class, () -> new IntersectionSimilarity<>(cs -> new HashSet<>(Collections.singletonList(cs))).apply(null, null));
}
@Test
public void testApplyNullString() {
- assertThatIllegalArgumentException()
- .isThrownBy(() -> new IntersectionSimilarity<>(cs -> new HashSet<>(Collections.singletonList(cs))).apply(null, "right"));
+ assertThrows(IllegalArgumentException.class,
+ () -> new IntersectionSimilarity<>(cs -> new HashSet<>(Collections.singletonList(cs))).apply(null, "right"));
}
@Test
public void testApplyStringNull() {
- assertThatIllegalArgumentException()
- .isThrownBy(() -> new IntersectionSimilarity<>(cs -> new HashSet<>(Collections.singletonList(cs))).apply("left", null));
+ assertThrows(IllegalArgumentException.class,
+ () -> new IntersectionSimilarity<>(cs -> new HashSet<>(Collections.singletonList(cs))).apply("left", null));
}
@Test
public void testConstructorWithNullConverterThrows() {
- assertThatIllegalArgumentException().isThrownBy(() -> new IntersectionSimilarity<>(null));
+ assertThrows(IllegalArgumentException.class, () -> new IntersectionSimilarity<>(null));
}
@Test
diff --git a/src/test/java/org/apache/commons/text/similarity/JaccardDistanceTest.java b/src/test/java/org/apache/commons/text/similarity/JaccardDistanceTest.java
index d67e8de5..4339fdf3 100644
--- a/src/test/java/org/apache/commons/text/similarity/JaccardDistanceTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/JaccardDistanceTest.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.text.similarity;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
@@ -77,16 +77,16 @@ public class JaccardDistanceTest {
@Test
public void testGettingJaccardDistanceNullNull() {
- assertThatIllegalArgumentException().isThrownBy(() -> classBeingTested.apply((String) null, null));
+ assertThrows(IllegalArgumentException.class, () -> classBeingTested.apply((String) null, null));
}
@Test
public void testGettingJaccardDistanceNullString() {
- assertThatIllegalArgumentException().isThrownBy(() -> classBeingTested.apply(null, "right"));
+ assertThrows(IllegalArgumentException.class, () -> classBeingTested.apply(null, "right"));
}
@Test
public void testGettingJaccardDistanceStringNull() {
- assertThatIllegalArgumentException().isThrownBy(() -> classBeingTested.apply(" ", null));
+ assertThrows(IllegalArgumentException.class, () -> classBeingTested.apply(" ", null));
}
}
diff --git a/src/test/java/org/apache/commons/text/similarity/JaccardSimilarityTest.java b/src/test/java/org/apache/commons/text/similarity/JaccardSimilarityTest.java
index b3c96532..08c9188e 100644
--- a/src/test/java/org/apache/commons/text/similarity/JaccardSimilarityTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/JaccardSimilarityTest.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.text.similarity;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
@@ -77,16 +77,16 @@ public class JaccardSimilarityTest {
@Test
public void testGettingJaccardSimilarityNullNull() {
- assertThatIllegalArgumentException().isThrownBy(() -> classBeingTested.apply((String) null, null));
+ assertThrows(IllegalArgumentException.class, () -> classBeingTested.apply((String) null, null));
}
@Test
public void testGettingJaccardSimilarityNullString() {
- assertThatIllegalArgumentException().isThrownBy(() -> classBeingTested.apply(null, "right"));
+ assertThrows(IllegalArgumentException.class, () -> classBeingTested.apply(null, "right"));
}
@Test
public void testGettingJaccardSimilarityStringNull() {
- assertThatIllegalArgumentException().isThrownBy(() -> classBeingTested.apply(" ", null));
+ assertThrows(IllegalArgumentException.class, () -> classBeingTested.apply(" ", null));
}
}
diff --git a/src/test/java/org/apache/commons/text/similarity/LevenshteinDistanceTest.java b/src/test/java/org/apache/commons/text/similarity/LevenshteinDistanceTest.java
index 51665928..94840e60 100644
--- a/src/test/java/org/apache/commons/text/similarity/LevenshteinDistanceTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/LevenshteinDistanceTest.java
@@ -32,13 +32,13 @@ public class LevenshteinDistanceTest {
private static final LevenshteinDistance UNLIMITED_DISTANCE = LevenshteinDistance.getDefaultInstance();
@Test
- public void testApplyThrowsIllegalArgumentExceptionString() {
- assertThrows(IllegalArgumentException.class, () -> new LevenshteinDistance(0).apply((String) null, (String) null));
+ public void testApplyThrowsIllegalArgumentExceptionSimilarityInput() {
+ assertThrows(IllegalArgumentException.class, () -> new LevenshteinDistance(0).apply((SimilarityInput<Object>) null, (SimilarityInput<Object>) null));
}
@Test
- public void testApplyThrowsIllegalArgumentExceptionSimilarityInput() {
- assertThrows(IllegalArgumentException.class, () -> new LevenshteinDistance(0).apply((SimilarityInput<Object>) null, (SimilarityInput<Object>) null));
+ public void testApplyThrowsIllegalArgumentExceptionString() {
+ assertThrows(IllegalArgumentException.class, () -> new LevenshteinDistance(0).apply((String) null, (String) null));
}
@Test
diff --git a/src/test/java/org/apache/commons/text/similarity/LevenshteinResultsTest.java b/src/test/java/org/apache/commons/text/similarity/LevenshteinResultsTest.java
index 68046561..e9a58e10 100644
--- a/src/test/java/org/apache/commons/text/similarity/LevenshteinResultsTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/LevenshteinResultsTest.java
@@ -16,7 +16,8 @@
*/
package org.apache.commons.text.similarity;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
@@ -27,28 +28,23 @@ public class LevenshteinResultsTest {
final Integer integer = 1662;
final LevenshteinResults levenshteinResults = new LevenshteinResults(integer, integer, integer, integer);
final LevenshteinResults levenshteinResultsTwo = new LevenshteinResults(integer, integer, integer, null);
-
- assertThat(levenshteinResults.equals(levenshteinResultsTwo)).isFalse();
+ assertFalse(levenshteinResults.equals(levenshteinResultsTwo));
}
@Test
public void testEqualsReturningFalse() {
final Integer integerOne = 1662;
final Integer integerTwo = 1164;
- final LevenshteinResults levenshteinResults =
- new LevenshteinResults(integerOne, integerOne, integerOne, integerOne);
- final LevenshteinResults levenshteinResultsTwo =
- new LevenshteinResults(integerOne, integerOne, integerTwo, integerTwo);
-
- assertThat(levenshteinResults.equals(levenshteinResultsTwo)).isFalse();
+ final LevenshteinResults levenshteinResults = new LevenshteinResults(integerOne, integerOne, integerOne, integerOne);
+ final LevenshteinResults levenshteinResultsTwo = new LevenshteinResults(integerOne, integerOne, integerTwo, integerTwo);
+ assertFalse(levenshteinResults.equals(levenshteinResultsTwo));
}
@Test
public void testEqualsSameObject() {
final Integer integer = 1662;
final LevenshteinResults levenshteinResults = new LevenshteinResults(integer, integer, integer, null);
-
- assertThat(levenshteinResults.equals(levenshteinResults)).isTrue();
+ assertTrue(levenshteinResults.equals(levenshteinResults));
}
@Test
@@ -56,16 +52,14 @@ public class LevenshteinResultsTest {
final Integer integer = 1;
final LevenshteinResults levenshteinResults = new LevenshteinResults(null, integer, integer, null);
final LevenshteinResults levenshteinResultsTwo = new LevenshteinResults(null, null, null, null);
-
- assertThat(levenshteinResults.equals(levenshteinResultsTwo)).isFalse();
+ assertFalse(levenshteinResults.equals(levenshteinResultsTwo));
}
@Test
public void testEqualsWithNull() {
final Integer integer = -647;
final LevenshteinResults levenshteinResults = new LevenshteinResults(integer, null, null, integer);
-
- assertThat(levenshteinResults.equals(null)).isFalse();
+ assertFalse(levenshteinResults.equals(null));
}
}
diff --git a/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceDistanceTest.java b/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceDistanceTest.java
index e0ccac52..30dddb4c 100644
--- a/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceDistanceTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceDistanceTest.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.text.similarity;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
@@ -36,34 +36,34 @@ public class LongestCommonSubsequenceDistanceTest {
@Test
public void testGettingLongestCommonSubsequenceDistance() {
- assertThat(subject.apply("", "")).isEqualTo(0);
- assertThat(subject.apply("left", "")).isEqualTo(4);
- assertThat(subject.apply("", "right")).isEqualTo(5);
- assertThat(subject.apply("frog", "fog")).isEqualTo(1);
- assertThat(subject.apply("fly", "ant")).isEqualTo(6);
- assertThat(subject.apply("elephant", "hippo")).isEqualTo(11);
- assertThat(subject.apply("ABC Corporation", "ABC Corp")).isEqualTo(7);
- assertThat(subject.apply("D N H Enterprises Inc", "D & H Enterprises, Inc.")).isEqualTo(4);
- assertThat(subject.apply("My Gym Children's Fitness Center", "My Gym. Childrens Fitness")).isEqualTo(9);
- assertThat(subject.apply("PENNSYLVANIA", "PENNCISYLVNIA")).isEqualTo(3);
- assertThat(subject.apply("left", "right")).isEqualTo(7);
- assertThat(subject.apply("leettteft", "ritttght")).isEqualTo(9);
- assertThat(subject.apply("the same string", "the same string")).isEqualTo(0);
+ assertEquals(0, subject.apply("", ""));
+ assertEquals(4, subject.apply("left", ""));
+ assertEquals(5, subject.apply("", "right"));
+ assertEquals(1, subject.apply("frog", "fog"));
+ assertEquals(6, subject.apply("fly", "ant"));
+ assertEquals(11, subject.apply("elephant", "hippo"));
+ assertEquals(7, subject.apply("ABC Corporation", "ABC Corp"));
+ assertEquals(4, subject.apply("D N H Enterprises Inc", "D & H Enterprises, Inc."));
+ assertEquals(9, subject.apply("My Gym Children's Fitness Center", "My Gym. Childrens Fitness"));
+ assertEquals(3, subject.apply("PENNSYLVANIA", "PENNCISYLVNIA"));
+ assertEquals(7, subject.apply("left", "right"));
+ assertEquals(9, subject.apply("leettteft", "ritttght"));
+ assertEquals(0, subject.apply("the same string", "the same string"));
}
@Test
public void testGettingLongestCommonSubsequenceDistanceNullNull() {
- assertThatIllegalArgumentException().isThrownBy(() -> subject.apply(null, null));
+ assertThrows(IllegalArgumentException.class, () -> subject.apply(null, null));
}
@Test
public void testGettingLongestCommonSubsequenceDistanceNullString() {
- assertThatIllegalArgumentException().isThrownBy(() -> subject.apply(null, "right"));
+ assertThrows(IllegalArgumentException.class, () -> subject.apply(null, "right"));
}
@Test
public void testGettingLongestCommonSubsequenceDistanceStringNull() {
- assertThatIllegalArgumentException().isThrownBy(() -> subject.apply(" ", null));
+ assertThrows(IllegalArgumentException.class, () -> subject.apply(" ", null));
}
}
diff --git a/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceTest.java b/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceTest.java
index 8115240d..ea01b5b8 100644
--- a/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceTest.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.text.similarity;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
@@ -37,104 +37,100 @@ public class LongestCommonSubsequenceTest {
@Test
@SuppressWarnings("deprecation")
public void testGettingLogestCommonSubsequenceNullNull() {
- assertThatIllegalArgumentException().isThrownBy(() -> subject.logestCommonSubsequence(null, null));
+ assertThrows(IllegalArgumentException.class, () -> subject.logestCommonSubsequence(null, null));
}
@Test
@SuppressWarnings("deprecation")
public void testGettingLogestCommonSubsequenceNullString() {
- assertThatIllegalArgumentException().isThrownBy(() -> subject.logestCommonSubsequence(null, "right"));
+ assertThrows(IllegalArgumentException.class, () -> subject.logestCommonSubsequence(null, "right"));
}
@Test
@SuppressWarnings("deprecation")
public void testGettingLogestCommonSubsequenceStringNull() {
- assertThatIllegalArgumentException().isThrownBy(() -> subject.logestCommonSubsequence(" ", null));
+ assertThrows(IllegalArgumentException.class, () -> subject.logestCommonSubsequence(" ", null));
}
@Test
public void testGettingLongestCommonSubsequenceApplyNullNull() {
- assertThatIllegalArgumentException().isThrownBy(() -> subject.apply(null, null));
+ assertThrows(IllegalArgumentException.class, () -> subject.apply(null, null));
}
@Test
public void testGettingLongestCommonSubsequenceApplyNullString() {
- assertThatIllegalArgumentException().isThrownBy(() -> subject.apply(null, "right"));
+ assertThrows(IllegalArgumentException.class, () -> subject.apply(null, "right"));
}
@Test
public void testGettingLongestCommonSubsequenceApplyStringNull() {
- assertThatIllegalArgumentException().isThrownBy(() -> subject.apply(" ", null));
+ assertThrows(IllegalArgumentException.class, () -> subject.apply(" ", null));
}
@Test
public void testGettingLongestCommonSubsequenceNullNull() {
- assertThatIllegalArgumentException().isThrownBy(() -> subject.longestCommonSubsequence(null, null));
+ assertThrows(IllegalArgumentException.class, () -> subject.longestCommonSubsequence(null, null));
}
@Test
public void testGettingLongestCommonSubsequenceNullString() {
- assertThatIllegalArgumentException().isThrownBy(() -> subject.longestCommonSubsequence(null, "right"));
+ assertThrows(IllegalArgumentException.class, () -> subject.longestCommonSubsequence(null, "right"));
}
@Test
public void testGettingLongestCommonSubsequenceStringNull() {
- assertThatIllegalArgumentException().isThrownBy(() -> subject.longestCommonSubsequence(" ", null));
+ assertThrows(IllegalArgumentException.class, () -> subject.longestCommonSubsequence(" ", null));
}
@Test
@Deprecated
public void testLogestCommonSubsequence() {
- assertThat(subject.logestCommonSubsequence("", "")).isEqualTo("");
- assertThat(subject.logestCommonSubsequence("left", "")).isEqualTo("");
- assertThat(subject.logestCommonSubsequence("", "right")).isEqualTo("");
- assertThat(subject.logestCommonSubsequence("frog", "fog")).isEqualTo("fog");
- assertThat(subject.logestCommonSubsequence("fly", "ant")).isEqualTo("");
- assertThat(subject.logestCommonSubsequence("elephant", "hippo")).isEqualTo("h");
- assertThat(subject.logestCommonSubsequence("ABC Corporation", "ABC Corp")).isEqualTo("ABC Corp");
- assertThat(subject.logestCommonSubsequence("D N H Enterprises Inc", "D & H Enterprises, Inc."))
- .isEqualTo("D H Enterprises Inc");
- assertThat(subject.logestCommonSubsequence("My Gym Children's Fitness Center", "My Gym. Childrens Fitness"))
- .isEqualTo("My Gym Childrens Fitness");
- assertThat(subject.logestCommonSubsequence("PENNSYLVANIA", "PENNCISYLVNIA")).isEqualTo("PENNSYLVNIA");
- assertThat(subject.logestCommonSubsequence("left", "right")).isEqualTo("t");
- assertThat(subject.logestCommonSubsequence("leettteft", "ritttght")).isEqualTo("tttt");
- assertThat(subject.logestCommonSubsequence("the same string", "the same string")).isEqualTo("the same string");
+ assertEquals("", subject.logestCommonSubsequence("", ""));
+ assertEquals("", subject.logestCommonSubsequence("left", ""));
+ assertEquals("", subject.logestCommonSubsequence("", "right"));
+ assertEquals("fog", subject.logestCommonSubsequence("frog", "fog"));
+ assertEquals("", subject.logestCommonSubsequence("fly", "ant"));
+ assertEquals("h", subject.logestCommonSubsequence("elephant", "hippo"));
+ assertEquals("ABC Corp", subject.logestCommonSubsequence("ABC Corporation", "ABC Corp"));
+ assertEquals("D H Enterprises Inc", subject.logestCommonSubsequence("D N H Enterprises Inc", "D & H Enterprises, Inc."));
+ assertEquals("My Gym Childrens Fitness", subject.logestCommonSubsequence("My Gym Children's Fitness Center", "My Gym. Childrens Fitness"));
+ assertEquals("PENNSYLVNIA", subject.logestCommonSubsequence("PENNSYLVANIA", "PENNCISYLVNIA"));
+ assertEquals("t", subject.logestCommonSubsequence("left", "right"));
+ assertEquals("tttt", subject.logestCommonSubsequence("leettteft", "ritttght"));
+ assertEquals("the same string", subject.logestCommonSubsequence("the same string", "the same string"));
}
@Test
public void testLongestCommonSubsequence() {
- assertThat(subject.longestCommonSubsequence("", "")).isEqualTo("");
- assertThat(subject.longestCommonSubsequence("left", "")).isEqualTo("");
- assertThat(subject.longestCommonSubsequence("", "right")).isEqualTo("");
- assertThat(subject.longestCommonSubsequence("frog", "fog")).isEqualTo("fog");
- assertThat(subject.longestCommonSubsequence("fly", "ant")).isEqualTo("");
- assertThat(subject.longestCommonSubsequence("elephant", "hippo")).isEqualTo("h");
- assertThat(subject.longestCommonSubsequence("ABC Corporation", "ABC Corp")).isEqualTo("ABC Corp");
- assertThat(subject.longestCommonSubsequence("D N H Enterprises Inc", "D & H Enterprises, Inc."))
- .isEqualTo("D H Enterprises Inc");
- assertThat(subject.longestCommonSubsequence("My Gym Children's Fitness Center", "My Gym. Childrens Fitness"))
- .isEqualTo("My Gym Childrens Fitness");
- assertThat(subject.longestCommonSubsequence("PENNSYLVANIA", "PENNCISYLVNIA")).isEqualTo("PENNSYLVNIA");
- assertThat(subject.longestCommonSubsequence("left", "right")).isEqualTo("t");
- assertThat(subject.longestCommonSubsequence("leettteft", "ritttght")).isEqualTo("tttt");
- assertThat(subject.longestCommonSubsequence("the same string", "the same string")).isEqualTo("the same string");
+ assertEquals("", subject.longestCommonSubsequence("", ""));
+ assertEquals("", subject.longestCommonSubsequence("left", ""));
+ assertEquals("", subject.longestCommonSubsequence("", "right"));
+ assertEquals("fog", subject.longestCommonSubsequence("frog", "fog"));
+ assertEquals("", subject.longestCommonSubsequence("fly", "ant"));
+ assertEquals("h", subject.longestCommonSubsequence("elephant", "hippo"));
+ assertEquals("ABC Corp", subject.longestCommonSubsequence("ABC Corporation", "ABC Corp"));
+ assertEquals("D H Enterprises Inc", subject.longestCommonSubsequence("D N H Enterprises Inc", "D & H Enterprises, Inc."));
+ assertEquals("My Gym Childrens Fitness", subject.longestCommonSubsequence("My Gym Children's Fitness Center", "My Gym. Childrens Fitness"));
+ assertEquals("PENNSYLVNIA", subject.longestCommonSubsequence("PENNSYLVANIA", "PENNCISYLVNIA"));
+ assertEquals("t", subject.longestCommonSubsequence("left", "right"));
+ assertEquals("tttt", subject.longestCommonSubsequence("leettteft", "ritttght"));
+ assertEquals("the same string", subject.longestCommonSubsequence("the same string", "the same string"));
}
@Test
public void testLongestCommonSubsequenceApply() {
- assertThat(subject.apply("", "")).isEqualTo(0);
- assertThat(subject.apply("left", "")).isEqualTo(0);
- assertThat(subject.apply("", "right")).isEqualTo(0);
- assertThat(subject.apply("frog", "fog")).isEqualTo(3);
- assertThat(subject.apply("fly", "ant")).isEqualTo(0);
- assertThat(subject.apply("elephant", "hippo")).isEqualTo(1);
- assertThat(subject.apply("ABC Corporation", "ABC Corp")).isEqualTo(8);
- assertThat(subject.apply("D N H Enterprises Inc", "D & H Enterprises, Inc.")).isEqualTo(20);
- assertThat(subject.apply("My Gym Children's Fitness Center", "My Gym. Childrens Fitness")).isEqualTo(24);
- assertThat(subject.apply("PENNSYLVANIA", "PENNCISYLVNIA")).isEqualTo(11);
- assertThat(subject.apply("left", "right")).isEqualTo(1);
- assertThat(subject.apply("leettteft", "ritttght")).isEqualTo(4);
- assertThat(subject.apply("the same string", "the same string")).isEqualTo(15);
+ assertEquals(0, subject.apply("", ""));
+ assertEquals(0, subject.apply("left", ""));
+ assertEquals(0, subject.apply("", "right"));
+ assertEquals(3, subject.apply("frog", "fog"));
+ assertEquals(0, subject.apply("fly", "ant"));
+ assertEquals(1, subject.apply("elephant", "hippo"));
+ assertEquals(8, subject.apply("ABC Corporation", "ABC Corp"));
+ assertEquals(20, subject.apply("D N H Enterprises Inc", "D & H Enterprises, Inc."));
+ assertEquals(24, subject.apply("My Gym Children's Fitness Center", "My Gym. Childrens Fitness"));
+ assertEquals(11, subject.apply("PENNSYLVANIA", "PENNCISYLVNIA"));
+ assertEquals(1, subject.apply("left", "right"));
+ assertEquals(4, subject.apply("leettteft", "ritttght"));
+ assertEquals(15, subject.apply("the same string", "the same string"));
}
}
diff --git a/src/test/java/org/apache/commons/text/similarity/ParameterizedEditDistanceFromTest.java b/src/test/java/org/apache/commons/text/similarity/ParameterizedEditDistanceFromTest.java
index 1373d1a6..420200e5 100644
--- a/src/test/java/org/apache/commons/text/similarity/ParameterizedEditDistanceFromTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/ParameterizedEditDistanceFromTest.java
@@ -16,7 +16,7 @@
*/
package org.apache.commons.text.similarity;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.stream.Stream;
@@ -54,10 +54,9 @@ public class ParameterizedEditDistanceFromTest<R> {
@ParameterizedTest
@MethodSource("parameters")
- public void test(final EditDistance<R> editDistance, final CharSequence left, final CharSequence right,
- final R distance) {
+ public void test(final EditDistance<R> editDistance, final CharSequence left, final CharSequence right, final R distance) {
final EditDistanceFrom<R> editDistanceFrom = new EditDistanceFrom<>(editDistance, left);
- assertThat(editDistanceFrom.apply(right)).isEqualTo(distance);
+ assertEquals(distance, editDistanceFrom.apply(right));
}
}
diff --git a/src/test/java/org/apache/commons/text/similarity/ParameterizedLevenshteinDistanceTest.java b/src/test/java/org/apache/commons/text/similarity/ParameterizedLevenshteinDistanceTest.java
index 2c272e73..fb75cd87 100644
--- a/src/test/java/org/apache/commons/text/similarity/ParameterizedLevenshteinDistanceTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/ParameterizedLevenshteinDistanceTest.java
@@ -16,7 +16,7 @@
*/
package org.apache.commons.text.similarity;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.stream.Stream;
@@ -30,6 +30,7 @@ import org.junit.jupiter.params.provider.MethodSource;
public class ParameterizedLevenshteinDistanceTest {
public static Stream<Arguments> parameters() {
+ // @formatter:off
return Stream.of(
/* empty strings */
Arguments.of(0, "", "", 0),
@@ -91,14 +92,13 @@ public class ParameterizedLevenshteinDistanceTest {
Arguments.of(Integer.MAX_VALUE, "hippo", "zzzzzzzz", 8),
Arguments.of(Integer.MAX_VALUE, "zzzzzzzz", "hippo", 8),
Arguments.of(Integer.MAX_VALUE, "hello", "hallo", 1));
+ // @formatter:on
}
@ParameterizedTest
@MethodSource("parameters")
- public void test(final Integer threshold, final CharSequence left, final CharSequence right,
- final Integer distance) {
- final LevenshteinDistance metric = new LevenshteinDistance(threshold);
- assertThat(metric.apply(left, right)).isEqualTo(distance);
+ public void test(final Integer threshold, final CharSequence left, final CharSequence right, final Integer distance) {
+ assertEquals(distance, new LevenshteinDistance(threshold).apply(left, right));
}
}
diff --git a/src/test/java/org/apache/commons/text/similarity/ParameterizedSimilarityScoreFromTest.java b/src/test/java/org/apache/commons/text/similarity/ParameterizedSimilarityScoreFromTest.java
index 40fae22c..6520daf6 100644
--- a/src/test/java/org/apache/commons/text/similarity/ParameterizedSimilarityScoreFromTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/ParameterizedSimilarityScoreFromTest.java
@@ -16,7 +16,7 @@
*/
package org.apache.commons.text.similarity;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.stream.Stream;
@@ -32,25 +32,17 @@ import org.junit.jupiter.params.provider.MethodSource;
public class ParameterizedSimilarityScoreFromTest<R> {
public static Stream<Arguments> parameters() {
- return Stream.of(
- Arguments.of(LevenshteinDistance.getDefaultInstance(), "elephant", "hippo", 7),
+ return Stream.of(Arguments.of(LevenshteinDistance.getDefaultInstance(), "elephant", "hippo", 7),
Arguments.of(LevenshteinDistance.getDefaultInstance(), "hippo", "elephant", 7),
Arguments.of(LevenshteinDistance.getDefaultInstance(), "hippo", "zzzzzzzz", 8),
-
- Arguments.of(
- (SimilarityScore<Boolean>) (left, right) -> left == right
- || left != null && left.equals(right),
- "Bob's your uncle.",
- "Every good boy does fine.",
- false
- ));
+ Arguments.of((SimilarityScore<Boolean>) (left, right) -> left == right || left != null && left.equals(right), "Bob's your uncle.",
+ "Every good boy does fine.", false));
}
@ParameterizedTest
@MethodSource("parameters")
- public void test(final SimilarityScore<R> similarityScore, final CharSequence left, final CharSequence right,
- final R distance) {
+ public void test(final SimilarityScore<R> similarityScore, final CharSequence left, final CharSequence right, final R distance) {
final SimilarityScoreFrom<R> similarityScoreFrom = new SimilarityScoreFrom<>(similarityScore, left);
- assertThat(similarityScoreFrom.apply(right)).isEqualTo(distance);
+ assertEquals(distance, similarityScoreFrom.apply(right));
}
}
diff --git a/src/test/java/org/apache/commons/text/similarity/SimilarityScoreFromTest.java b/src/test/java/org/apache/commons/text/similarity/SimilarityScoreFromTest.java
index 24eac1d0..5dffc285 100644
--- a/src/test/java/org/apache/commons/text/similarity/SimilarityScoreFromTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/SimilarityScoreFromTest.java
@@ -17,8 +17,8 @@
package org.apache.commons.text.similarity;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
@@ -27,15 +27,13 @@ public class SimilarityScoreFromTest {
@Test
public void testApply() {
final LongestCommonSubsequence longestCommonSubsequence = new LongestCommonSubsequence();
- final SimilarityScoreFrom<Integer> similarityScoreFrom =
- new SimilarityScoreFrom<>(longestCommonSubsequence, "asdf");
-
- assertThat(similarityScoreFrom.apply("s")).isEqualTo(1);
+ final SimilarityScoreFrom<Integer> similarityScoreFrom = new SimilarityScoreFrom<>(longestCommonSubsequence, "asdf");
+ assertEquals(1, similarityScoreFrom.apply("s"));
}
@Test
public void testFailsToCreateSimilarityScoreFromThrowsIllegalArgumentException() {
- assertThatIllegalArgumentException().isThrownBy(() -> new SimilarityScoreFrom<>(null, ""));
+ assertThrows(IllegalArgumentException.class, () -> new SimilarityScoreFrom<>(null, ""));
}
}
diff --git a/src/test/java/org/apache/commons/text/similarity/StringMetricFromTest.java b/src/test/java/org/apache/commons/text/similarity/StringMetricFromTest.java
index cffa4f5d..3ee73290 100644
--- a/src/test/java/org/apache/commons/text/similarity/StringMetricFromTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/StringMetricFromTest.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.text.similarity;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
@@ -34,33 +34,32 @@ public class StringMetricFromTest {
final Integer distance = 4;
final EditDistanceFrom<Integer> metricFrom = new EditDistanceFrom<>(metric, left);
- assertThat(metricFrom.apply(right)).isEqualTo(distance);
- assertThat(metricFrom.apply(right)).isEqualTo(metric.apply(left, right));
+ assertEquals(distance, metricFrom.apply(right));
+ assertEquals(metric.apply(left, right), metricFrom.apply(right));
}
@Test
public void testJavadocExample() {
final EditDistance<Integer> metric = LevenshteinDistance.getDefaultInstance();
final String target = "Apache";
- final EditDistanceFrom<Integer> metricFrom =
- new EditDistanceFrom<>(metric, target);
+ final EditDistanceFrom<Integer> metricFrom = new EditDistanceFrom<>(metric, target);
String mostSimilar = null;
Integer shortestDistance = null;
- for (final String test : new String[] {"Appaloosa", "a patchy", "apple" }) {
+ for (final String test : new String[] { "Appaloosa", "a patchy", "apple" }) {
final Integer distance = metricFrom.apply(test);
if (shortestDistance == null || distance < shortestDistance) {
shortestDistance = distance;
mostSimilar = test;
}
}
- assertThat(mostSimilar).isEqualTo("a patchy");
- assertThat(shortestDistance).isEqualTo(4);
+ assertEquals("a patchy", mostSimilar);
+ assertEquals(4, shortestDistance);
}
@Test
public void testMissingMetric() {
- assertThatIllegalArgumentException().isThrownBy(() -> new EditDistanceFrom<Number>(null, "no go"));
+ assertThrows(IllegalArgumentException.class, () -> new EditDistanceFrom<Number>(null, "no go"));
}
}
diff --git a/src/test/java/org/apache/commons/text/translate/AggregateTranslatorTest.java b/src/test/java/org/apache/commons/text/translate/AggregateTranslatorTest.java
index a3bdc9d8..99fa2efd 100644
--- a/src/test/java/org/apache/commons/text/translate/AggregateTranslatorTest.java
+++ b/src/test/java/org/apache/commons/text/translate/AggregateTranslatorTest.java
@@ -16,7 +16,7 @@
*/
package org.apache.commons.text.translate;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.IOException;
import java.io.StringWriter;
@@ -41,26 +41,26 @@ public class AggregateTranslatorTest {
final AggregateTranslator subject = new AggregateTranslator(translator1, translator2);
final StringWriter out1 = new StringWriter();
final int result1 = subject.translate(new StringBuffer("one"), 0, out1);
- assertThat(result1).as("Incorrect code point consumption").isEqualTo(3);
- assertThat(out1.toString()).as("Incorrect value").isEqualTo("two");
+ assertEquals(3, result1, "Incorrect code point consumption");
+ assertEquals("two", out1.toString());
final StringWriter out2 = new StringWriter();
final int result2 = subject.translate(new StringBuffer("three"), 0, out2);
- assertThat(result2).as("Incorrect code point consumption").isEqualTo(5);
- assertThat(out2.toString()).as("Incorrect value").isEqualTo("four");
+ assertEquals(5, result2, "Incorrect code point consumption");
+ assertEquals("four", out2.toString(), "Incorrect value");
}
@Test
public void testNullConstructor() {
final String testString = "foo";
final AggregateTranslator subject = new AggregateTranslator((CharSequenceTranslator[]) null);
- assertThat(subject.translate(testString)).isEqualTo(testString);
+ assertEquals(testString, subject.translate(testString));
}
@Test
public void testNullVarargConstructor() {
final String testString = "foo";
final AggregateTranslator subject = new AggregateTranslator((CharSequenceTranslator) null);
- assertThat(subject.translate(testString)).isEqualTo(testString);
+ assertEquals(testString, subject.translate(testString));
}
}
diff --git a/src/test/java/org/apache/commons/text/translate/CodePointTranslatorTest.java b/src/test/java/org/apache/commons/text/translate/CodePointTranslatorTest.java
index e7fe55a0..56eb8b09 100644
--- a/src/test/java/org/apache/commons/text/translate/CodePointTranslatorTest.java
+++ b/src/test/java/org/apache/commons/text/translate/CodePointTranslatorTest.java
@@ -16,7 +16,7 @@
*/
package org.apache.commons.text.translate;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.IOException;
import java.io.PipedReader;
@@ -32,7 +32,7 @@ public class CodePointTranslatorTest {
final UnicodeEscaper unicodeEscaper = new UnicodeEscaper();
final String string = unicodeEscaper.toUtf16Escape(0);
try (PipedReader pipedReader = new PipedReader(); PipedWriter pipedWriter = new PipedWriter(pipedReader)) {
- assertThat(numericEntityEscaper.translate(string, 0, pipedWriter)).isEqualTo(1);
+ assertEquals(1, numericEntityEscaper.translate(string, 0, pipedWriter));
}
}
diff --git a/src/test/java/org/apache/commons/text/translate/CsvTranslatorsTest.java b/src/test/java/org/apache/commons/text/translate/CsvTranslatorsTest.java
index bf86136c..9804d5da 100644
--- a/src/test/java/org/apache/commons/text/translate/CsvTranslatorsTest.java
+++ b/src/test/java/org/apache/commons/text/translate/CsvTranslatorsTest.java
@@ -16,7 +16,7 @@
*/
package org.apache.commons.text.translate;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.IOException;
import java.io.StringWriter;
@@ -34,7 +34,7 @@ public class CsvTranslatorsTest {
final String input = "hi,this,is,a,test";
escaper.translateWhole(input, writer);
final String data = writer.toString();
- assertThat(data).isEqualTo("\"hi,this,is,a,test\"");
+ assertEquals("\"hi,this,is,a,test\"", data);
}
@Test
@@ -44,7 +44,7 @@ public class CsvTranslatorsTest {
final String input = "hi,this,is,a,CR,test" + String.valueOf(CharUtils.CR);
escaper.translateWhole(input, writer);
final String data = writer.toString();
- assertThat(data).isEqualTo("\"hi,this,is,a,CR,test" + String.valueOf(CharUtils.CR) + "\"");
+ assertEquals("\"hi,this,is,a,CR,test" + String.valueOf(CharUtils.CR) + "\"", data);
}
@Test
@@ -54,7 +54,7 @@ public class CsvTranslatorsTest {
final String input = "hi,this,is,a,LF,test" + String.valueOf(CharUtils.LF);
escaper.translateWhole(input, writer);
final String data = writer.toString();
- assertThat(data).isEqualTo("\"hi,this,is,a,LF,test" + String.valueOf(CharUtils.LF) + "\"");
+ assertEquals("\"hi,this,is,a,LF,test" + String.valueOf(CharUtils.LF) + "\"", data);
}
@Test
@@ -64,7 +64,7 @@ public class CsvTranslatorsTest {
final String input = "hi this is just a plane text nothing to do with csv!";
escaper.translateWhole(input, writer);
final String data = writer.toString();
- assertThat(input).isEqualTo(data);
+ assertEquals(data, input);
}
@Test
@@ -74,7 +74,7 @@ public class CsvTranslatorsTest {
final String input = "hi,this,is,a,\"quote,test";
escaper.translateWhole(input, writer);
final String data = writer.toString();
- assertThat(data).isEqualTo("\"hi,this,is,a,\"\"quote,test\"");
+ assertEquals("\"hi,this,is,a,\"\"quote,test\"", data);
}
@Test
@@ -84,7 +84,7 @@ public class CsvTranslatorsTest {
final String input = "hi,this,is,unescape,test";
escaper.translateWhole(input, writer);
final String data = writer.toString();
- assertThat(data).isEqualTo("hi,this,is,unescape,test");
+ assertEquals(input, data);
}
@Test
@@ -94,7 +94,7 @@ public class CsvTranslatorsTest {
final String input = "\"hi,this,is,unescape,test\"";
escaper.translateWhole(input, writer);
final String data = writer.toString();
- assertThat(data).isEqualTo("hi,this,is,unescape,test");
+ assertEquals("hi,this,is,unescape,test", data);
}
@Test
@@ -104,7 +104,7 @@ public class CsvTranslatorsTest {
final String input = "\"hi,this,is,unescape,test";
escaper.translateWhole(input, writer);
final String data = writer.toString();
- assertThat(input).isEqualTo(data);
+ assertEquals(input, data);
}
@Test
@@ -114,7 +114,7 @@ public class CsvTranslatorsTest {
final String input = "hi,this,is,unescape,test\"";
escaper.translateWhole(input, writer);
final String data = writer.toString();
- assertThat(input).isEqualTo(data);
+ assertEquals(input, data);
}
@Test
@@ -124,7 +124,7 @@ public class CsvTranslatorsTest {
final String input = "\"hi,this,is,\"unescape,test\"";
escaper.translateWhole(input, writer);
final String data = writer.toString();
- assertThat(data).isEqualTo("hi,this,is,\"unescape,test");
+ assertEquals("hi,this,is,\"unescape,test", data);
}
}
diff --git a/src/test/java/org/apache/commons/text/translate/EntityArraysTest.java b/src/test/java/org/apache/commons/text/translate/EntityArraysTest.java
index e05d9768..991ce292 100644
--- a/src/test/java/org/apache/commons/text/translate/EntityArraysTest.java
+++ b/src/test/java/org/apache/commons/text/translate/EntityArraysTest.java
@@ -17,7 +17,7 @@
package org.apache.commons.text.translate;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.BufferedReader;
import java.io.FileReader;
@@ -49,7 +49,7 @@ public class EntityArraysTest {
for (final CharSequence escapeKey : escapeMap.keySet()) {
for (final CharSequence unescapeKey : unescapeMap.keySet()) {
if (escapeKey == unescapeMap.get(unescapeKey)) {
- assertThat(unescapeKey).isEqualTo(escapeMap.get(escapeKey));
+ assertEquals(escapeMap.get(escapeKey), unescapeKey);
}
}
}
@@ -74,7 +74,7 @@ public class EntityArraysTest {
final Map<String, String> mapValue = (Map<String, String>) EntityArrays.class.getDeclaredField(mapVariableName).get(EntityArrays.class);
// Validate that we are not inserting into the same key twice in the map declaration. If this,
// indeed was the case the keySet().size() would be smaller than the number of put() statements
- assertThat(mapValue.size()).isEqualTo(mapDeclarationCounter);
+ assertEquals(mapDeclarationCounter, mapValue.size());
}
}
}
@@ -82,27 +82,27 @@ public class EntityArraysTest {
@Test
public void testForDuplicateDeclaredMapValuesAposMap() {
- assertThat(EntityArrays.APOS_ESCAPE.keySet()).hasSameSizeAs(EntityArrays.APOS_UNESCAPE.keySet());
+ assertEquals(EntityArrays.APOS_UNESCAPE.keySet().size(), EntityArrays.APOS_ESCAPE.keySet().size());
}
@Test
public void testForDuplicateDeclaredMapValuesBasicMap() {
- assertThat(EntityArrays.BASIC_ESCAPE.keySet()).hasSameSizeAs(EntityArrays.BASIC_UNESCAPE.keySet());
+ assertEquals(EntityArrays.BASIC_ESCAPE.keySet().size(), EntityArrays.BASIC_UNESCAPE.keySet().size());
}
@Test
public void testForDuplicateDeclaredMapValuesHtml40ExtendedMap() {
- assertThat(EntityArrays.HTML40_EXTENDED_ESCAPE.keySet()).hasSameSizeAs(EntityArrays.HTML40_EXTENDED_UNESCAPE.keySet());
+ assertEquals(EntityArrays.HTML40_EXTENDED_ESCAPE.keySet().size(), EntityArrays.HTML40_EXTENDED_UNESCAPE.keySet().size());
}
@Test
public void testForDuplicateDeclaredMapValuesISO8859Map() {
- assertThat(EntityArrays.ISO8859_1_ESCAPE.keySet()).hasSameSizeAs(EntityArrays.ISO8859_1_UNESCAPE.keySet());
+ assertEquals(EntityArrays.ISO8859_1_ESCAPE.keySet().size(), EntityArrays.ISO8859_1_UNESCAPE.keySet().size());
}
@Test
public void testForDuplicateDeclaredMapValuesJavaCtrlCharsMap() {
- assertThat(EntityArrays.JAVA_CTRL_CHARS_ESCAPE.keySet()).hasSameSizeAs(EntityArrays.JAVA_CTRL_CHARS_UNESCAPE.keySet());
+ assertEquals(EntityArrays.JAVA_CTRL_CHARS_ESCAPE.keySet().size(), EntityArrays.JAVA_CTRL_CHARS_UNESCAPE.keySet().size());
}
@Test
diff --git a/src/test/java/org/apache/commons/text/translate/JavaUnicodeEscaperTest.java b/src/test/java/org/apache/commons/text/translate/JavaUnicodeEscaperTest.java
index 98a6a9a5..021e7828 100644
--- a/src/test/java/org/apache/commons/text/translate/JavaUnicodeEscaperTest.java
+++ b/src/test/java/org/apache/commons/text/translate/JavaUnicodeEscaperTest.java
@@ -16,7 +16,7 @@
*/
package org.apache.commons.text.translate;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
@@ -28,31 +28,25 @@ public class JavaUnicodeEscaperTest {
@Test
public void testAbove() {
final JavaUnicodeEscaper jue = JavaUnicodeEscaper.above('F');
-
final String input = "ADFGZ";
final String result = jue.translate(input);
- assertThat(result).as("Failed to escape Unicode characters via the above method")
- .isEqualTo("ADF\\u0047\\u005A");
+ assertEquals("ADF\\u0047\\u005A", result, "Failed to escape Unicode characters via the above method");
}
@Test
public void testBelow() {
final JavaUnicodeEscaper jue = JavaUnicodeEscaper.below('F');
-
final String input = "ADFGZ";
final String result = jue.translate(input);
- assertThat(result).as("Failed to escape Unicode characters via the below method")
- .isEqualTo("\\u0041\\u0044FGZ");
+ assertEquals("\\u0041\\u0044FGZ", result, "Failed to escape Unicode characters via the below method");
}
@Test
public void testBetween() {
final JavaUnicodeEscaper jue = JavaUnicodeEscaper.between('F', 'L');
-
final String input = "ADFGZ";
final String result = jue.translate(input);
- assertThat(result).as("Failed to escape Unicode characters via the between method")
- .isEqualTo("AD\\u0046\\u0047Z");
+ assertEquals("AD\\u0046\\u0047Z", result, "Failed to escape Unicode characters via the between method");
}
@Test
@@ -62,6 +56,6 @@ public class JavaUnicodeEscaperTest {
// Character ?, U+24B62, Binary Code Point 0010 0100 1011 0110 0010,
// Binary UTF-167 1101 1000 0101 0010 1101 1111 0110 0010, UTF-16 Hex Code Units D852 DF62
final String encoding = jue.toUtf16Escape(Integer.parseInt("024B62", 16));
- assertThat(encoding).isEqualTo("\\uD852\\uDF62");
+ assertEquals("\\uD852\\uDF62", encoding);
}
}
diff --git a/src/test/java/org/apache/commons/text/translate/LookupTranslatorTest.java b/src/test/java/org/apache/commons/text/translate/LookupTranslatorTest.java
index 548434ff..1176c9bf 100644
--- a/src/test/java/org/apache/commons/text/translate/LookupTranslatorTest.java
+++ b/src/test/java/org/apache/commons/text/translate/LookupTranslatorTest.java
@@ -17,8 +17,8 @@
package org.apache.commons.text.translate;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
import java.io.IOException;
import java.io.StringWriter;
@@ -40,13 +40,13 @@ public class LookupTranslatorTest {
final LookupTranslator lt = new LookupTranslator(translatorMap);
final StringWriter out = new StringWriter();
final int result = lt.translate("one", 0, out);
- assertThat(result).as("Incorrect code point consumption").isEqualTo(3);
- assertThat(out.toString()).as("Incorrect value").isEqualTo("two");
+ assertEquals(3, result, "Incorrect code point consumption");
+ assertEquals("two", out.toString(), "Incorrect value");
}
@Test
public void testFailsToCreateLookupTranslatorThrowsInvalidParameterException() {
- assertThatExceptionOfType(InvalidParameterException.class).isThrownBy(() -> new LookupTranslator(null));
+ assertThrowsExactly(InvalidParameterException.class, () -> new LookupTranslator(null));
}
// Tests: https://issues.apache.org/jira/browse/LANG-882
@@ -57,8 +57,8 @@ public class LookupTranslatorTest {
final LookupTranslator lt = new LookupTranslator(translatorMap);
final StringWriter out = new StringWriter();
final int result = lt.translate(new StringBuffer("one"), 0, out);
- assertThat(result).as("Incorrect code point consumption").isEqualTo(3);
- assertThat(out.toString()).as("Incorrect value").isEqualTo("two");
+ assertEquals(3, result, "Incorrect code point consumption");
+ assertEquals("two", out.toString(), "Incorrect value");
}
@Test
@@ -71,7 +71,7 @@ public class LookupTranslatorTest {
final LookupTranslator translator = new LookupTranslator(map);
final String translated = translator.translate(symbol + "=A");
/* we should get "A=A". */
- assertThat(translated).as("Incorrect value").isEqualTo("A=A");
+ assertEquals("A=A", translated, "Incorrect value");
}
}
diff --git a/src/test/java/org/apache/commons/text/translate/NumericEntityEscaperTest.java b/src/test/java/org/apache/commons/text/translate/NumericEntityEscaperTest.java
index ff0cddf0..83275fe5 100644
--- a/src/test/java/org/apache/commons/text/translate/NumericEntityEscaperTest.java
+++ b/src/test/java/org/apache/commons/text/translate/NumericEntityEscaperTest.java
@@ -17,7 +17,7 @@
package org.apache.commons.text.translate;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
@@ -32,7 +32,7 @@ public class NumericEntityEscaperTest {
final String input = "ADFGZ";
final String result = nee.translate(input);
- assertThat(result).as("Failed to escape numeric entities via the above method").isEqualTo("ADFGZ");
+ assertEquals("ADFGZ", result, "Failed to escape numeric entities via the above method");
}
@Test
@@ -41,16 +41,15 @@ public class NumericEntityEscaperTest {
final String input = "ADFGZ";
final String result = nee.translate(input);
- assertThat(result).as("Failed to escape numeric entities via the below method").isEqualTo("ADFGZ");
+ assertEquals("ADFGZ", result, "Failed to escape numeric entities via the below method");
}
@Test
public void testBetween() {
final NumericEntityEscaper nee = NumericEntityEscaper.between('F', 'L');
-
final String input = "ADFGZ";
final String result = nee.translate(input);
- assertThat(result).as("Failed to escape numeric entities via the between method").isEqualTo("ADFGZ");
+ assertEquals("ADFGZ", result, "Failed to escape numeric entities via the between method");
}
/** See LANG-617 */
@@ -59,9 +58,8 @@ public class NumericEntityEscaperTest {
final NumericEntityEscaper nee = new NumericEntityEscaper();
final String input = "\uD803\uDC22";
final String expected = "𐰢";
-
final String result = nee.translate(input);
- assertThat(result).as("Failed to escape numeric entities supplementary characters").isEqualTo(expected);
+ assertEquals(expected, result, "Failed to escape numeric entities supplementary characters");
}
diff --git a/src/test/java/org/apache/commons/text/translate/NumericEntityUnescaperTest.java b/src/test/java/org/apache/commons/text/translate/NumericEntityUnescaperTest.java
index 5e9e86ec..997d7332 100644
--- a/src/test/java/org/apache/commons/text/translate/NumericEntityUnescaperTest.java
+++ b/src/test/java/org/apache/commons/text/translate/NumericEntityUnescaperTest.java
@@ -17,8 +17,8 @@
package org.apache.commons.text.translate;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
import org.junit.jupiter.api.Test;
@@ -32,8 +32,7 @@ public class NumericEntityUnescaperTest {
final NumericEntityUnescaper.OPTION[] numericEntityUnescaperOPTIONArray = {};
final NumericEntityUnescaper numericEntityUnescaper =
new NumericEntityUnescaper(numericEntityUnescaperOPTIONArray);
-
- assertThat(numericEntityUnescaper.translate("2|y|O7y`&#uVWj")).isEqualTo("2|y|O7y`&#uVWj");
+ assertEquals("2|y|O7y`&#uVWj", numericEntityUnescaper.translate("2|y|O7y`&#uVWj"));
}
@Test
@@ -41,18 +40,17 @@ public class NumericEntityUnescaperTest {
final NumericEntityUnescaper.OPTION[] numericEntityUnescaperOPTIONArray = {};
final NumericEntityUnescaper numericEntityUnescaper =
new NumericEntityUnescaper(numericEntityUnescaperOPTIONArray);
-
- assertThat(numericEntityUnescaper.translate("Ws2v8|O=7NR&#cB")).isEqualTo("Ws2v8|O=7NR&#cB");
+ assertEquals("Ws2v8|O=7NR&#cB", numericEntityUnescaper.translate("Ws2v8|O=7NR&#cB"));
}
@Test
public void testOutOfBounds() {
final NumericEntityUnescaper neu = new NumericEntityUnescaper();
- assertThat(neu.translate("Test &")).as("Failed to ignore when last character is &").isEqualTo("Test &");
- assertThat(neu.translate("Test &#")).as("Failed to ignore when last character is &").isEqualTo("Test &#");
- assertThat(neu.translate("Test &#x")).as("Failed to ignore when last character is &").isEqualTo("Test &#x");
- assertThat(neu.translate("Test &#X")).as("Failed to ignore when last character is &").isEqualTo("Test &#X");
+ assertEquals("Test &", neu.translate("Test &"), "Failed to ignore when last character is &");
+ assertEquals("Test &#", neu.translate("Test &#"), "Failed to ignore when last character is &");
+ assertEquals("Test &#x", neu.translate("Test &#x"), "Failed to ignore when last character is &");
+ assertEquals("Test &#X", neu.translate("Test &#X"), "Failed to ignore when last character is &");
}
@Test
@@ -62,7 +60,7 @@ public class NumericEntityUnescaperTest {
final String expected = "\uD803\uDC22";
final String result = neu.translate(input);
- assertThat(result).as("Failed to unescape numeric entities supplementary characters").isEqualTo(expected);
+ assertEquals(expected, result, "Failed to unescape numeric entities supplementary characters");
}
@Test
@@ -73,7 +71,7 @@ public class NumericEntityUnescaperTest {
String expected = "Test \u0030 not test";
String result = neu.translate(input);
- assertThat(result).as("Failed to support unfinished entities (i.e. missing semicolon)").isEqualTo(expected);
+ assertEquals(expected, result, "Failed to support unfinished entities (i.e. missing semicolon)");
// ignore it
neu = new NumericEntityUnescaper();
@@ -81,7 +79,7 @@ public class NumericEntityUnescaperTest {
expected = input;
result = neu.translate(input);
- assertThat(result).as("Failed to ignore unfinished entities (i.e. missing semicolon)").isEqualTo(expected);
+ assertEquals(expected, result, "Failed to ignore unfinished entities (i.e. missing semicolon)");
// fail it
neu = new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.errorIfNoSemiColon);
diff --git a/src/test/java/org/apache/commons/text/translate/OctalUnescaperTest.java b/src/test/java/org/apache/commons/text/translate/OctalUnescaperTest.java
index a6f60ad4..64b76c11 100644
--- a/src/test/java/org/apache/commons/text/translate/OctalUnescaperTest.java
+++ b/src/test/java/org/apache/commons/text/translate/OctalUnescaperTest.java
@@ -17,7 +17,7 @@
package org.apache.commons.text.translate;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
@@ -28,56 +28,55 @@ public class OctalUnescaperTest {
@Test
public void testBetween() {
- final OctalUnescaper oue = new OctalUnescaper(); //.between("1", "377");
+ final OctalUnescaper oue = new OctalUnescaper(); // .between("1", "377");
String input = "\\45";
String result = oue.translate(input);
- assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\45");
+ assertEquals("\45", result, "Failed to unescape octal characters via the between method");
input = "\\377";
result = oue.translate(input);
- assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\377");
+ assertEquals("\377", result, "Failed to unescape octal characters via the between method");
input = "\\377 and";
result = oue.translate(input);
- assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\377 and");
+ assertEquals("\377 and", result, "Failed to unescape octal characters via the between method");
input = "\\378 and";
result = oue.translate(input);
- assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\37" + "8 and");
+ assertEquals("\37" + "8 and", result, "Failed to unescape octal characters via the between method");
input = "\\378";
result = oue.translate(input);
- assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\37" + "8");
+ assertEquals("\37" + "8", result, "Failed to unescape octal characters via the between method");
input = "\\1";
result = oue.translate(input);
- assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\1");
+ assertEquals("\1", result, "Failed to unescape octal characters via the between method");
input = "\\036";
result = oue.translate(input);
- assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\036");
+ assertEquals("\036", result, "Failed to unescape octal characters via the between method");
input = "\\0365";
result = oue.translate(input);
- assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\036" + "5");
+ assertEquals("\036" + "5", result, "Failed to unescape octal characters via the between method");
input = "\\003";
result = oue.translate(input);
- assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\003");
+ assertEquals("\003", result, "Failed to unescape octal characters via the between method");
input = "\\0003";
result = oue.translate(input);
- assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\000" + "3");
+ assertEquals("\000" + "3", result, "Failed to unescape octal characters via the between method");
input = "\\279";
result = oue.translate(input);
- assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\279");
+ assertEquals("\279", result, "Failed to unescape octal characters via the between method");
input = "\\999";
result = oue.translate(input);
- assertThat(result).as("Failed to ignore an out of range octal character via the between method")
- .isEqualTo("\\999");
+ assertEquals("\\999", result, "Failed to ignore an out of range octal character via the between method");
}
}
diff --git a/src/test/java/org/apache/commons/text/translate/SinglePassTranslatorTest.java b/src/test/java/org/apache/commons/text/translate/SinglePassTranslatorTest.java
index f6ca1c34..39aafd15 100644
--- a/src/test/java/org/apache/commons/text/translate/SinglePassTranslatorTest.java
+++ b/src/test/java/org/apache/commons/text/translate/SinglePassTranslatorTest.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.text.translate;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import java.io.IOException;
import java.io.StringWriter;
@@ -48,19 +48,19 @@ public class SinglePassTranslatorTest {
@Test
public void testCodePointsAreReturned() throws Exception {
- assertThat(dummyTranslator.translate("", 0, out)).isEqualTo(0);
- assertThat(dummyTranslator.translate("abc", 0, out)).isEqualTo(3);
- assertThat(dummyTranslator.translate("abcdefg", 0, out)).isEqualTo(7);
+ assertEquals(0, dummyTranslator.translate("", 0, out));
+ assertEquals(3, dummyTranslator.translate("abc", 0, out));
+ assertEquals(7, dummyTranslator.translate("abcdefg", 0, out));
}
@Test
public void testIndexIsValidated() {
- assertThatIllegalArgumentException().isThrownBy(() -> dummyTranslator.translate("abc", 1, out));
+ assertThrows(IllegalArgumentException.class, () -> dummyTranslator.translate("abc", 1, out));
}
@Test
public void testTranslateThrowsIllegalArgumentException() {
- assertThatIllegalArgumentException().isThrownBy(() -> dummyTranslator.translate("(,Fk", 647, null));
+ assertThrows(IllegalArgumentException.class, () -> dummyTranslator.translate("(,Fk", 647, null));
}
}
diff --git a/src/test/java/org/apache/commons/text/translate/UnicodeEscaperTest.java b/src/test/java/org/apache/commons/text/translate/UnicodeEscaperTest.java
index 6e0f9b12..3d06c57f 100644
--- a/src/test/java/org/apache/commons/text/translate/UnicodeEscaperTest.java
+++ b/src/test/java/org/apache/commons/text/translate/UnicodeEscaperTest.java
@@ -17,42 +17,36 @@
package org.apache.commons.text.translate;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
/**
* Tests {@link UnicodeEscaper}.
*/
-public class UnicodeEscaperTest {
+public class UnicodeEscaperTest {
@Test
public void testAbove() {
- final UnicodeEscaper ue = UnicodeEscaper.above('F');
-
+ final UnicodeEscaper escaper = UnicodeEscaper.above('F');
final String input = "ADFGZ";
- final String result = ue.translate(input);
- assertThat(result).as("Failed to escape Unicode characters via the above method")
- .isEqualTo("ADF\\u0047\\u005A");
+ final String result = escaper.translate(input);
+ assertEquals("ADF\\u0047\\u005A", result, "Failed to escape Unicode characters via the above method");
}
@Test
public void testBelow() {
- final UnicodeEscaper ue = UnicodeEscaper.below('F');
-
+ final UnicodeEscaper escaper = UnicodeEscaper.below('F');
final String input = "ADFGZ";
- final String result = ue.translate(input);
- assertThat(result).as("Failed to escape Unicode characters via the below method")
- .isEqualTo("\\u0041\\u0044FGZ");
+ final String result = escaper.translate(input);
+ assertEquals("\\u0041\\u0044FGZ", result, "Failed to escape Unicode characters via the below method");
}
@Test
public void testBetween() {
- final UnicodeEscaper ue = UnicodeEscaper.between('F', 'L');
-
+ final UnicodeEscaper escaper = UnicodeEscaper.between('F', 'L');
final String input = "ADFGZ";
- final String result = ue.translate(input);
- assertThat(result).as("Failed to escape Unicode characters via the between method")
- .isEqualTo("AD\\u0046\\u0047Z");
+ final String result = escaper.translate(input);
+ assertEquals("AD\\u0046\\u0047Z", result, "Failed to escape Unicode characters via the between method");
}
}
diff --git a/src/test/java/org/apache/commons/text/translate/UnicodeUnescaperTest.java b/src/test/java/org/apache/commons/text/translate/UnicodeUnescaperTest.java
index 4a729941..3653ae33 100644
--- a/src/test/java/org/apache/commons/text/translate/UnicodeUnescaperTest.java
+++ b/src/test/java/org/apache/commons/text/translate/UnicodeUnescaperTest.java
@@ -17,7 +17,7 @@
package org.apache.commons.text.translate;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
@@ -29,27 +29,24 @@ public class UnicodeUnescaperTest {
@Test
public void testLessThanFour() {
- final UnicodeUnescaper uu = new UnicodeUnescaper();
-
+ final UnicodeUnescaper escaper = new UnicodeUnescaper();
final String input = "\\0047\\u006";
- assertThrows(IllegalArgumentException.class, () -> uu.translate(input));
+ assertThrows(IllegalArgumentException.class, () -> escaper.translate(input));
}
// Requested in LANG-507
@Test
public void testUPlus() {
- final UnicodeUnescaper uu = new UnicodeUnescaper();
-
+ final UnicodeUnescaper escaper = new UnicodeUnescaper();
final String input = "\\u+0047";
- assertThat(uu.translate(input)).as("Failed to unescape Unicode characters with 'u+' notation").isEqualTo("G");
+ assertEquals("G", escaper.translate(input), "Failed to unescape Unicode characters with 'u+' notation");
}
@Test
public void testUuuuu() {
- final UnicodeUnescaper uu = new UnicodeUnescaper();
-
+ final UnicodeUnescaper escaper = new UnicodeUnescaper();
final String input = "\\uuuuuuuu0047";
- final String result = uu.translate(input);
- assertThat(result).as("Failed to unescape Unicode characters with many 'u' characters").isEqualTo("G");
+ final String result = escaper.translate(input);
+ assertEquals("G", result, "Failed to unescape Unicode characters with many 'u' characters");
}
}
diff --git a/src/test/java/org/apache/commons/text/translate/UnicodeUnpairedSurrogateRemoverTest.java b/src/test/java/org/apache/commons/text/translate/UnicodeUnpairedSurrogateRemoverTest.java
index 20e3c8e5..cd3e8580 100644
--- a/src/test/java/org/apache/commons/text/translate/UnicodeUnpairedSurrogateRemoverTest.java
+++ b/src/test/java/org/apache/commons/text/translate/UnicodeUnpairedSurrogateRemoverTest.java
@@ -16,7 +16,9 @@
*/
package org.apache.commons.text.translate;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.CharArrayWriter;
import java.io.IOException;
@@ -32,16 +34,16 @@ public class UnicodeUnpairedSurrogateRemoverTest {
@Test
public void testInvalidCharacters() throws IOException {
- assertThat(subject.translate(0xd800, writer)).isTrue();
- assertThat(subject.translate(0xdfff, writer)).isTrue();
- assertThat(writer.size()).isZero();
+ assertTrue(subject.translate(0xd800, writer));
+ assertTrue(subject.translate(0xdfff, writer));
+ assertEquals(0, writer.size());
}
@Test
public void testValidCharacters() throws IOException {
- assertThat(subject.translate(0xd7ff, writer)).isFalse();
- assertThat(subject.translate(0xe000, writer)).isFalse();
- assertThat(writer.size()).isZero();
+ assertFalse(subject.translate(0xd7ff, writer));
+ assertFalse(subject.translate(0xe000, writer));
+ assertEquals(0, writer.size());
}
}