You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by pa...@apache.org on 2017/10/27 14:26:16 UTC
[1/5] [text] Partial and mostly automated migration of assertions
from JUnit to AssertJ. (closes #70)
Repository: commons-text
Updated Branches:
refs/heads/master 6665a0209 -> e55d0ac1c
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/translate/UnicodeEscaperTest.java
----------------------------------------------------------------------
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 9b3a3ff..c4026c9 100644
--- a/src/test/java/org/apache/commons/text/translate/UnicodeEscaperTest.java
+++ b/src/test/java/org/apache/commons/text/translate/UnicodeEscaperTest.java
@@ -19,7 +19,7 @@ package org.apache.commons.text.translate;
import org.junit.Test;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link UnicodeEscaper}.
@@ -32,7 +32,8 @@ public class UnicodeEscaperTest {
final String input = "ADFGZ";
final String result = ue.translate(input);
- assertEquals("Failed to escape Unicode characters via the below method", "\\u0041\\u0044FGZ", result);
+ assertThat(result).as("Failed to escape Unicode characters via the below method")
+ .isEqualTo("\\u0041\\u0044FGZ");
}
@Test
@@ -41,7 +42,8 @@ public class UnicodeEscaperTest {
final String input = "ADFGZ";
final String result = ue.translate(input);
- assertEquals("Failed to escape Unicode characters via the between method", "AD\\u0046\\u0047Z", result);
+ assertThat(result).as("Failed to escape Unicode characters via the between method")
+ .isEqualTo("AD\\u0046\\u0047Z");
}
@Test
@@ -50,6 +52,7 @@ public class UnicodeEscaperTest {
final String input = "ADFGZ";
final String result = ue.translate(input);
- assertEquals("Failed to escape Unicode characters via the above method", "ADF\\u0047\\u005A", result);
+ assertThat(result).as("Failed to escape Unicode characters via the above method")
+ .isEqualTo("ADF\\u0047\\u005A");
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/translate/UnicodeUnescaperTest.java
----------------------------------------------------------------------
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 a840238..472a21c 100644
--- a/src/test/java/org/apache/commons/text/translate/UnicodeUnescaperTest.java
+++ b/src/test/java/org/apache/commons/text/translate/UnicodeUnescaperTest.java
@@ -19,8 +19,8 @@ package org.apache.commons.text.translate;
import org.junit.Test;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
/**
* Unit tests for {@link UnicodeEscaper}.
@@ -33,7 +33,7 @@ public class UnicodeUnescaperTest {
final UnicodeUnescaper uu = new UnicodeUnescaper();
final String input = "\\u+0047";
- assertEquals("Failed to unescape Unicode characters with 'u+' notation", "G", uu.translate(input));
+ assertThat(uu.translate(input)).as("Failed to unescape Unicode characters with 'u+' notation").isEqualTo("G");
}
@Test
@@ -42,7 +42,7 @@ public class UnicodeUnescaperTest {
final String input = "\\uuuuuuuu0047";
final String result = uu.translate(input);
- assertEquals("Failed to unescape Unicode characters with many 'u' characters", "G", result);
+ assertThat(result).as("Failed to unescape Unicode characters with many 'u' characters").isEqualTo("G");
}
@Test
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/translate/UnicodeUnpairedSurrogateRemoverTest.java
----------------------------------------------------------------------
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 ab688ab..7eacb57 100644
--- a/src/test/java/org/apache/commons/text/translate/UnicodeUnpairedSurrogateRemoverTest.java
+++ b/src/test/java/org/apache/commons/text/translate/UnicodeUnpairedSurrogateRemoverTest.java
@@ -21,9 +21,7 @@ import org.junit.Test;
import java.io.CharArrayWriter;
import java.io.IOException;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link UnicodeUnpairedSurrogateRemover}.
@@ -34,16 +32,16 @@ public class UnicodeUnpairedSurrogateRemoverTest {
@Test
public void testValidCharacters() throws IOException {
- assertFalse(subject.translate(0xd7ff, writer));
- assertFalse(subject.translate(0xe000, writer));
- assertEquals(0, writer.size());
+ assertThat(subject.translate(0xd7ff, writer)).isFalse();
+ assertThat(subject.translate(0xe000, writer)).isFalse();
+ assertThat(writer.size()).isZero();
}
@Test
public void testInvalidCharacters() throws IOException {
- assertTrue(subject.translate(0xd800, writer));
- assertTrue(subject.translate(0xdfff, writer));
- assertEquals(0, writer.size());
+ assertThat(subject.translate(0xd800, writer)).isTrue();
+ assertThat(subject.translate(0xdfff, writer)).isTrue();
+ assertThat(writer.size()).isZero();
}
}
[3/5] [text] Partial and mostly automated migration of assertions
from JUnit to AssertJ. (closes #70)
Posted by pa...@apache.org.
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/WordUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/text/WordUtilsTest.java b/src/test/java/org/apache/commons/text/WordUtilsTest.java
index 2b374c6..53684ae 100644
--- a/src/test/java/org/apache/commons/text/WordUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/WordUtilsTest.java
@@ -16,11 +16,7 @@
*/
package org.apache.commons.text;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
@@ -36,124 +32,124 @@ public class WordUtilsTest {
// -----------------------------------------------------------------------
@Test
public void testConstructor() {
- assertNotNull(new WordUtils());
+ assertThat(new WordUtils()).isNotNull();
final Constructor<?>[] cons = WordUtils.class.getDeclaredConstructors();
- assertEquals(1, cons.length);
- assertTrue(Modifier.isPublic(cons[0].getModifiers()));
- assertTrue(Modifier.isPublic(WordUtils.class.getModifiers()));
- assertFalse(Modifier.isFinal(WordUtils.class.getModifiers()));
+ 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();
}
// -----------------------------------------------------------------------
@Test
public void testWrap_StringInt() {
- assertNull(WordUtils.wrap(null, 20));
- assertNull(WordUtils.wrap(null, -1));
+ assertThat(WordUtils.wrap(null, 20)).isNull();
+ assertThat(WordUtils.wrap(null, -1)).isNull();
- assertEquals("", WordUtils.wrap("", 20));
- assertEquals("", WordUtils.wrap("", -1));
+ assertThat(WordUtils.wrap("", 20)).isEqualTo("");
+ assertThat(WordUtils.wrap("", -1)).isEqualTo("");
// 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.";
- assertEquals(expected, WordUtils.wrap(input, 20));
+ assertThat(WordUtils.wrap(input, 20)).isEqualTo(expected);
// long word at end
input = "Click here to jump to the commons website - http://commons.apache.org";
expected = "Click here to jump" + systemNewLine + "to the commons" + systemNewLine + "website -" + systemNewLine
+ "http://commons.apache.org";
- assertEquals(expected, WordUtils.wrap(input, 20));
+ assertThat(WordUtils.wrap(input, 20)).isEqualTo(expected);
// long word in middle
input = "Click here, http://commons.apache.org, to jump to the commons website";
expected = "Click here," + systemNewLine + "http://commons.apache.org," + systemNewLine + "to jump to the"
+ systemNewLine + "commons website";
- assertEquals(expected, WordUtils.wrap(input, 20));
+ assertThat(WordUtils.wrap(input, 20)).isEqualTo(expected);
// leading spaces on a new line are stripped
// trailing spaces are not stripped
input = "word1 word2 word3";
expected = "word1 " + systemNewLine + "word2 " + systemNewLine + "word3";
- assertEquals(expected, WordUtils.wrap(input, 7));
+ assertThat(WordUtils.wrap(input, 7)).isEqualTo(expected);
}
@Test
public void testWrap_StringIntStringBoolean() {
- 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));
+ 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("");
// 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.";
- assertEquals(expected, WordUtils.wrap(input, 20, "\n", false));
- assertEquals(expected, WordUtils.wrap(input, 20, "\n", true));
+ assertThat(WordUtils.wrap(input, 20, "\n", false)).isEqualTo(expected);
+ assertThat(WordUtils.wrap(input, 20, "\n", true)).isEqualTo(expected);
// 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.";
- assertEquals(expected, WordUtils.wrap(input, 20, "<br />", false));
- assertEquals(expected, WordUtils.wrap(input, 20, "<br />", true));
+ assertThat(WordUtils.wrap(input, 20, "<br />", false)).isEqualTo(expected);
+ assertThat(WordUtils.wrap(input, 20, "<br />", true)).isEqualTo(expected);
// short line length
input = "Here is one line";
expected = "Here\nis one\nline";
- assertEquals(expected, WordUtils.wrap(input, 6, "\n", false));
+ assertThat(WordUtils.wrap(input, 6, "\n", false)).isEqualTo(expected);
expected = "Here\nis\none\nline";
- assertEquals(expected, WordUtils.wrap(input, 2, "\n", false));
- assertEquals(expected, WordUtils.wrap(input, -1, "\n", false));
+ assertThat(WordUtils.wrap(input, 2, "\n", false)).isEqualTo(expected);
+ assertThat(WordUtils.wrap(input, -1, "\n", false)).isEqualTo(expected);
// 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.";
- assertEquals(expected, WordUtils.wrap(input, 20, null, false));
- assertEquals(expected, WordUtils.wrap(input, 20, null, true));
+ assertThat(WordUtils.wrap(input, 20, null, false)).isEqualTo(expected);
+ assertThat(WordUtils.wrap(input, 20, null, true)).isEqualTo(expected);
// 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.";
- assertEquals(expected, WordUtils.wrap(input, 20, "\n", false));
- assertEquals(expected, WordUtils.wrap(input, 20, "\n", true));
+ assertThat(WordUtils.wrap(input, 20, "\n", false)).isEqualTo(expected);
+ assertThat(WordUtils.wrap(input, 20, "\n", true)).isEqualTo(expected);
// 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.";
- assertEquals(expected, WordUtils.wrap(input, 20, "\n", false));
- assertEquals(expected, WordUtils.wrap(input, 20, "\n", true));
+ assertThat(WordUtils.wrap(input, 20, "\n", false)).isEqualTo(expected);
+ assertThat(WordUtils.wrap(input, 20, "\n", true)).isEqualTo(expected);
// 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.";
- assertEquals(expected, WordUtils.wrap(input, 20, "\n", false));
- assertEquals(expected, WordUtils.wrap(input, 20, "\n", true));
+ assertThat(WordUtils.wrap(input, 20, "\n", false)).isEqualTo(expected);
+ assertThat(WordUtils.wrap(input, 20, "\n", true)).isEqualTo(expected);
// difference because of long word
input = "Click here to jump to the commons website - http://commons.apache.org";
expected = "Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org";
- assertEquals(expected, WordUtils.wrap(input, 20, "\n", false));
+ assertThat(WordUtils.wrap(input, 20, "\n", false)).isEqualTo(expected);
expected = "Click here to jump\nto the commons\nwebsite -\nhttp://commons.apach\ne.org";
- assertEquals(expected, WordUtils.wrap(input, 20, "\n", true));
+ assertThat(WordUtils.wrap(input, 20, "\n", true)).isEqualTo(expected);
// difference because of long word in middle
input = "Click here, http://commons.apache.org, to jump to the commons website";
expected = "Click here,\nhttp://commons.apache.org,\nto jump to the\ncommons website";
- assertEquals(expected, WordUtils.wrap(input, 20, "\n", false));
+ assertThat(WordUtils.wrap(input, 20, "\n", false)).isEqualTo(expected);
expected = "Click here,\nhttp://commons.apach\ne.org, to jump to\nthe commons website";
- assertEquals(expected, WordUtils.wrap(input, 20, "\n", true));
+ assertThat(WordUtils.wrap(input, 20, "\n", true)).isEqualTo(expected);
}
@Test
@@ -162,358 +158,360 @@ public class WordUtilsTest {
// no changes test
String input = "flammable/inflammable";
String expected = "flammable/inflammable";
- assertEquals(expected, WordUtils.wrap(input, 30, "\n", false, "/"));
+ assertThat(WordUtils.wrap(input, 30, "\n", false, "/")).isEqualTo(expected);
// wrap on / and small width
expected = "flammable\ninflammable";
- assertEquals(expected, WordUtils.wrap(input, 2, "\n", false, "/"));
+ assertThat(WordUtils.wrap(input, 2, "\n", false, "/")).isEqualTo(expected);
// wrap long words on / 1
expected = "flammable\ninflammab\nle";
- assertEquals(expected, WordUtils.wrap(input, 9, "\n", true, "/"));
+ assertThat(WordUtils.wrap(input, 9, "\n", true, "/")).isEqualTo(expected);
// wrap long words on / 2
expected = "flammable\ninflammable";
- assertEquals(expected, WordUtils.wrap(input, 15, "\n", true, "/"));
+ assertThat(WordUtils.wrap(input, 15, "\n", true, "/")).isEqualTo(expected);
// wrap long words on / 3
input = "flammableinflammable";
expected = "flammableinflam\nmable";
- assertEquals(expected, WordUtils.wrap(input, 15, "\n", true, "/"));
+ assertThat(WordUtils.wrap(input, 15, "\n", true, "/")).isEqualTo(expected);
}
// -----------------------------------------------------------------------
@Test
public void testCapitalize_String() {
- assertNull(WordUtils.capitalize(null));
- assertEquals("", WordUtils.capitalize(""));
- assertEquals(" ", WordUtils.capitalize(" "));
-
- 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"));
+ assertThat(WordUtils.capitalize(null)).isNull();
+ assertThat(WordUtils.capitalize("")).isEqualTo("");
+ assertThat(WordUtils.capitalize(" ")).isEqualTo(" ");
+
+ 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");
}
@Test
public void testCapitalizeWithDelimiters_String() {
- assertNull(WordUtils.capitalize(null, null));
- assertEquals("", WordUtils.capitalize("", new char[0]));
- assertEquals(" ", WordUtils.capitalize(" ", new char[0]));
+ assertThat(WordUtils.capitalize(null, null)).isNull();
+ assertThat(WordUtils.capitalize("", new char[0])).isEqualTo("");
+ assertThat(WordUtils.capitalize(" ", new char[0])).isEqualTo(" ");
char[] chars = new char[] {'-', '+', ' ', '@'};
- 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));
+ 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[] {'.'};
- assertEquals("I aM.Fine", WordUtils.capitalize("i aM.fine", chars));
- assertEquals("I Am.fine", WordUtils.capitalize("i am.fine", null));
+ assertThat(WordUtils.capitalize("i aM.fine", chars)).isEqualTo("I aM.Fine");
+ assertThat(WordUtils.capitalize("i am.fine", null)).isEqualTo("I Am.fine");
}
@Test
public void testCapitalizeFully_String() {
- 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
+ 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
}
@Test
public void testCapitalizeFully_Text88() {
- assertEquals("I am fine now", WordUtils.capitalizeFully("i am fine now", new char[] {}));
+ assertThat(WordUtils.capitalizeFully("i am fine now", new char[] {})).isEqualTo("I am fine now");
}
@Test
public void testUnCapitalize_Text88() {
- assertEquals("i am fine now", WordUtils.uncapitalize("I am fine now", new char[] {}));
+ assertThat(WordUtils.uncapitalize("I am fine now", new char[] {})).isEqualTo("i am fine now");
}
@Test
public void testCapitalizeFullyWithDelimiters_String() {
- assertNull(WordUtils.capitalizeFully(null, null));
- assertEquals("", WordUtils.capitalizeFully("", new char[0]));
- assertEquals(" ", WordUtils.capitalizeFully(" ", new char[0]));
+ assertThat(WordUtils.capitalizeFully(null, null)).isNull();
+ assertThat(WordUtils.capitalizeFully("", new char[0])).isEqualTo("");
+ assertThat(WordUtils.capitalizeFully(" ", new char[0])).isEqualTo(" ");
char[] chars = new char[] {'-', '+', ' ', '@'};
- 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));
+ 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[] {'.'};
- 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
+ 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
}
@Test
public void testContainsAllWords_StringString() {
- assertFalse(WordUtils.containsAllWords(null, (String) null));
- assertFalse(WordUtils.containsAllWords(null, ""));
- assertFalse(WordUtils.containsAllWords(null, "ab"));
-
- assertFalse(WordUtils.containsAllWords("", (String) null));
- assertFalse(WordUtils.containsAllWords("", ""));
- assertFalse(WordUtils.containsAllWords("", "ab"));
-
- assertFalse(WordUtils.containsAllWords("foo", (String) null));
- assertFalse(WordUtils.containsAllWords("bar", ""));
- assertFalse(WordUtils.containsAllWords("zzabyycdxx", "by"));
- assertTrue(WordUtils.containsAllWords("lorem ipsum dolor sit amet", "ipsum", "lorem", "dolor"));
- assertFalse(WordUtils.containsAllWords("lorem ipsum dolor sit amet", "ipsum", null, "lorem", "dolor"));
- assertFalse(WordUtils.containsAllWords("lorem ipsum null dolor sit amet", "ipsum", null, "lorem", "dolor"));
- assertFalse(WordUtils.containsAllWords("ab", "b"));
- assertFalse(WordUtils.containsAllWords("ab", "z"));
+ assertThat(WordUtils.containsAllWords(null, (String) null)).isFalse();
+ assertThat(WordUtils.containsAllWords(null, "")).isFalse();
+ assertThat(WordUtils.containsAllWords(null, "ab")).isFalse();
+
+ assertThat(WordUtils.containsAllWords("", (String) null)).isFalse();
+ assertThat(WordUtils.containsAllWords("", "")).isFalse();
+ assertThat(WordUtils.containsAllWords("", "ab")).isFalse();
+
+ assertThat(WordUtils.containsAllWords("foo", (String) null)).isFalse();
+ assertThat(WordUtils.containsAllWords("bar", "")).isFalse();
+ assertThat(WordUtils.containsAllWords("zzabyycdxx", "by")).isFalse();
+ assertThat(WordUtils.containsAllWords("lorem ipsum dolor sit amet", "ipsum", "lorem", "dolor")).isTrue();
+ assertThat(WordUtils.containsAllWords("lorem ipsum dolor sit amet", "ipsum", null, "lorem", "dolor")).isFalse();
+ assertThat(WordUtils.containsAllWords("lorem ipsum null dolor sit amet", "ipsum", null, "lorem", "dolor"))
+ .isFalse();
+ assertThat(WordUtils.containsAllWords("ab", "b")).isFalse();
+ assertThat(WordUtils.containsAllWords("ab", "z")).isFalse();
}
@Test
public void testUncapitalize_String() {
- 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"));
+ 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");
}
@Test
public void testUncapitalizeWithDelimiters_String() {
- assertNull(WordUtils.uncapitalize(null, null));
- assertEquals("", WordUtils.uncapitalize("", new char[0]));
- assertEquals(" ", WordUtils.uncapitalize(" ", new char[0]));
+ assertThat(WordUtils.uncapitalize(null, null)).isNull();
+ assertThat(WordUtils.uncapitalize("", new char[0])).isEqualTo("");
+ assertThat(WordUtils.uncapitalize(" ", new char[0])).isEqualTo(" ");
char[] chars = new char[] {'-', '+', ' ', '@'};
- 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));
+ 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[] {'.'};
- assertEquals("i AM.fINE", WordUtils.uncapitalize("I AM.FINE", chars));
- assertEquals("i aM.FINE", WordUtils.uncapitalize("I AM.FINE", null));
+ assertThat(WordUtils.uncapitalize("I AM.FINE", chars)).isEqualTo("i AM.fINE");
+ assertThat(WordUtils.uncapitalize("I AM.FINE", null)).isEqualTo("i aM.FINE");
}
// -----------------------------------------------------------------------
@Test
public void testInitials_String() {
- assertNull(WordUtils.initials(null));
- assertEquals("", WordUtils.initials(""));
- assertEquals("", WordUtils.initials(" "));
-
- 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"));
+ assertThat(WordUtils.initials(null)).isNull();
+ assertThat(WordUtils.initials("")).isEqualTo("");
+ assertThat(WordUtils.initials(" ")).isEqualTo("");
+
+ 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");
}
// -----------------------------------------------------------------------
@Test
public void testInitials_String_charArray() {
char[] array = null;
- 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));
+ 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");
array = new char[0];
- 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));
+ 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("");
array = " ".toCharArray();
- 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));
+ 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");
array = " .".toCharArray();
- 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));
+ 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");
array = " .'".toCharArray();
- 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));
+ 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");
array = "SIJo1".toCharArray();
- 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));
+ 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");
}
@Test
public void testInitialsSurrogatePairs() {
// Tests with space as default delimiter
- 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));
+ 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");
// Tests with UTF-16 as delimiters
- 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'}));
+ 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");
// Tests with UTF-32 as delimiters
- 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'}));
+ 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");
}
// -----------------------------------------------------------------------
@Test
public void testSwapCase_String() {
- assertNull(WordUtils.swapCase(null));
- assertEquals("", WordUtils.swapCase(""));
- assertEquals(" ", WordUtils.swapCase(" "));
+ assertThat(WordUtils.swapCase(null)).isNull();
+ assertThat(WordUtils.swapCase("")).isEqualTo("");
+ assertThat(WordUtils.swapCase(" ")).isEqualTo(" ");
- 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"));
+ 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");
final String test = "This String contains a TitleCase character: \u01C8";
final String expect = "tHIS sTRING CONTAINS A tITLEcASE CHARACTER: \u01C9";
- assertEquals(expect, WordUtils.swapCase(test));
+ assertThat(WordUtils.swapCase(test)).isEqualTo(expect);
}
// -----------------------------------------------------------------------
@Test
public void testAbbreviateForNullAndEmptyString() {
- 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, ""));
+ 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("");
}
// -----------------------------------------------------------------------
@Test
public void testAbbreviateForUpperLimit() {
- assertEquals("01234", WordUtils.abbreviate("0123456789", 0, 5, ""));
- assertEquals("012", WordUtils.abbreviate("012 3456789", 2, 5, ""));
- assertEquals("0123456789", WordUtils.abbreviate("0123456789", 0, -1, ""));
+ 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");
}
// -----------------------------------------------------------------------
@Test
public void testAbbreviateForUpperLimitAndAppendedString() {
- assertEquals("01234-", WordUtils.abbreviate("0123456789", 0, 5, "-"));
- assertEquals("012", WordUtils.abbreviate("012 3456789", 2, 5, null));
- assertEquals("0123456789", WordUtils.abbreviate("0123456789", 0, -1, ""));
+ 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");
}
// -----------------------------------------------------------------------
@Test
public void testAbbreviateForLowerValue() {
- 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));
+ 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");
}
// -----------------------------------------------------------------------
@Test
public void testAbbreviateForLowerValueAndAppendedString() {
- 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, ""));
+ 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");
}
@Test(expected = IllegalArgumentException.class)
public void testAbbreviateForLowerThanMinusOneValues() {
- assertEquals("01 23 45 67", WordUtils.abbreviate("01 23 45 67 89", 9, -10, null));
+ assertThat(WordUtils.abbreviate("01 23 45 67 89", 9, -10, null)).isEqualTo("01 23 45 67");
}
@Test(expected = IllegalArgumentException.class)
public void testAbbreviateUpperLessThanLowerValues() {
- assertEquals("01234", WordUtils.abbreviate("0123456789", 5, 2, ""));
+ assertThat(WordUtils.abbreviate("0123456789", 5, 2, "")).isEqualTo("01234");
}
@Test
public void testLANG673() throws Exception {
- 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, ""));
+ 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");
}
@Test
@@ -526,7 +524,7 @@ public class WordUtilsTest {
@Test
public void testContainsAllWordsWithNull() {
- assertFalse(WordUtils.containsAllWords("M", null));
+ assertThat(WordUtils.containsAllWords("M", null)).isFalse();
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/diff/ReplacementsFinderTest.java
----------------------------------------------------------------------
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 8b99d03..fddf406 100644
--- a/src/test/java/org/apache/commons/text/diff/ReplacementsFinderTest.java
+++ b/src/test/java/org/apache/commons/text/diff/ReplacementsFinderTest.java
@@ -16,7 +16,7 @@
*/
package org.apache.commons.text.diff;
import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
@@ -77,7 +77,7 @@ public class ReplacementsFinderTest {
final StringsComparator sc = new StringsComparator(left, right);
final ReplacementsFinder<Character> replacementFinder = new ReplacementsFinder<>(handler);
sc.getScript().visit(replacementFinder);
- assertEquals("Skipped characters do not match", skipped, handler.getSkipped());
+ assertThat(handler.getSkipped()).as("Skipped characters do not match").isEqualTo(skipped);
assertArrayEquals("From characters do not match", from,
handler.getFrom().toArray(new Character[0]));
assertArrayEquals("To characters do not match", to,
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/diff/StringsComparatorTest.java
----------------------------------------------------------------------
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 70636a5..f731d16 100644
--- a/src/test/java/org/apache/commons/text/diff/StringsComparatorTest.java
+++ b/src/test/java/org/apache/commons/text/diff/StringsComparatorTest.java
@@ -22,7 +22,7 @@ import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for the StringsComparator.
@@ -37,7 +37,7 @@ 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));
- assertEquals(length[i], comparator.getScript().getModifications());
+ assertThat(comparator.getScript().getModifications()).isEqualTo(length[i]);
}
}
@@ -45,7 +45,7 @@ public class StringsComparatorTest {
public void testLongestCommonSubsequence() {
for (int i = 0; i < before.size(); ++i) {
final StringsComparator comparator = new StringsComparator(before.get(i), after.get(i));
- assertEquals(lcs[i], comparator.getScript().getLCSLength());
+ assertThat(comparator.getScript().getLCSLength()).isEqualTo(lcs[i]);
}
}
@@ -54,7 +54,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);
- assertEquals(after.get(i), ev.getString());
+ assertThat(ev.getString()).isEqualTo(after.get(i));
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/similarity/CosineDistanceTest.java
----------------------------------------------------------------------
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 68ea13c..51f7194 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.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
import java.math.BigDecimal;
import java.math.RoundingMode;
@@ -47,12 +47,13 @@ public class CosineDistanceTest {
*/
@Test
public void testCosineDistance() {
- 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(
+ 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(
"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")));
+ "the boy was from tamana shi, kumamoto, and the boy was from rio de janeiro, rio de janeiro")))
+ .isEqualTo(Double.valueOf(0.08d));
}
// --- Utility methods
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/similarity/CosineSimilarityTest.java
----------------------------------------------------------------------
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 5197248..73d9b48 100644
--- a/src/test/java/org/apache/commons/text/similarity/CosineSimilarityTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/CosineSimilarityTest.java
@@ -21,7 +21,8 @@ import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.within;
public class CosineSimilarityTest {
@@ -34,7 +35,7 @@ public class CosineSimilarityTest {
hashMap.put("3J/$3.L", integer);
final Map<CharSequence, Integer> hashMapTwo = new HashMap<>();
- assertEquals(0.0, cosineSimilarity.cosineSimilarity(hashMap, hashMapTwo), 0.01);
+ assertThat(cosineSimilarity.cosineSimilarity(hashMap, hashMapTwo)).isEqualTo(0.0, within(0.01));
}
@Test(expected = IllegalArgumentException.class)
@@ -55,7 +56,7 @@ public class CosineSimilarityTest {
final CosineSimilarity cosineSimilarity = new CosineSimilarity();
final Map<CharSequence, Integer> hashMap = new HashMap<>();
- assertEquals(0.0, cosineSimilarity.cosineSimilarity(hashMap, hashMap), 0.01);
+ assertThat(cosineSimilarity.cosineSimilarity(hashMap, hashMap)).isEqualTo(0.0, within(0.01));
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/similarity/FuzzyScoreTest.java
----------------------------------------------------------------------
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 1c88789..2261bd5 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,7 @@
*/
package org.apache.commons.text.similarity;
-import static junit.framework.TestCase.assertSame;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
import java.util.Locale;
@@ -32,14 +31,13 @@ public class FuzzyScoreTest {
@Test
public void testGetFuzzyScore() throws Exception {
- assertEquals(0, (int) ENGLISH_SCORE.fuzzyScore("", ""));
- assertEquals(0, (int) ENGLISH_SCORE.fuzzyScore("Workshop", "b"));
- assertEquals(1, (int) ENGLISH_SCORE.fuzzyScore("Room", "o"));
- assertEquals(1, (int) ENGLISH_SCORE.fuzzyScore("Workshop", "w"));
- assertEquals(2, (int) ENGLISH_SCORE.fuzzyScore("Workshop", "ws"));
- assertEquals(4, (int) ENGLISH_SCORE.fuzzyScore("Workshop", "wo"));
- assertEquals(3, (int) ENGLISH_SCORE.fuzzyScore(
- "Apache Software Foundation", "asf"));
+ 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);
}
@Test(expected = IllegalArgumentException.class)
@@ -68,7 +66,7 @@ public class FuzzyScoreTest {
final FuzzyScore fuzzyScore = new FuzzyScore(locale);
final Locale localeTwo = fuzzyScore.getLocale();
- assertSame(locale, localeTwo);
+ assertThat(localeTwo).isSameAs(locale);
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/similarity/HammingDistanceTest.java
----------------------------------------------------------------------
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 704ebae..6ce2314 100644
--- a/src/test/java/org/apache/commons/text/similarity/HammingDistanceTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/HammingDistanceTest.java
@@ -16,7 +16,7 @@
*/
package org.apache.commons.text.similarity;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
import org.junit.BeforeClass;
import org.junit.Test;
@@ -35,14 +35,14 @@ public class HammingDistanceTest {
@Test
public void testHammingDistance() {
- assertEquals(Integer.valueOf(0), distance.apply("", ""));
- assertEquals(Integer.valueOf(0), distance.apply("pappa", "pappa"));
- assertEquals(Integer.valueOf(1), distance.apply("papaa", "pappa"));
- assertEquals(Integer.valueOf(3), distance.apply("karolin", "kathrin"));
- assertEquals(Integer.valueOf(3), distance.apply("karolin", "kerstin"));
- assertEquals(Integer.valueOf(2), distance.apply("1011101", "1001001"));
- assertEquals(Integer.valueOf(3), distance.apply("2173896", "2233796"));
- assertEquals(Integer.valueOf(2), distance.apply("ATCG", "ACCC"));
+ assertThat(distance.apply("", "")).isEqualTo(0);
+ assertThat(distance.apply("pappa", "pappa")).isEqualTo(0);
+ assertThat(distance.apply("papaa", "pappa")).isEqualTo(1);
+ assertThat(distance.apply("karolin", "kathrin")).isEqualTo(3);
+ assertThat(distance.apply("karolin", "kerstin")).isEqualTo(3);
+ assertThat(distance.apply("1011101", "1001001")).isEqualTo(2);
+ assertThat(distance.apply("2173896", "2233796")).isEqualTo(3);
+ assertThat(distance.apply("ATCG", "ACCC")).isEqualTo(2);
}
@Test(expected = IllegalArgumentException.class)
[4/5] [text] Partial and mostly automated migration of assertions
from JUnit to AssertJ. (closes #70)
Posted by pa...@apache.org.
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/StrBuilderAppendInsertTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/text/StrBuilderAppendInsertTest.java b/src/test/java/org/apache/commons/text/StrBuilderAppendInsertTest.java
index cfbfed6..3078808 100644
--- a/src/test/java/org/apache/commons/text/StrBuilderAppendInsertTest.java
+++ b/src/test/java/org/apache/commons/text/StrBuilderAppendInsertTest.java
@@ -17,8 +17,8 @@
package org.apache.commons.text;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
import java.text.DecimalFormatSymbols;
import java.util.Arrays;
@@ -49,11 +49,11 @@ public class StrBuilderAppendInsertTest {
public void testAppendNewLine() {
StrBuilder sb = new StrBuilder("---");
sb.appendNewLine().append("+++");
- assertEquals("---" + SEP + "+++", sb.toString());
+ assertThat(sb.toString()).isEqualTo("---" + SEP + "+++");
sb = new StrBuilder("---");
sb.setNewLineText("#").appendNewLine().setNewLineText(null).appendNewLine();
- assertEquals("---#" + SEP, sb.toString());
+ assertThat(sb.toString()).isEqualTo("---#" + SEP);
}
//-----------------------------------------------------------------------
@@ -61,31 +61,31 @@ public class StrBuilderAppendInsertTest {
public void testAppendWithNullText() {
final StrBuilder sb = new StrBuilder();
sb.setNullText("NULL");
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.appendNull();
- assertEquals("NULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULL");
sb.append((Object) null);
- assertEquals("NULLNULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULLNULL");
sb.append(FOO);
- assertEquals("NULLNULLfoo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULLNULLfoo");
sb.append((String) null);
- assertEquals("NULLNULLfooNULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULLNULLfooNULL");
sb.append("");
- assertEquals("NULLNULLfooNULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULLNULLfooNULL");
sb.append("bar");
- assertEquals("NULLNULLfooNULLbar", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULLNULLfooNULLbar");
sb.append((StringBuffer) null);
- assertEquals("NULLNULLfooNULLbarNULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULLNULLfooNULLbarNULL");
sb.append(new StringBuffer("baz"));
- assertEquals("NULLNULLfooNULLbarNULLbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULLNULLfooNULLbarNULLbaz");
}
//-----------------------------------------------------------------------
@@ -93,28 +93,28 @@ public class StrBuilderAppendInsertTest {
public void testAppend_Object() {
final StrBuilder sb = new StrBuilder();
sb.appendNull();
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.append((Object) null);
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.append(FOO);
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append((StringBuffer) null);
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append(new StringBuffer("baz"));
- assertEquals("foobaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobaz");
sb.append(new StrBuilder("yes"));
- assertEquals("foobazyes", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobazyes");
sb.append((CharSequence) "Seq");
- assertEquals("foobazyesSeq", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobazyesSeq");
sb.append(new StringBuilder("bld")); // Check it supports StringBuilder
- assertEquals("foobazyesSeqbld", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobazyesSeqbld");
}
//-----------------------------------------------------------------------
@@ -122,17 +122,17 @@ public class StrBuilderAppendInsertTest {
public void testAppend_StringBuilder() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((String) null);
- assertEquals("NULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULL");
sb = new StrBuilder();
sb.append(new StringBuilder("foo"));
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append(new StringBuilder(""));
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append(new StringBuilder("bar"));
- assertEquals("foobar", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobar");
}
//-----------------------------------------------------------------------
@@ -140,17 +140,17 @@ public class StrBuilderAppendInsertTest {
public void testAppend_String() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((String) null);
- assertEquals("NULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULL");
sb = new StrBuilder();
sb.append("foo");
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append("");
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append("bar");
- assertEquals("foobar", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobar");
}
//-----------------------------------------------------------------------
@@ -158,11 +158,11 @@ public class StrBuilderAppendInsertTest {
public void testAppend_String_int_int() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((String) null, 0, 1);
- assertEquals("NULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULL");
sb = new StrBuilder();
sb.append("foo", 0, 3);
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
try {
sb.append("bar", -1, 1);
@@ -207,13 +207,13 @@ public class StrBuilderAppendInsertTest {
}
sb.append("bar", 3, 0);
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append("abcbardef", 3, 3);
- assertEquals("foobar", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobar");
sb.append((CharSequence) "abcbardef", 4, 3);
- assertEquals("foobarard", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobarard");
}
//-----------------------------------------------------------------------
@@ -221,11 +221,11 @@ public class StrBuilderAppendInsertTest {
public void testAppend_StringBuilder_int_int() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((String) null, 0, 1);
- assertEquals("NULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULL");
sb = new StrBuilder();
sb.append(new StringBuilder("foo"), 0, 3);
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
try {
sb.append(new StringBuilder("bar"), -1, 1);
@@ -270,13 +270,13 @@ public class StrBuilderAppendInsertTest {
}
sb.append(new StringBuilder("bar"), 3, 0);
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append(new StringBuilder("abcbardef"), 3, 3);
- assertEquals("foobar", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobar");
sb.append(new StringBuilder("abcbardef"), 4, 3);
- assertEquals("foobarard", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobarard");
}
//-----------------------------------------------------------------------
@@ -284,17 +284,17 @@ public class StrBuilderAppendInsertTest {
public void testAppend_StringBuffer() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((StringBuffer) null);
- assertEquals("NULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULL");
sb = new StrBuilder();
sb.append(new StringBuffer("foo"));
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append(new StringBuffer(""));
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append(new StringBuffer("bar"));
- assertEquals("foobar", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobar");
}
//-----------------------------------------------------------------------
@@ -302,11 +302,11 @@ public class StrBuilderAppendInsertTest {
public void testAppend_StringBuffer_int_int() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((StringBuffer) null, 0, 1);
- assertEquals("NULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULL");
sb = new StrBuilder();
sb.append(new StringBuffer("foo"), 0, 3);
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
try {
sb.append(new StringBuffer("bar"), -1, 1);
@@ -351,10 +351,10 @@ public class StrBuilderAppendInsertTest {
}
sb.append(new StringBuffer("bar"), 3, 0);
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append(new StringBuffer("abcbardef"), 3, 3);
- assertEquals("foobar", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobar");
}
//-----------------------------------------------------------------------
@@ -362,17 +362,17 @@ public class StrBuilderAppendInsertTest {
public void testAppend_StrBuilder() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((StrBuilder) null);
- assertEquals("NULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULL");
sb = new StrBuilder();
sb.append(new StrBuilder("foo"));
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append(new StrBuilder(""));
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append(new StrBuilder("bar"));
- assertEquals("foobar", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobar");
}
//-----------------------------------------------------------------------
@@ -380,11 +380,11 @@ public class StrBuilderAppendInsertTest {
public void testAppend_StrBuilder_int_int() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((StrBuilder) null, 0, 1);
- assertEquals("NULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULL");
sb = new StrBuilder();
sb.append(new StrBuilder("foo"), 0, 3);
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
try {
sb.append(new StrBuilder("bar"), -1, 1);
@@ -429,10 +429,10 @@ public class StrBuilderAppendInsertTest {
}
sb.append(new StrBuilder("bar"), 3, 0);
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append(new StrBuilder("abcbardef"), 3, 3);
- assertEquals("foobar", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobar");
}
//-----------------------------------------------------------------------
@@ -440,14 +440,14 @@ public class StrBuilderAppendInsertTest {
public void testAppend_CharArray() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((char[]) null);
- assertEquals("NULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULL");
sb = new StrBuilder();
sb.append(new char[0]);
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.append(new char[]{'f', 'o', 'o'});
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
}
//-----------------------------------------------------------------------
@@ -455,11 +455,11 @@ public class StrBuilderAppendInsertTest {
public void testAppend_CharArray_int_int() {
StrBuilder sb = new StrBuilder();
sb.setNullText("NULL").append((char[]) null, 0, 1);
- assertEquals("NULL", sb.toString());
+ assertThat(sb.toString()).isEqualTo("NULL");
sb = new StrBuilder();
sb.append(new char[]{'f', 'o', 'o'}, 0, 3);
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
try {
sb.append(new char[]{'b', 'a', 'r'}, -1, 1);
@@ -504,10 +504,10 @@ public class StrBuilderAppendInsertTest {
}
sb.append(new char[]{'b', 'a', 'r'}, 3, 0);
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.append(new char[]{'a', 'b', 'c', 'b', 'a', 'r', 'd', 'e', 'f'}, 3, 3);
- assertEquals("foobar", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobar");
}
//-----------------------------------------------------------------------
@@ -515,13 +515,13 @@ public class StrBuilderAppendInsertTest {
public void testAppend_Boolean() {
final StrBuilder sb = new StrBuilder();
sb.append(true);
- assertEquals("true", sb.toString());
+ assertThat(sb.toString()).isEqualTo("true");
sb.append(false);
- assertEquals("truefalse", sb.toString());
+ assertThat(sb.toString()).isEqualTo("truefalse");
sb.append('!');
- assertEquals("truefalse!", sb.toString());
+ assertThat(sb.toString()).isEqualTo("truefalse!");
}
//-----------------------------------------------------------------------
@@ -529,16 +529,16 @@ public class StrBuilderAppendInsertTest {
public void testAppend_PrimitiveNumber() {
final StrBuilder sb = new StrBuilder();
sb.append(0);
- assertEquals("0", sb.toString());
+ assertThat(sb.toString()).isEqualTo("0");
sb.append(1L);
- assertEquals("01", sb.toString());
+ assertThat(sb.toString()).isEqualTo("01");
sb.append(2.3f);
- assertEquals("012.3", sb.toString());
+ assertThat(sb.toString()).isEqualTo("012.3");
sb.append(4.5d);
- assertEquals("012.34.5", sb.toString());
+ assertThat(sb.toString()).isEqualTo("012.34.5");
}
//-----------------------------------------------------------------------
@@ -560,9 +560,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln("Hello %s", "Alice");
- assertEquals("Hello Alice" + SEP, sb.toString());
- assertEquals(2, count[0]); // appendNewLine() calls append(String)
- assertEquals(1, count[1]);
+ assertThat(sb.toString()).isEqualTo("Hello Alice" + SEP);
+ assertThat(count[0]); // appendNewLine() calls append(String).isEqualTo(2)
+ assertThat(count[1]).isEqualTo(1);
}
//-----------------------------------------------------------------------
@@ -570,13 +570,13 @@ public class StrBuilderAppendInsertTest {
public void testAppendln_Object() {
final StrBuilder sb = new StrBuilder();
sb.appendln((Object) null);
- assertEquals("" + SEP, sb.toString());
+ assertThat(sb.toString()).isEqualTo("" + SEP);
sb.appendln(FOO);
- assertEquals(SEP + "foo" + SEP, sb.toString());
+ assertThat(sb.toString()).isEqualTo(SEP + "foo" + SEP);
sb.appendln(Integer.valueOf(6));
- assertEquals(SEP + "foo" + SEP + "6" + SEP, sb.toString());
+ assertThat(sb.toString()).isEqualTo(SEP + "foo" + SEP + "6" + SEP);
}
//-----------------------------------------------------------------------
@@ -598,9 +598,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln("foo");
- assertEquals("foo" + SEP, sb.toString());
- assertEquals(2, count[0]); // appendNewLine() calls append(String)
- assertEquals(1, count[1]);
+ assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertThat(count[0]); // appendNewLine() calls append(String).isEqualTo(2)
+ assertThat(count[1]).isEqualTo(1);
}
//-----------------------------------------------------------------------
@@ -622,9 +622,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln("foo", 0, 3);
- assertEquals("foo" + SEP, sb.toString());
- assertEquals(1, count[0]);
- assertEquals(1, count[1]);
+ assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertThat(count[0]).isEqualTo(1);
+ assertThat(count[1]).isEqualTo(1);
}
//-----------------------------------------------------------------------
@@ -646,9 +646,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln(new StringBuffer("foo"));
- assertEquals("foo" + SEP, sb.toString());
- assertEquals(1, count[0]);
- assertEquals(1, count[1]);
+ assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertThat(count[0]).isEqualTo(1);
+ assertThat(count[1]).isEqualTo(1);
}
//-----------------------------------------------------------------------
@@ -670,9 +670,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln(new StringBuilder("foo"));
- assertEquals("foo" + SEP, sb.toString());
- assertEquals(1, count[0]);
- assertEquals(1, count[1]);
+ assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertThat(count[0]).isEqualTo(1);
+ assertThat(count[1]).isEqualTo(1);
}
//-----------------------------------------------------------------------
@@ -694,9 +694,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln(new StringBuffer("foo"), 0, 3);
- assertEquals("foo" + SEP, sb.toString());
- assertEquals(1, count[0]);
- assertEquals(1, count[1]);
+ assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertThat(count[0]).isEqualTo(1);
+ assertThat(count[1]).isEqualTo(1);
}
//-----------------------------------------------------------------------
@@ -718,9 +718,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln(new StringBuilder("foo"), 0, 3);
- assertEquals("foo" + SEP, sb.toString());
- assertEquals(1, count[0]);
- assertEquals(1, count[1]);
+ assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertThat(count[0]).isEqualTo(1);
+ assertThat(count[1]).isEqualTo(1);
}
//-----------------------------------------------------------------------
@@ -742,9 +742,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln(new StrBuilder("foo"));
- assertEquals("foo" + SEP, sb.toString());
- assertEquals(1, count[0]);
- assertEquals(1, count[1]);
+ assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertThat(count[0]).isEqualTo(1);
+ assertThat(count[1]).isEqualTo(1);
}
//-----------------------------------------------------------------------
@@ -766,9 +766,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln(new StrBuilder("foo"), 0, 3);
- assertEquals("foo" + SEP, sb.toString());
- assertEquals(1, count[0]);
- assertEquals(1, count[1]);
+ assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertThat(count[0]).isEqualTo(1);
+ assertThat(count[1]).isEqualTo(1);
}
//-----------------------------------------------------------------------
@@ -790,9 +790,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln("foo".toCharArray());
- assertEquals("foo" + SEP, sb.toString());
- assertEquals(1, count[0]);
- assertEquals(1, count[1]);
+ assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertThat(count[0]).isEqualTo(1);
+ assertThat(count[1]).isEqualTo(1);
}
//-----------------------------------------------------------------------
@@ -814,9 +814,9 @@ public class StrBuilderAppendInsertTest {
}
};
sb.appendln("foo".toCharArray(), 0, 3);
- assertEquals("foo" + SEP, sb.toString());
- assertEquals(1, count[0]);
- assertEquals(1, count[1]);
+ assertThat(sb.toString()).isEqualTo("foo" + SEP);
+ assertThat(count[0]).isEqualTo(1);
+ assertThat(count[1]).isEqualTo(1);
}
//-----------------------------------------------------------------------
@@ -824,11 +824,11 @@ public class StrBuilderAppendInsertTest {
public void testAppendln_Boolean() {
final StrBuilder sb = new StrBuilder();
sb.appendln(true);
- assertEquals("true" + SEP, sb.toString());
+ assertThat(sb.toString()).isEqualTo("true" + SEP);
sb.clear();
sb.appendln(false);
- assertEquals("false" + SEP, sb.toString());
+ assertThat(sb.toString()).isEqualTo("false" + SEP);
}
//-----------------------------------------------------------------------
@@ -836,19 +836,19 @@ public class StrBuilderAppendInsertTest {
public void testAppendln_PrimitiveNumber() {
final StrBuilder sb = new StrBuilder();
sb.appendln(0);
- assertEquals("0" + SEP, sb.toString());
+ assertThat(sb.toString()).isEqualTo("0" + SEP);
sb.clear();
sb.appendln(1L);
- assertEquals("1" + SEP, sb.toString());
+ assertThat(sb.toString()).isEqualTo("1" + SEP);
sb.clear();
sb.appendln(2.3f);
- assertEquals("2.3" + SEP, sb.toString());
+ assertThat(sb.toString()).isEqualTo("2.3" + SEP);
sb.clear();
sb.appendln(4.5d);
- assertEquals("4.5" + SEP, sb.toString());
+ assertThat(sb.toString()).isEqualTo("4.5" + SEP);
}
//-----------------------------------------------------------------------
@@ -856,21 +856,21 @@ public class StrBuilderAppendInsertTest {
public void testAppendPadding() {
final StrBuilder sb = new StrBuilder();
sb.append("foo");
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.appendPadding(-1, '-');
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.appendPadding(0, '-');
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.appendPadding(1, '-');
- assertEquals("foo-", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo-");
sb.appendPadding(16, '-');
- assertEquals(20, sb.length());
+ assertThat(sb.length()).isEqualTo(20);
// 12345678901234567890
- assertEquals("foo-----------------", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo-----------------");
}
//-----------------------------------------------------------------------
@@ -878,38 +878,38 @@ public class StrBuilderAppendInsertTest {
public void testAppendFixedWidthPadLeft() {
final StrBuilder sb = new StrBuilder();
sb.appendFixedWidthPadLeft("foo", -1, '-');
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendFixedWidthPadLeft("foo", 0, '-');
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendFixedWidthPadLeft("foo", 1, '-');
- assertEquals("o", sb.toString());
+ assertThat(sb.toString()).isEqualTo("o");
sb.clear();
sb.appendFixedWidthPadLeft("foo", 2, '-');
- assertEquals("oo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("oo");
sb.clear();
sb.appendFixedWidthPadLeft("foo", 3, '-');
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.clear();
sb.appendFixedWidthPadLeft("foo", 4, '-');
- assertEquals("-foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("-foo");
sb.clear();
sb.appendFixedWidthPadLeft("foo", 10, '-');
- assertEquals(10, sb.length());
+ assertThat(sb.length()).isEqualTo(10);
// 1234567890
- assertEquals("-------foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("-------foo");
sb.clear();
sb.setNullText("null");
sb.appendFixedWidthPadLeft(null, 5, '-');
- assertEquals("-null", sb.toString());
+ assertThat(sb.toString()).isEqualTo("-null");
}
//-----------------------------------------------------------------------
@@ -917,33 +917,33 @@ public class StrBuilderAppendInsertTest {
public void testAppendFixedWidthPadLeft_int() {
final StrBuilder sb = new StrBuilder();
sb.appendFixedWidthPadLeft(123, -1, '-');
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendFixedWidthPadLeft(123, 0, '-');
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendFixedWidthPadLeft(123, 1, '-');
- assertEquals("3", sb.toString());
+ assertThat(sb.toString()).isEqualTo("3");
sb.clear();
sb.appendFixedWidthPadLeft(123, 2, '-');
- assertEquals("23", sb.toString());
+ assertThat(sb.toString()).isEqualTo("23");
sb.clear();
sb.appendFixedWidthPadLeft(123, 3, '-');
- assertEquals("123", sb.toString());
+ assertThat(sb.toString()).isEqualTo("123");
sb.clear();
sb.appendFixedWidthPadLeft(123, 4, '-');
- assertEquals("-123", sb.toString());
+ assertThat(sb.toString()).isEqualTo("-123");
sb.clear();
sb.appendFixedWidthPadLeft(123, 10, '-');
- assertEquals(10, sb.length());
+ assertThat(sb.length()).isEqualTo(10);
// 1234567890
- assertEquals("-------123", sb.toString());
+ assertThat(sb.toString()).isEqualTo("-------123");
}
//-----------------------------------------------------------------------
@@ -951,38 +951,38 @@ public class StrBuilderAppendInsertTest {
public void testAppendFixedWidthPadRight() {
final StrBuilder sb = new StrBuilder();
sb.appendFixedWidthPadRight("foo", -1, '-');
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendFixedWidthPadRight("foo", 0, '-');
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendFixedWidthPadRight("foo", 1, '-');
- assertEquals("f", sb.toString());
+ assertThat(sb.toString()).isEqualTo("f");
sb.clear();
sb.appendFixedWidthPadRight("foo", 2, '-');
- assertEquals("fo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("fo");
sb.clear();
sb.appendFixedWidthPadRight("foo", 3, '-');
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.clear();
sb.appendFixedWidthPadRight("foo", 4, '-');
- assertEquals("foo-", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo-");
sb.clear();
sb.appendFixedWidthPadRight("foo", 10, '-');
- assertEquals(10, sb.length());
+ assertThat(sb.length()).isEqualTo(10);
// 1234567890
- assertEquals("foo-------", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo-------");
sb.clear();
sb.setNullText("null");
sb.appendFixedWidthPadRight(null, 5, '-');
- assertEquals("null-", sb.toString());
+ assertThat(sb.toString()).isEqualTo("null-");
}
// See: http://issues.apache.org/jira/browse/LANG-299
@@ -990,7 +990,7 @@ public class StrBuilderAppendInsertTest {
public void testLang299() {
final StrBuilder sb = new StrBuilder(1);
sb.appendFixedWidthPadRight("foo", 1, '-');
- assertEquals("f", sb.toString());
+ assertThat(sb.toString()).isEqualTo("f");
}
//-----------------------------------------------------------------------
@@ -998,33 +998,33 @@ public class StrBuilderAppendInsertTest {
public void testAppendFixedWidthPadRight_int() {
final StrBuilder sb = new StrBuilder();
sb.appendFixedWidthPadRight(123, -1, '-');
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendFixedWidthPadRight(123, 0, '-');
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendFixedWidthPadRight(123, 1, '-');
- assertEquals("1", sb.toString());
+ assertThat(sb.toString()).isEqualTo("1");
sb.clear();
sb.appendFixedWidthPadRight(123, 2, '-');
- assertEquals("12", sb.toString());
+ assertThat(sb.toString()).isEqualTo("12");
sb.clear();
sb.appendFixedWidthPadRight(123, 3, '-');
- assertEquals("123", sb.toString());
+ assertThat(sb.toString()).isEqualTo("123");
sb.clear();
sb.appendFixedWidthPadRight(123, 4, '-');
- assertEquals("123-", sb.toString());
+ assertThat(sb.toString()).isEqualTo("123-");
sb.clear();
sb.appendFixedWidthPadRight(123, 10, '-');
- assertEquals(10, sb.length());
+ assertThat(sb.length()).isEqualTo(10);
// 1234567890
- assertEquals("123-------", sb.toString());
+ assertThat(sb.toString()).isEqualTo("123-------");
}
//-----------------------------------------------------------------------
@@ -1034,22 +1034,22 @@ public class StrBuilderAppendInsertTest {
sb = new StrBuilder();
sb.append("Hi", (Object[]) null);
- assertEquals("Hi", sb.toString());
+ assertThat(sb.toString()).isEqualTo("Hi");
sb = new StrBuilder();
sb.append("Hi", "Alice");
- assertEquals("Hi", sb.toString());
+ assertThat(sb.toString()).isEqualTo("Hi");
sb = new StrBuilder();
sb.append("Hi %s", "Alice");
- assertEquals("Hi Alice", sb.toString());
+ assertThat(sb.toString()).isEqualTo("Hi Alice");
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";
- assertEquals(expected, sb.toString());
+ assertThat(sb.toString()).isEqualTo(expected);
}
//-----------------------------------------------------------------------
@@ -1057,19 +1057,19 @@ public class StrBuilderAppendInsertTest {
public void testAppendAll_Array() {
final StrBuilder sb = new StrBuilder();
sb.appendAll((Object[]) null);
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendAll(new Object[0]);
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendAll(new Object[]{"foo", "bar", "baz"});
- assertEquals("foobarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobarbaz");
sb.clear();
sb.appendAll("foo", "bar", "baz");
- assertEquals("foobarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobarbaz");
}
//-----------------------------------------------------------------------
@@ -1077,15 +1077,15 @@ public class StrBuilderAppendInsertTest {
public void testAppendAll_Collection() {
final StrBuilder sb = new StrBuilder();
sb.appendAll((Collection<?>) null);
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendAll(Collections.EMPTY_LIST);
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendAll(Arrays.asList(new Object[]{"foo", "bar", "baz"}));
- assertEquals("foobarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobarbaz");
}
//-----------------------------------------------------------------------
@@ -1093,15 +1093,15 @@ public class StrBuilderAppendInsertTest {
public void testAppendAll_Iterator() {
final StrBuilder sb = new StrBuilder();
sb.appendAll((Iterator<?>) null);
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendAll(Collections.EMPTY_LIST.iterator());
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendAll(Arrays.asList(new Object[]{"foo", "bar", "baz"}).iterator());
- assertEquals("foobarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobarbaz");
}
//-----------------------------------------------------------------------
@@ -1109,23 +1109,23 @@ public class StrBuilderAppendInsertTest {
public void testAppendWithSeparators_Array() {
final StrBuilder sb = new StrBuilder();
sb.appendWithSeparators((Object[]) null, ",");
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendWithSeparators(new Object[0], ",");
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendWithSeparators(new Object[]{"foo", "bar", "baz"}, ",");
- assertEquals("foo,bar,baz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo,bar,baz");
sb.clear();
sb.appendWithSeparators(new Object[]{"foo", "bar", "baz"}, null);
- assertEquals("foobarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobarbaz");
sb.clear();
sb.appendWithSeparators(new Object[]{"foo", null, "baz"}, ",");
- assertEquals("foo,,baz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo,,baz");
}
//-----------------------------------------------------------------------
@@ -1133,23 +1133,23 @@ public class StrBuilderAppendInsertTest {
public void testAppendWithSeparators_Collection() {
final StrBuilder sb = new StrBuilder();
sb.appendWithSeparators((Collection<?>) null, ",");
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendWithSeparators(Collections.EMPTY_LIST, ",");
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendWithSeparators(Arrays.asList(new Object[]{"foo", "bar", "baz"}), ",");
- assertEquals("foo,bar,baz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo,bar,baz");
sb.clear();
sb.appendWithSeparators(Arrays.asList(new Object[]{"foo", "bar", "baz"}), null);
- assertEquals("foobarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobarbaz");
sb.clear();
sb.appendWithSeparators(Arrays.asList(new Object[]{"foo", null, "baz"}), ",");
- assertEquals("foo,,baz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo,,baz");
}
//-----------------------------------------------------------------------
@@ -1157,23 +1157,23 @@ public class StrBuilderAppendInsertTest {
public void testAppendWithSeparators_Iterator() {
final StrBuilder sb = new StrBuilder();
sb.appendWithSeparators((Iterator<?>) null, ",");
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendWithSeparators(Collections.EMPTY_LIST.iterator(), ",");
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.clear();
sb.appendWithSeparators(Arrays.asList(new Object[]{"foo", "bar", "baz"}).iterator(), ",");
- assertEquals("foo,bar,baz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo,bar,baz");
sb.clear();
sb.appendWithSeparators(Arrays.asList(new Object[]{"foo", "bar", "baz"}).iterator(), null);
- assertEquals("foobarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobarbaz");
sb.clear();
sb.appendWithSeparators(Arrays.asList(new Object[]{"foo", null, "baz"}).iterator(), ",");
- assertEquals("foo,,baz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo,,baz");
}
//-----------------------------------------------------------------------
@@ -1182,11 +1182,11 @@ public class StrBuilderAppendInsertTest {
final StrBuilder sb = new StrBuilder();
sb.setNullText("null");
sb.appendWithSeparators(new Object[]{"foo", null, "baz"}, ",");
- assertEquals("foo,null,baz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo,null,baz");
sb.clear();
sb.appendWithSeparators(Arrays.asList(new Object[]{"foo", null, "baz"}), ",");
- assertEquals("foo,null,baz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo,null,baz");
}
//-----------------------------------------------------------------------
@@ -1194,11 +1194,11 @@ public class StrBuilderAppendInsertTest {
public void testAppendSeparator_String() {
final StrBuilder sb = new StrBuilder();
sb.appendSeparator(","); // no effect
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.append("foo");
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.appendSeparator(",");
- assertEquals("foo,", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo,");
}
//-----------------------------------------------------------------------
@@ -1209,19 +1209,19 @@ public class StrBuilderAppendInsertTest {
final String standardSeparator = ",";
final String foo = "foo";
sb.appendSeparator(null, null);
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.appendSeparator(standardSeparator, null);
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.appendSeparator(standardSeparator, startSeparator);
- assertEquals(startSeparator, sb.toString());
+ assertThat(sb.toString()).isEqualTo(startSeparator);
sb.appendSeparator(null, null);
- assertEquals(startSeparator, sb.toString());
+ assertThat(sb.toString()).isEqualTo(startSeparator);
sb.appendSeparator(null, startSeparator);
- assertEquals(startSeparator, sb.toString());
+ assertThat(sb.toString()).isEqualTo(startSeparator);
sb.append(foo);
- assertEquals(startSeparator + foo, sb.toString());
+ assertThat(sb.toString()).isEqualTo(startSeparator + foo);
sb.appendSeparator(standardSeparator, startSeparator);
- assertEquals(startSeparator + foo + standardSeparator, sb.toString());
+ assertThat(sb.toString()).isEqualTo(startSeparator + foo + standardSeparator);
}
//-----------------------------------------------------------------------
@@ -1229,11 +1229,11 @@ public class StrBuilderAppendInsertTest {
public void testAppendSeparator_char() {
final StrBuilder sb = new StrBuilder();
sb.appendSeparator(','); // no effect
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.append("foo");
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.appendSeparator(',');
- assertEquals("foo,", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo,");
}
@Test
public void testAppendSeparator_char_char() {
@@ -1242,11 +1242,11 @@ public class StrBuilderAppendInsertTest {
final char standardSeparator = ',';
final String foo = "foo";
sb.appendSeparator(standardSeparator, startSeparator); // no effect
- assertEquals(String.valueOf(startSeparator), sb.toString());
+ assertThat(sb.toString()).isEqualTo(String.valueOf(startSeparator));
sb.append(foo);
- assertEquals(String.valueOf(startSeparator) + foo, sb.toString());
+ assertThat(sb.toString()).isEqualTo(String.valueOf(startSeparator) + foo);
sb.appendSeparator(standardSeparator, startSeparator);
- assertEquals(String.valueOf(startSeparator) + foo + standardSeparator, sb.toString());
+ assertThat(sb.toString()).isEqualTo(String.valueOf(startSeparator) + foo + standardSeparator);
}
//-----------------------------------------------------------------------
@@ -1254,14 +1254,14 @@ public class StrBuilderAppendInsertTest {
public void testAppendSeparator_String_int() {
final StrBuilder sb = new StrBuilder();
sb.appendSeparator(",", 0); // no effect
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.append("foo");
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.appendSeparator(",", 1);
- assertEquals("foo,", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo,");
sb.appendSeparator(",", -1); // no effect
- assertEquals("foo,", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo,");
}
//-----------------------------------------------------------------------
@@ -1269,14 +1269,14 @@ public class StrBuilderAppendInsertTest {
public void testAppendSeparator_char_int() {
final StrBuilder sb = new StrBuilder();
sb.appendSeparator(',', 0); // no effect
- assertEquals("", sb.toString());
+ assertThat(sb.toString()).isEqualTo("");
sb.append("foo");
- assertEquals("foo", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo");
sb.appendSeparator(',', 1);
- assertEquals("foo,", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo,");
sb.appendSeparator(',', -1); // no effect
- assertEquals("foo,", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foo,");
}
//-----------------------------------------------------------------------
@@ -1285,7 +1285,7 @@ public class StrBuilderAppendInsertTest {
final StrBuilder sb = new StrBuilder();
sb.append("barbaz");
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
try {
sb.insert(-1, FOO);
@@ -1302,14 +1302,14 @@ public class StrBuilderAppendInsertTest {
}
sb.insert(0, (Object) null);
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
sb.insert(0, FOO);
- assertEquals("foobarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobarbaz");
sb.clear();
sb.append("barbaz");
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
try {
sb.insert(-1, "foo");
@@ -1326,14 +1326,14 @@ public class StrBuilderAppendInsertTest {
}
sb.insert(0, (String) null);
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
sb.insert(0, "foo");
- assertEquals("foobarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobarbaz");
sb.clear();
sb.append("barbaz");
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
try {
sb.insert(-1, new char[]{'f', 'o', 'o'});
@@ -1350,17 +1350,17 @@ public class StrBuilderAppendInsertTest {
}
sb.insert(0, (char[]) null);
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
sb.insert(0, new char[0]);
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
sb.insert(0, new char[]{'f', 'o', 'o'});
- assertEquals("foobarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobarbaz");
sb.clear();
sb.append("barbaz");
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
try {
sb.insert(-1, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 3, 3);
@@ -1377,10 +1377,10 @@ public class StrBuilderAppendInsertTest {
}
sb.insert(0, (char[]) null, 0, 0);
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
sb.insert(0, new char[0], 0, 0);
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
try {
sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, -1, 3);
@@ -1411,14 +1411,14 @@ public class StrBuilderAppendInsertTest {
}
sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 0, 0);
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 3, 3);
- assertEquals("foobarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foobarbaz");
sb.clear();
sb.append("barbaz");
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
try {
sb.insert(-1, true);
@@ -1435,14 +1435,14 @@ public class StrBuilderAppendInsertTest {
}
sb.insert(0, true);
- assertEquals("truebarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("truebarbaz");
sb.insert(0, false);
- assertEquals("falsetruebarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("falsetruebarbaz");
sb.clear();
sb.append("barbaz");
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
try {
sb.insert(-1, '!');
@@ -1459,11 +1459,11 @@ public class StrBuilderAppendInsertTest {
}
sb.insert(0, '!');
- assertEquals("!barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("!barbaz");
sb.clear();
sb.append("barbaz");
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
try {
sb.insert(-1, 0);
@@ -1480,11 +1480,11 @@ public class StrBuilderAppendInsertTest {
}
sb.insert(0, '0');
- assertEquals("0barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("0barbaz");
sb.clear();
sb.append("barbaz");
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
try {
sb.insert(-1, 1L);
@@ -1501,11 +1501,11 @@ public class StrBuilderAppendInsertTest {
}
sb.insert(0, 1L);
- assertEquals("1barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("1barbaz");
sb.clear();
sb.append("barbaz");
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
try {
sb.insert(-1, 2.3F);
@@ -1522,11 +1522,11 @@ public class StrBuilderAppendInsertTest {
}
sb.insert(0, 2.3F);
- assertEquals("2.3barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("2.3barbaz");
sb.clear();
sb.append("barbaz");
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
try {
sb.insert(-1, 4.5D);
@@ -1543,7 +1543,7 @@ public class StrBuilderAppendInsertTest {
}
sb.insert(0, 4.5D);
- assertEquals("4.5barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("4.5barbaz");
}
//-----------------------------------------------------------------------
@@ -1552,7 +1552,7 @@ public class StrBuilderAppendInsertTest {
final StrBuilder sb = new StrBuilder();
sb.setNullText("null");
sb.append("barbaz");
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
try {
sb.insert(-1, FOO);
@@ -1569,14 +1569,14 @@ public class StrBuilderAppendInsertTest {
}
sb.insert(0, (Object) null);
- assertEquals("nullbarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("nullbarbaz");
sb.insert(0, FOO);
- assertEquals("foonullbarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foonullbarbaz");
sb.clear();
sb.append("barbaz");
- assertEquals("barbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("barbaz");
try {
sb.insert(-1, "foo");
@@ -1593,15 +1593,15 @@ public class StrBuilderAppendInsertTest {
}
sb.insert(0, (String) null);
- assertEquals("nullbarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("nullbarbaz");
sb.insert(0, "foo");
- assertEquals("foonullbarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("foonullbarbaz");
sb.insert(0, (char[]) null);
- assertEquals("nullfoonullbarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("nullfoonullbarbaz");
sb.insert(0, (char[]) null, 0, 0);
- assertEquals("nullnullfoonullbarbaz", sb.toString());
+ assertThat(sb.toString()).isEqualTo("nullnullfoonullbarbaz");
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/StrMatcherTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/text/StrMatcherTest.java b/src/test/java/org/apache/commons/text/StrMatcherTest.java
index a233794..cac9670 100644
--- a/src/test/java/org/apache/commons/text/StrMatcherTest.java
+++ b/src/test/java/org/apache/commons/text/StrMatcherTest.java
@@ -16,9 +16,7 @@
*/
package org.apache.commons.text;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Test;
@@ -36,167 +34,167 @@ public class StrMatcherTest {
@Test
public void testCommaMatcher() {
final StrMatcher matcher = StrMatcher.commaMatcher();
- assertSame(matcher, StrMatcher.commaMatcher());
- assertEquals(0, matcher.isMatch(BUFFER1, 0));
- assertEquals(1, matcher.isMatch(BUFFER1, 1));
- assertEquals(0, matcher.isMatch(BUFFER1, 2));
+ 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);
}
//-----------------------------------------------------------------------
@Test
public void testTabMatcher() {
final StrMatcher matcher = StrMatcher.tabMatcher();
- assertSame(matcher, StrMatcher.tabMatcher());
- assertEquals(0, matcher.isMatch(BUFFER1, 2));
- assertEquals(1, matcher.isMatch(BUFFER1, 3));
- assertEquals(0, matcher.isMatch(BUFFER1, 4));
+ 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);
}
//-----------------------------------------------------------------------
@Test
public void testSpaceMatcher() {
final StrMatcher matcher = StrMatcher.spaceMatcher();
- assertSame(matcher, StrMatcher.spaceMatcher());
- assertEquals(0, matcher.isMatch(BUFFER1, 4));
- assertEquals(1, matcher.isMatch(BUFFER1, 5));
- assertEquals(0, matcher.isMatch(BUFFER1, 6));
+ 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);
}
//-----------------------------------------------------------------------
@Test
public void testSplitMatcher() {
final StrMatcher matcher = StrMatcher.splitMatcher();
- assertSame(matcher, StrMatcher.splitMatcher());
- 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));
+ 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);
}
//-----------------------------------------------------------------------
@Test
public void testTrimMatcher() {
final StrMatcher matcher = StrMatcher.trimMatcher();
- assertSame(matcher, StrMatcher.trimMatcher());
- 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));
+ 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);
}
//-----------------------------------------------------------------------
@Test
public void testSingleQuoteMatcher() {
final StrMatcher matcher = StrMatcher.singleQuoteMatcher();
- assertSame(matcher, StrMatcher.singleQuoteMatcher());
- assertEquals(0, matcher.isMatch(BUFFER1, 10));
- assertEquals(1, matcher.isMatch(BUFFER1, 11));
- assertEquals(0, matcher.isMatch(BUFFER1, 12));
+ 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);
}
//-----------------------------------------------------------------------
@Test
public void testDoubleQuoteMatcher() {
final StrMatcher matcher = StrMatcher.doubleQuoteMatcher();
- assertSame(matcher, StrMatcher.doubleQuoteMatcher());
- assertEquals(0, matcher.isMatch(BUFFER1, 11));
- assertEquals(1, matcher.isMatch(BUFFER1, 12));
+ assertThat(StrMatcher.doubleQuoteMatcher()).isSameAs(matcher);
+ assertThat(matcher.isMatch(BUFFER1, 11)).isEqualTo(0);
+ assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(1);
}
//-----------------------------------------------------------------------
@Test
public void testQuoteMatcher() {
final StrMatcher matcher = StrMatcher.quoteMatcher();
- assertSame(matcher, StrMatcher.quoteMatcher());
- assertEquals(0, matcher.isMatch(BUFFER1, 10));
- assertEquals(1, matcher.isMatch(BUFFER1, 11));
- assertEquals(1, matcher.isMatch(BUFFER1, 12));
+ 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);
}
//-----------------------------------------------------------------------
@Test
public void testNoneMatcher() {
final StrMatcher matcher = StrMatcher.noneMatcher();
- assertSame(matcher, StrMatcher.noneMatcher());
- 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));
+ 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);
}
//-----------------------------------------------------------------------
@Test
public void testCharMatcher_char() {
final StrMatcher matcher = StrMatcher.charMatcher('c');
- 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));
+ 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);
}
//-----------------------------------------------------------------------
@Test
public void testCharSetMatcher_String() {
final StrMatcher matcher = StrMatcher.charSetMatcher("ace");
- 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.noneMatcher(), StrMatcher.charSetMatcher(""));
- assertSame(StrMatcher.noneMatcher(), StrMatcher.charSetMatcher((String) null));
- assertTrue(StrMatcher.charSetMatcher("a") instanceof StrMatcher.CharMatcher);
+ 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());
+ assertThat(StrMatcher.charSetMatcher("a") instanceof StrMatcher.CharMatcher).isTrue();
}
//-----------------------------------------------------------------------
@Test
public void testCharSetMatcher_charArray() {
final StrMatcher matcher = StrMatcher.charSetMatcher("ace".toCharArray());
- 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.noneMatcher(), StrMatcher.charSetMatcher(new char[0]));
- assertSame(StrMatcher.noneMatcher(), StrMatcher.charSetMatcher((char[]) null));
- assertTrue(StrMatcher.charSetMatcher("a".toCharArray()) instanceof StrMatcher.CharMatcher);
+ 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(new char[0])).isSameAs(StrMatcher.noneMatcher());
+ assertThat(StrMatcher.charSetMatcher((char[]) null)).isSameAs(StrMatcher.noneMatcher());
+ assertThat(StrMatcher.charSetMatcher("a".toCharArray()) instanceof StrMatcher.CharMatcher).isTrue();
}
//-----------------------------------------------------------------------
@Test
public void testStringMatcher_String() {
final StrMatcher matcher = StrMatcher.stringMatcher("bc");
- 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.noneMatcher(), StrMatcher.stringMatcher(""));
- assertSame(StrMatcher.noneMatcher(), StrMatcher.stringMatcher((String) null));
+ 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());
}
//-----------------------------------------------------------------------
@@ -206,9 +204,9 @@ 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");
- 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));
+ 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);
}
}
[5/5] [text] Partial and mostly automated migration of assertions
from JUnit to AssertJ. (closes #70)
Posted by pa...@apache.org.
Partial and mostly automated migration of assertions from JUnit to AssertJ. (closes #70)
Project: http://git-wip-us.apache.org/repos/asf/commons-text/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-text/commit/e55d0ac1
Tree: http://git-wip-us.apache.org/repos/asf/commons-text/tree/e55d0ac1
Diff: http://git-wip-us.apache.org/repos/asf/commons-text/diff/e55d0ac1
Branch: refs/heads/master
Commit: e55d0ac1c17a7fd71dbb4f65034c7b739be6a35a
Parents: 6665a02
Author: Pascal Schumacher <pa...@gmx.net>
Authored: Sun Oct 15 12:11:39 2017 +0200
Committer: Pascal Schumacher <pa...@gmx.net>
Committed: Fri Oct 27 16:25:04 2017 +0200
----------------------------------------------------------------------
pom.xml | 6 +
.../commons/text/AlphabetConverterTest.java | 56 +-
.../org/apache/commons/text/CaseUtilsTest.java | 70 ++-
.../commons/text/CharacterPredicatesTest.java | 115 ++--
.../commons/text/FormattableUtilsTest.java | 157 +++---
.../commons/text/RandomStringGeneratorTest.java | 32 +-
.../text/StrBuilderAppendInsertTest.java | 486 ++++++++---------
.../org/apache/commons/text/StrMatcherTest.java | 188 ++++---
.../org/apache/commons/text/WordUtilsTest.java | 534 +++++++++----------
.../text/diff/ReplacementsFinderTest.java | 4 +-
.../text/diff/StringsComparatorTest.java | 8 +-
.../text/similarity/CosineDistanceTest.java | 13 +-
.../text/similarity/CosineSimilarityTest.java | 7 +-
.../commons/text/similarity/FuzzyScoreTest.java | 20 +-
.../text/similarity/HammingDistanceTest.java | 18 +-
.../LevenshteinDetailedDistanceTest.java | 428 +++++++--------
.../similarity/LevenshteinDistanceTest.java | 109 ++--
.../text/similarity/LevenshteinResultsTest.java | 13 +-
.../LongestCommonSubsequenceDistanceTest.java | 29 +-
.../LongestCommonSubsequenceTest.java | 89 ++--
.../similarity/SimilarityScoreFromTest.java | 4 +-
.../text/translate/AggregateTranslatorTest.java | 14 +-
.../text/translate/CodePointTranslatorTest.java | 4 +-
.../text/translate/CsvTranslatorsTest.java | 22 +-
.../text/translate/EntityArraysTest.java | 26 +-
.../text/translate/JavaUnicodeEscaperTest.java | 13 +-
.../text/translate/LookupTranslatorTest.java | 10 +-
.../translate/NumericEntityEscaperTest.java | 10 +-
.../translate/NumericEntityUnescaperTest.java | 22 +-
.../text/translate/OctalUnescaperTest.java | 27 +-
.../translate/SinglePassTranslatorTest.java | 8 +-
.../text/translate/UnicodeEscaperTest.java | 11 +-
.../text/translate/UnicodeUnescaperTest.java | 8 +-
.../UnicodeUnpairedSurrogateRemoverTest.java | 16 +-
34 files changed, 1289 insertions(+), 1288 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index dcee00d..112b5c8 100644
--- a/pom.xml
+++ b/pom.xml
@@ -77,6 +77,12 @@
<version>1.3</version>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.assertj</groupId>
+ <artifactId>assertj-core</artifactId>
+ <version>2.8.0</version>
+ <scope>test</scope>
+ </dependency>
</dependencies>
<build>
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/AlphabetConverterTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/text/AlphabetConverterTest.java b/src/test/java/org/apache/commons/text/AlphabetConverterTest.java
index 0178a4a..7a59c6e 100644
--- a/src/test/java/org/apache/commons/text/AlphabetConverterTest.java
+++ b/src/test/java/org/apache/commons/text/AlphabetConverterTest.java
@@ -26,10 +26,7 @@ import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link AlphabetConverter}.
@@ -110,11 +107,11 @@ public class AlphabetConverterTest {
public void javadocExampleTest() throws UnsupportedEncodingException {
final AlphabetConverter ac = createJavadocExample();
- 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"));
+ 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");
}
@Test
@@ -147,14 +144,14 @@ public class AlphabetConverterTest {
final AlphabetConverter ac = AlphabetConverter.createConverter(unicode, lowerCaseEnglishCodepoints,
doNotEncodeCodepoints);
- assertEquals(2, ac.getEncodedCharLength());
+ assertThat(ac.getEncodedCharLength()).isEqualTo(2);
final String original = "\u8a43\u8a45 \u8dce ab \u8dc3 c \u8983";
final String encoded = ac.encode(original);
final String decoded = ac.decode(encoded);
- assertEquals("Encoded '" + original + "' into '" + encoded + "', but decoded into '" + decoded + "'", original,
- decoded);
+ assertThat(decoded).as("Encoded '" + original + "' into '" + encoded + "', but decoded into '" + decoded + "'")
+ .isEqualTo(original);
}
@Test
@@ -203,11 +200,11 @@ public class AlphabetConverterTest {
final AlphabetConverter reconstructedAlphabetConverter = AlphabetConverter
.createConverterFromMap(ac.getOriginalToEncoded());
- 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
+ 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
// test all the trial strings
for (final String s : strings) {
@@ -216,7 +213,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++) {
- assertTrue(originalEncodingChars.contains(encoded.charAt(i)));
+ assertThat(originalEncodingChars.contains(encoded.charAt(i))).isTrue();
}
final String decoded = ac.decode(encoded);
@@ -224,10 +221,11 @@ 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++) {
- assertTrue(originalCharsList.contains(decoded.charAt(i)));
+ assertThat(originalCharsList.contains(decoded.charAt(i))).isTrue();
}
- assertEquals("Encoded '" + s + "' into '" + encoded + "', but decoded into '" + decoded + "'", s, decoded);
+ assertThat(decoded).as("Encoded '" + s + "' into '" + encoded + "', but decoded into '" + decoded + "'")
+ .isEqualTo(s);
}
}
@@ -248,7 +246,7 @@ public class AlphabetConverterTest {
final AlphabetConverter alphabetConverter = AlphabetConverter.createConverterFromChars(characterArray,
characterArray, characterArray);
- assertEquals(1, alphabetConverter.getEncodedCharLength());
+ assertThat(alphabetConverter.getEncodedCharLength()).isEqualTo(1);
}
@Test
@@ -258,8 +256,8 @@ public class AlphabetConverterTest {
hashMap.put(0, "CtDs");
final AlphabetConverter alphabetConverterTwo = AlphabetConverter.createConverterFromMap(hashMap);
- assertFalse(alphabetConverter.equals(alphabetConverterTwo));
- assertEquals(1, alphabetConverter.getEncodedCharLength());
+ assertThat(alphabetConverter.equals(alphabetConverterTwo)).isFalse();
+ assertThat(alphabetConverter.getEncodedCharLength()).isEqualTo(1);
}
@Test
@@ -273,8 +271,8 @@ public class AlphabetConverterTest {
final Map<Integer, String> map = new HashMap<>();
final AlphabetConverter alphabetConverterTwo = AlphabetConverter.createConverterFromMap(map);
- assertEquals(1, alphabetConverterTwo.getEncodedCharLength());
- assertFalse(alphabetConverter.equals(alphabetConverterTwo));
+ assertThat(alphabetConverterTwo.getEncodedCharLength()).isEqualTo(1);
+ assertThat(alphabetConverter.equals(alphabetConverterTwo)).isFalse();
}
@Test
@@ -286,7 +284,7 @@ public class AlphabetConverterTest {
final AlphabetConverter alphabetConverter = AlphabetConverter.createConverterFromChars(characterArray,
characterArray, characterArray);
- assertTrue(alphabetConverter.equals(alphabetConverter));
+ assertThat(alphabetConverter.equals(alphabetConverter)).isTrue();
}
@Test
@@ -295,7 +293,7 @@ public class AlphabetConverterTest {
final AlphabetConverter alphabetConverter = AlphabetConverter.createConverterFromChars(characterArray, null,
null);
- assertFalse(alphabetConverter.equals(null));
+ assertThat(alphabetConverter.equals(null)).isFalse();
}
@Test
@@ -308,7 +306,7 @@ public class AlphabetConverterTest {
final AlphabetConverter alphabetConverter = AlphabetConverter.createConverterFromChars(characterArray,
characterArray, characterArray);
- assertFalse(alphabetConverter.equals(charOne));
+ assertThat(alphabetConverter.equals(charOne)).isFalse();
}
@Test
@@ -317,7 +315,7 @@ public class AlphabetConverterTest {
final AlphabetConverter alphabetConverter = AlphabetConverter.createConverterFromMap(map);
alphabetConverter.decode(null);
- assertEquals(1, alphabetConverter.getEncodedCharLength());
+ assertThat(alphabetConverter.getEncodedCharLength()).isEqualTo(1);
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/CaseUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/text/CaseUtilsTest.java b/src/test/java/org/apache/commons/text/CaseUtilsTest.java
index 3211b18..5b085ce 100644
--- a/src/test/java/org/apache/commons/text/CaseUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/CaseUtilsTest.java
@@ -21,11 +21,7 @@ import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link CaseUtils} class.
@@ -35,49 +31,49 @@ public class CaseUtilsTest {
//-----------------------------------------------------------------------
@Test
public void testConstructor() {
- assertNotNull(new CaseUtils());
+ assertThat(new CaseUtils()).isNotNull();
final Constructor<?>[] cons = CaseUtils.class.getDeclaredConstructors();
- assertEquals(1, cons.length);
- assertTrue(Modifier.isPublic(cons[0].getModifiers()));
- assertTrue(Modifier.isPublic(CaseUtils.class.getModifiers()));
- assertFalse(Modifier.isFinal(CaseUtils.class.getModifiers()));
+ 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();
}
//------------------------------------------------------------------------
@Test
public void testToCamelCase() throws Exception {
- 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, new char[]{}));
- assertEquals("ABC@def", CaseUtils.toCamelCase("a b c @def", true, new char[]{'-'}));
- assertEquals("ABC@def", CaseUtils.toCamelCase("a b c @def", true, new char[]{'-'}));
+ 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, new char[]{})).isEqualTo("ABC@def");
+ assertThat(CaseUtils.toCamelCase("a b c @def", true, new char[]{'-'})).isEqualTo("ABC@def");
+ assertThat(CaseUtils.toCamelCase("a b c @def", true, new char[]{'-'})).isEqualTo("ABC@def");
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("-+@ ", 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");
- assertEquals("toCamelCase", CaseUtils.toCamelCase("To.Camel.Case", false, new char[]{'.'}));
- assertEquals("toCamelCase", CaseUtils.toCamelCase("To.Camel-Case", false, new char[]{'-', '.'}));
- assertEquals("toCamelCase", CaseUtils.toCamelCase(" to @ Camel case", false, new char[]{'-', '@'}));
- assertEquals("ToCamelCase", CaseUtils.toCamelCase(" @to @ Camel case", true, new char[]{'-', '@'}));
+ assertThat(CaseUtils.toCamelCase("To.Camel.Case", false, new char[]{'.'})).isEqualTo("toCamelCase");
+ assertThat(CaseUtils.toCamelCase("To.Camel-Case", false, new char[]{'-', '.'})).isEqualTo("toCamelCase");
+ assertThat(CaseUtils.toCamelCase(" to @ Camel case", false, new char[]{'-', '@'})).isEqualTo("toCamelCase");
+ assertThat(CaseUtils.toCamelCase(" @to @ Camel case", true, new char[]{'-', '@'})).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("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("tocamelcase", true));
- assertEquals("tocamelcase", CaseUtils.toCamelCase("tocamelcase", false));
+ assertThat(CaseUtils.toCamelCase("tocamelcase", true)).isEqualTo("Tocamelcase");
+ assertThat(CaseUtils.toCamelCase("tocamelcase", false)).isEqualTo("tocamelcase");
- 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,
- new char[]{'\uD800', '\uDF14'}));
+ 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,
+ new char[]{'\uD800', '\uDF14'}))
+ .isEqualTo("\uD800\uDF00\uD800\uDF01\uD800\uDF02\uD800\uDF03");
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/CharacterPredicatesTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/text/CharacterPredicatesTest.java b/src/test/java/org/apache/commons/text/CharacterPredicatesTest.java
index 63f606b..070a84a 100644
--- a/src/test/java/org/apache/commons/text/CharacterPredicatesTest.java
+++ b/src/test/java/org/apache/commons/text/CharacterPredicatesTest.java
@@ -16,11 +16,10 @@
*/
package org.apache.commons.text;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
import org.junit.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
* Tests for {@link CharacterPredicates}.
*/
@@ -28,87 +27,87 @@ public class CharacterPredicatesTest {
@Test
public void testLetters() throws Exception {
- assertTrue(CharacterPredicates.LETTERS.test('a'));
- assertTrue(CharacterPredicates.LETTERS.test('Z'));
+ assertThat(CharacterPredicates.LETTERS.test('a')).isTrue();
+ assertThat(CharacterPredicates.LETTERS.test('Z')).isTrue();
- assertFalse(CharacterPredicates.LETTERS.test('1'));
- assertFalse(CharacterPredicates.LETTERS.test('?'));
- assertFalse(CharacterPredicates.LETTERS.test('@'));
+ assertThat(CharacterPredicates.LETTERS.test('1')).isFalse();
+ assertThat(CharacterPredicates.LETTERS.test('?')).isFalse();
+ assertThat(CharacterPredicates.LETTERS.test('@')).isFalse();
}
@Test
public void testDigits() {
- assertTrue(CharacterPredicates.DIGITS.test('0'));
- assertTrue(CharacterPredicates.DIGITS.test('9'));
+ assertThat(CharacterPredicates.DIGITS.test('0')).isTrue();
+ assertThat(CharacterPredicates.DIGITS.test('9')).isTrue();
- assertFalse(CharacterPredicates.DIGITS.test('-'));
- assertFalse(CharacterPredicates.DIGITS.test('.'));
- assertFalse(CharacterPredicates.DIGITS.test('L'));
+ assertThat(CharacterPredicates.DIGITS.test('-')).isFalse();
+ assertThat(CharacterPredicates.DIGITS.test('.')).isFalse();
+ assertThat(CharacterPredicates.DIGITS.test('L')).isFalse();
}
@Test
public void testArabicNumerals() {
- assertTrue(CharacterPredicates.ARABIC_NUMERALS.test('0'));
- assertTrue(CharacterPredicates.ARABIC_NUMERALS.test('1'));
- assertTrue(CharacterPredicates.ARABIC_NUMERALS.test('9'));
+ assertThat(CharacterPredicates.ARABIC_NUMERALS.test('0')).isTrue();
+ assertThat(CharacterPredicates.ARABIC_NUMERALS.test('1')).isTrue();
+ assertThat(CharacterPredicates.ARABIC_NUMERALS.test('9')).isTrue();
- assertFalse(CharacterPredicates.ARABIC_NUMERALS.test('/'));
- assertFalse(CharacterPredicates.ARABIC_NUMERALS.test(':'));
- assertFalse(CharacterPredicates.ARABIC_NUMERALS.test('a'));
+ assertThat(CharacterPredicates.ARABIC_NUMERALS.test('/')).isFalse();
+ assertThat(CharacterPredicates.ARABIC_NUMERALS.test(':')).isFalse();
+ assertThat(CharacterPredicates.ARABIC_NUMERALS.test('a')).isFalse();
}
@Test
public void testAsciiLowercaseLetters() {
- 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('{'));
+ 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();
}
@Test
public void testAsciiUppercaseLetters() {
- 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'));
+ 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();
}
@Test
public void testAsciiLetters() {
- 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('['));
+ 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();
}
@Test
public void testAsciiAlphaNumerals() {
- 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(':'));
+ 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();
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/FormattableUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/text/FormattableUtilsTest.java b/src/test/java/org/apache/commons/text/FormattableUtilsTest.java
index 6038f62..7741523 100644
--- a/src/test/java/org/apache/commons/text/FormattableUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/FormattableUtilsTest.java
@@ -17,7 +17,7 @@
package org.apache.commons.text;
import static java.util.FormattableFlags.LEFT_JUSTIFY;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
import java.util.Formattable;
import java.util.Formatter;
@@ -38,61 +38,73 @@ public class FormattableUtilsTest {
public void testSimplestFormat() {
final Formattable formattable = new SimplestFormattable("foo");
- assertEquals("foo", FormattableUtils.toString(formattable));
+ assertThat(FormattableUtils.toString(formattable)).isEqualTo("foo");
}
@Test
public void testDefaultAppend() {
- assertEquals("foo", FormattableUtils.append("foo", new Formatter(), 0, -1, -1).toString());
- assertEquals("fo", FormattableUtils.append("foo", new Formatter(), 0, -1, 2).toString());
- assertEquals(" foo", FormattableUtils.append("foo", new Formatter(), 0, 4, -1).toString());
- assertEquals(" foo", FormattableUtils.append("foo", new Formatter(), 0, 6, -1).toString());
- assertEquals(" fo", FormattableUtils.append("foo", new Formatter(), 0, 3, 2).toString());
- assertEquals(" fo", FormattableUtils.append("foo", new Formatter(), 0, 5, 2).toString());
- assertEquals("foo ", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 4, -1).toString());
- assertEquals("foo ", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 6, -1).toString());
- assertEquals("fo ", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 3, 2).toString());
- assertEquals("fo ", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 5, 2).toString());
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, -1, -1).toString()).isEqualTo("foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, -1, 2).toString()).isEqualTo("fo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 4, -1).toString()).isEqualTo(" foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 6, -1).toString()).isEqualTo(" foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 3, 2).toString()).isEqualTo(" fo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 5, 2).toString()).isEqualTo(" fo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 4, -1).toString()).isEqualTo("foo ");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 6, -1).toString()).isEqualTo("foo ");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 3, 2).toString()).isEqualTo("fo ");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 5, 2).toString()).isEqualTo("fo ");
}
@Test
public void testAlternatePadCharacter() {
final char pad = '_';
- assertEquals("foo", FormattableUtils.append("foo", new Formatter(), 0, -1, -1, pad).toString());
- assertEquals("fo", FormattableUtils.append("foo", new Formatter(), 0, -1, 2, pad).toString());
- assertEquals("_foo", FormattableUtils.append("foo", new Formatter(), 0, 4, -1, pad).toString());
- assertEquals("___foo", FormattableUtils.append("foo", new Formatter(), 0, 6, -1, pad).toString());
- assertEquals("_fo", FormattableUtils.append("foo", new Formatter(), 0, 3, 2, pad).toString());
- assertEquals("___fo", FormattableUtils.append("foo", new Formatter(), 0, 5, 2, pad).toString());
- assertEquals("foo_", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 4, -1, pad).toString());
- assertEquals("foo___", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 6, -1, pad).toString());
- assertEquals("fo_", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 3, 2, pad).toString());
- assertEquals("fo___", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 5, 2, pad).toString());
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, -1, -1, pad).toString()).isEqualTo("foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, -1, 2, pad).toString()).isEqualTo("fo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 4, -1, pad).toString()).isEqualTo("_foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 6, -1, pad).toString()).isEqualTo("___foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 3, 2, pad).toString()).isEqualTo("_fo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 5, 2, pad).toString()).isEqualTo("___fo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 4, -1, pad).toString())
+ .isEqualTo("foo_");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 6, -1, pad).toString())
+ .isEqualTo("foo___");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 3, 2, pad).toString())
+ .isEqualTo("fo_");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 5, 2, pad).toString())
+ .isEqualTo("fo___");
}
@Test
public void testEllipsis() {
- assertEquals("foo", FormattableUtils.append("foo", new Formatter(), 0, -1, -1, "*").toString());
- assertEquals("f*", FormattableUtils.append("foo", new Formatter(), 0, -1, 2, "*").toString());
- assertEquals(" foo", FormattableUtils.append("foo", new Formatter(), 0, 4, -1, "*").toString());
- assertEquals(" foo", FormattableUtils.append("foo", new Formatter(), 0, 6, -1, "*").toString());
- assertEquals(" f*", FormattableUtils.append("foo", new Formatter(), 0, 3, 2, "*").toString());
- assertEquals(" f*", FormattableUtils.append("foo", new Formatter(), 0, 5, 2, "*").toString());
- assertEquals("foo ", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 4, -1, "*").toString());
- assertEquals("foo ", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 6, -1, "*").toString());
- assertEquals("f* ", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 3, 2, "*").toString());
- assertEquals("f* ", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 5, 2, "*").toString());
-
- assertEquals("foo", FormattableUtils.append("foo", new Formatter(), 0, -1, -1, "+*").toString());
- assertEquals("+*", FormattableUtils.append("foo", new Formatter(), 0, -1, 2, "+*").toString());
- assertEquals(" foo", FormattableUtils.append("foo", new Formatter(), 0, 4, -1, "+*").toString());
- assertEquals(" foo", FormattableUtils.append("foo", new Formatter(), 0, 6, -1, "+*").toString());
- assertEquals(" +*", FormattableUtils.append("foo", new Formatter(), 0, 3, 2, "+*").toString());
- assertEquals(" +*", FormattableUtils.append("foo", new Formatter(), 0, 5, 2, "+*").toString());
- assertEquals("foo ", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 4, -1, "+*").toString());
- assertEquals("foo ", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 6, -1, "+*").toString());
- assertEquals("+* ", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 3, 2, "+*").toString());
- assertEquals("+* ", FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 5, 2, "+*").toString());
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, -1, -1, "*").toString()).isEqualTo("foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, -1, 2, "*").toString()).isEqualTo("f*");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 4, -1, "*").toString()).isEqualTo(" foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 6, -1, "*").toString()).isEqualTo(" foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 3, 2, "*").toString()).isEqualTo(" f*");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 5, 2, "*").toString()).isEqualTo(" f*");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 4, -1, "*").toString())
+ .isEqualTo("foo ");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 6, -1, "*").toString())
+ .isEqualTo("foo ");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 3, 2, "*").toString())
+ .isEqualTo("f* ");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 5, 2, "*").toString())
+ .isEqualTo("f* ");
+
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, -1, -1, "+*").toString()).isEqualTo("foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, -1, 2, "+*").toString()).isEqualTo("+*");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 4, -1, "+*").toString()).isEqualTo(" foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 6, -1, "+*").toString()).isEqualTo(" foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 3, 2, "+*").toString()).isEqualTo(" +*");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 5, 2, "+*").toString()).isEqualTo(" +*");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 4, -1, "+*").toString())
+ .isEqualTo("foo ");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 6, -1, "+*").toString())
+ .isEqualTo("foo ");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 3, 2, "+*").toString())
+ .isEqualTo("+* ");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 5, 2, "+*").toString())
+ .isEqualTo("+* ");
}
@Test(expected = IllegalArgumentException.class)
@@ -102,35 +114,36 @@ public class FormattableUtilsTest {
@Test
public void testAlternatePadCharAndEllipsis() {
- assertEquals("foo", FormattableUtils.append("foo", new Formatter(), 0, -1, -1, '_', "*").toString());
- assertEquals("f*", FormattableUtils.append("foo", new Formatter(), 0, -1, 2, '_', "*").toString());
- assertEquals("_foo", FormattableUtils.append("foo", new Formatter(), 0, 4, -1, '_', "*").toString());
- assertEquals("___foo", FormattableUtils.append("foo", new Formatter(), 0, 6, -1, '_', "*").toString());
- assertEquals("_f*", FormattableUtils.append("foo", new Formatter(), 0, 3, 2, '_', "*").toString());
- assertEquals("___f*", FormattableUtils.append("foo", new Formatter(), 0, 5, 2, '_', "*").toString());
- assertEquals("foo_",
- FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 4, -1, '_', "*").toString());
- assertEquals("foo___",
- FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 6, -1, '_', "*").toString());
- assertEquals("f*_",
- FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 3, 2, '_', "*").toString());
- assertEquals("f*___",
- FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 5, 2, '_', "*").toString());
-
- assertEquals("foo", FormattableUtils.append("foo", new Formatter(), 0, -1, -1, '_', "+*").toString());
- assertEquals("+*", FormattableUtils.append("foo", new Formatter(), 0, -1, 2, '_', "+*").toString());
- assertEquals("_foo", FormattableUtils.append("foo", new Formatter(), 0, 4, -1, '_', "+*").toString());
- assertEquals("___foo", FormattableUtils.append("foo", new Formatter(), 0, 6, -1, '_', "+*").toString());
- assertEquals("_+*", FormattableUtils.append("foo", new Formatter(), 0, 3, 2, '_', "+*").toString());
- assertEquals("___+*", FormattableUtils.append("foo", new Formatter(), 0, 5, 2, '_', "+*").toString());
- assertEquals("foo_",
- FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 4, -1, '_', "+*").toString());
- assertEquals("foo___",
- FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 6, -1, '_', "+*").toString());
- assertEquals("+*_",
- FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 3, 2, '_', "+*").toString());
- assertEquals("+*___",
- FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 5, 2, '_', "+*").toString());
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, -1, -1, '_', "*").toString()).isEqualTo("foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, -1, 2, '_', "*").toString()).isEqualTo("f*");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 4, -1, '_', "*").toString()).isEqualTo("_foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 6, -1, '_', "*").toString()).isEqualTo("___foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 3, 2, '_', "*").toString()).isEqualTo("_f*");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 5, 2, '_', "*").toString()).isEqualTo("___f*");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 4, -1, '_', "*").toString())
+ .isEqualTo("foo_");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 6, -1, '_', "*").toString())
+ .isEqualTo("foo___");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 3, 2, '_', "*").toString())
+ .isEqualTo("f*_");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 5, 2, '_', "*").toString())
+ .isEqualTo("f*___");
+
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, -1, -1, '_', "+*").toString()).isEqualTo("foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, -1, 2, '_', "+*").toString()).isEqualTo("+*");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 4, -1, '_', "+*").toString()).isEqualTo("_foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 6, -1, '_', "+*").toString())
+ .isEqualTo("___foo");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 3, 2, '_', "+*").toString()).isEqualTo("_+*");
+ assertThat(FormattableUtils.append("foo", new Formatter(), 0, 5, 2, '_', "+*").toString()).isEqualTo("___+*");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 4, -1, '_', "+*").toString())
+ .isEqualTo("foo_");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 6, -1, '_', "+*").toString())
+ .isEqualTo("foo___");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 3, 2, '_', "+*").toString())
+ .isEqualTo("+*_");
+ assertThat(FormattableUtils.append("foo", new Formatter(), LEFT_JUSTIFY, 5, 2, '_', "+*").toString())
+ .isEqualTo("+*___");
}
@Test(expected = NullPointerException.class)
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/RandomStringGeneratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/text/RandomStringGeneratorTest.java b/src/test/java/org/apache/commons/text/RandomStringGeneratorTest.java
index 8b7a172..be1443e 100644
--- a/src/test/java/org/apache/commons/text/RandomStringGeneratorTest.java
+++ b/src/test/java/org/apache/commons/text/RandomStringGeneratorTest.java
@@ -19,11 +19,9 @@ package org.apache.commons.text;
import static org.hamcrest.Matchers.allOf;
import static org.hamcrest.Matchers.greaterThanOrEqualTo;
import static org.hamcrest.Matchers.lessThanOrEqualTo;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.fail;
import org.junit.Test;
@@ -73,7 +71,7 @@ public class RandomStringGeneratorTest {
final int length = 99;
final RandomStringGenerator generator = new RandomStringGenerator.Builder().build();
final String str = generator.generate(length);
- assertEquals(length, codePointLength(str));
+ assertThat(codePointLength(str)).isEqualTo(length);
}
@Test
@@ -107,7 +105,7 @@ public class RandomStringGeneratorTest {
int i = 0;
do {
final int codePoint = str.codePointAt(i);
- assertTrue(codePoint >= minimumCodePoint && codePoint <= maximumCodePoint);
+ assertThat(codePoint >= minimumCodePoint && codePoint <= maximumCodePoint).isTrue();
i += Character.charCount(codePoint);
} while (i < str.length());
}
@@ -131,7 +129,7 @@ public class RandomStringGeneratorTest {
int i = 0;
do {
final int codePoint = str.codePointAt(i);
- assertTrue(codePoint >= minimumCodePoint && codePoint <= maximumCodePoint);
+ assertThat(codePoint >= minimumCodePoint && codePoint <= maximumCodePoint).isTrue();
i += Character.charCount(codePoint);
} while (i < str.length());
}
@@ -147,16 +145,16 @@ public class RandomStringGeneratorTest {
final char c = str.charAt(i);
if (Character.isLowSurrogate(c)) {
- assertTrue(Character.isHighSurrogate(lastChar));
+ assertThat(Character.isHighSurrogate(lastChar)).isTrue();
}
if (Character.isHighSurrogate(lastChar)) {
- assertTrue(Character.isLowSurrogate(c));
+ assertThat(Character.isLowSurrogate(c)).isTrue();
}
if (Character.isHighSurrogate(c)) {
// test this isn't the last character in the string
- assertTrue(i + 1 < str.length());
+ assertThat(i + 1 < str.length()).isTrue();
}
lastChar = c;
@@ -176,7 +174,7 @@ public class RandomStringGeneratorTest {
final String str = new RandomStringGenerator.Builder().usingRandom(testRandom).build().generate(10);
for (final char c : str.toCharArray()) {
- assertEquals(testChar, c);
+ assertThat(c).isEqualTo(testChar);
}
}
@@ -198,7 +196,7 @@ public class RandomStringGeneratorTest {
}
}
- assertTrue(aFound && bFound);
+ assertThat(aFound && bFound).isTrue();
}
@Test
@@ -213,7 +211,7 @@ public class RandomStringGeneratorTest {
int i = 0;
do {
final int codePoint = str.codePointAt(i);
- assertFalse(Character.getType(codePoint) == Character.PRIVATE_USE);
+ assertThat(Character.getType(codePoint) == Character.PRIVATE_USE).isFalse();
i += Character.charCount(codePoint);
} while (i < str.length());
}
@@ -248,14 +246,14 @@ public class RandomStringGeneratorTest {
final String str = builder.filteredBy(B_FILTER).build().generate(100);
for (final char c : str.toCharArray()) {
- assertTrue(c == 'b');
+ assertThat(c == 'b').isTrue();
}
}
@Test
public void testZeroLength() {
final RandomStringGenerator generator = new RandomStringGenerator.Builder().build();
- assertEquals("", generator.generate(0));
+ assertThat(generator.generate(0)).isEqualTo("");
}
@Test
@@ -267,7 +265,7 @@ public class RandomStringGeneratorTest {
final String randomText = generator.generate(5);
for (final char c : randomText.toCharArray()) {
- assertTrue(str.indexOf(c) != -1);
+ assertThat(str.indexOf(c) != -1).isTrue();
}
}
@@ -277,7 +275,7 @@ public class RandomStringGeneratorTest {
final RandomStringGenerator generator = new RandomStringGenerator.Builder().selectFrom('a', 'b', 'c').build();
final String randomText = generator.generate(5);
for (final char c : randomText.toCharArray()) {
- assertTrue(str.indexOf(c) != -1);
+ assertThat(str.indexOf(c) != -1).isTrue();
}
}
[2/5] [text] Partial and mostly automated migration of assertions
from JUnit to AssertJ. (closes #70)
Posted by pa...@apache.org.
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/similarity/LevenshteinDetailedDistanceTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/text/similarity/LevenshteinDetailedDistanceTest.java b/src/test/java/org/apache/commons/text/similarity/LevenshteinDetailedDistanceTest.java
index 2462e84..78f3b2b 100644
--- a/src/test/java/org/apache/commons/text/similarity/LevenshteinDetailedDistanceTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/LevenshteinDetailedDistanceTest.java
@@ -16,7 +16,7 @@
*/
package org.apache.commons.text.similarity;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
import org.apache.commons.text.StrBuilder;
import org.junit.Test;
@@ -28,64 +28,64 @@ public class LevenshteinDetailedDistanceTest {
@Test
public void testGetLevenshteinDetailedDistance_StringString() {
LevenshteinResults result = UNLIMITED_DISTANCE.apply("", "");
- assertEquals(0, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(0);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = UNLIMITED_DISTANCE.apply("", "a");
- assertEquals(1, (int) result.getDistance());
- assertEquals(1, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(1);
+ assertThat(result.getInsertCount()).isEqualTo(1);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = UNLIMITED_DISTANCE.apply("aaapppp", "");
- assertEquals(7, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(7, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(7);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(7);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = UNLIMITED_DISTANCE.apply("frog", "fog");
- assertEquals(1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(1, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(1);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = UNLIMITED_DISTANCE.apply("fly", "ant");
- assertEquals(3, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(3, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(3);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(3);
result = UNLIMITED_DISTANCE.apply("elephant", "hippo");
- assertEquals(7, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(3, (int) result.getDeleteCount());
- assertEquals(4, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(7);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(3);
+ assertThat(result.getSubstituteCount()).isEqualTo(4);
result = UNLIMITED_DISTANCE.apply("hippo", "elephant");
- assertEquals(7, (int) result.getDistance());
- assertEquals(3, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(4, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(7);
+ assertThat(result.getInsertCount()).isEqualTo(3);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(4);
result = UNLIMITED_DISTANCE.apply("hippo", "zzzzzzzz");
- assertEquals(8, (int) result.getDistance());
- assertEquals(3, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(5, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(8);
+ assertThat(result.getInsertCount()).isEqualTo(3);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(5);
result = UNLIMITED_DISTANCE.apply("zzzzzzzz", "hippo");
- assertEquals(8, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(3, (int) result.getDeleteCount());
- assertEquals(5, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(8);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(3);
+ assertThat(result.getSubstituteCount()).isEqualTo(5);
result = UNLIMITED_DISTANCE.apply("hello", "hallo");
- assertEquals(1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(1, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(1);
}
@Test
@@ -93,16 +93,16 @@ public class LevenshteinDetailedDistanceTest {
final LevenshteinDetailedDistance classBeingTested = new LevenshteinDetailedDistance();
LevenshteinResults actualResult = classBeingTested.apply("hello", "hallo");
LevenshteinResults expectedResult = new LevenshteinResults(1, 0, 0, 1);
- assertEquals(actualResult, expectedResult);
+ assertThat(expectedResult).isEqualTo(actualResult);
actualResult = classBeingTested.apply("zzzzzzzz", "hippo");
expectedResult = new LevenshteinResults(8, 0, 3, 5);
- assertEquals(actualResult, expectedResult);
- assertEquals(actualResult, actualResult); //intentionally added
+ assertThat(expectedResult).isEqualTo(actualResult);
+ assertThat(actualResult).isEqualTo(actualResult); //intentionally added
actualResult = classBeingTested.apply("", "");
expectedResult = new LevenshteinResults(0, 0, 0, 0);
- assertEquals(actualResult, expectedResult);
+ assertThat(expectedResult).isEqualTo(actualResult);
}
@Test
@@ -110,15 +110,15 @@ public class LevenshteinDetailedDistanceTest {
final LevenshteinDetailedDistance classBeingTested = new LevenshteinDetailedDistance();
LevenshteinResults actualResult = classBeingTested.apply("aaapppp", "");
LevenshteinResults expectedResult = new LevenshteinResults(7, 0, 7, 0);
- assertEquals(actualResult.hashCode(), expectedResult.hashCode());
+ assertThat(expectedResult.hashCode()).isEqualTo(actualResult.hashCode());
actualResult = classBeingTested.apply("frog", "fog");
expectedResult = new LevenshteinResults(1, 0, 1, 0);
- assertEquals(actualResult.hashCode(), expectedResult.hashCode());
+ assertThat(expectedResult.hashCode()).isEqualTo(actualResult.hashCode());
actualResult = classBeingTested.apply("elephant", "hippo");
expectedResult = new LevenshteinResults(7, 0, 3, 4);
- assertEquals(actualResult.hashCode(), expectedResult.hashCode());
+ assertThat(expectedResult.hashCode()).isEqualTo(actualResult.hashCode());
}
@Test
@@ -126,15 +126,15 @@ public class LevenshteinDetailedDistanceTest {
final LevenshteinDetailedDistance classBeingTested = new LevenshteinDetailedDistance();
LevenshteinResults actualResult = classBeingTested.apply("fly", "ant");
LevenshteinResults expectedResult = new LevenshteinResults(3, 0, 0, 3);
- assertEquals(actualResult.toString(), expectedResult.toString());
+ assertThat(expectedResult.toString()).isEqualTo(actualResult.toString());
actualResult = classBeingTested.apply("hippo", "elephant");
expectedResult = new LevenshteinResults(7, 3, 0, 4);
- assertEquals(actualResult.toString(), expectedResult.toString());
+ assertThat(expectedResult.toString()).isEqualTo(actualResult.toString());
actualResult = classBeingTested.apply("", "a");
expectedResult = new LevenshteinResults(1, 1, 0, 0);
- assertEquals(actualResult.toString(), expectedResult.toString());
+ assertThat(expectedResult.toString()).isEqualTo(actualResult.toString());
}
@Test(expected = IllegalArgumentException.class)
@@ -152,238 +152,238 @@ public class LevenshteinDetailedDistanceTest {
LevenshteinResults result = new LevenshteinDetailedDistance(0).apply("", "");
- assertEquals(0, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(0);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(8).apply("aaapppp", "");
- assertEquals(7, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(7, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(7);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(7);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(7).apply("aaapppp", "");
- assertEquals(7, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(7, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(7);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(7);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(6).apply("aaapppp", "");
- assertEquals(-1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(-1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(0).apply("b", "a");
- assertEquals(-1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(-1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(0).apply("a", "b");
- assertEquals(-1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(-1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(0).apply("aa", "aa");
- assertEquals(0, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(0);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(2).apply("aa", "aa");
- assertEquals(0, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(0);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(2).apply("aaa", "bbb");
- assertEquals(-1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(-1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(3).apply("aaa", "bbb");
- assertEquals(3, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(3, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(3);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(3);
result = new LevenshteinDetailedDistance(10).apply("aaaaaa", "b");
- assertEquals(6, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(5, (int) result.getDeleteCount());
- assertEquals(1, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(6);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(5);
+ assertThat(result.getSubstituteCount()).isEqualTo(1);
result = new LevenshteinDetailedDistance(8).apply("aaapppp", "b");
- assertEquals(7, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(6, (int) result.getDeleteCount());
- assertEquals(1, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(7);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(6);
+ assertThat(result.getSubstituteCount()).isEqualTo(1);
result = new LevenshteinDetailedDistance(4).apply("a", "bbb");
- assertEquals(3, (int) result.getDistance());
- assertEquals(2, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(1, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(3);
+ assertThat(result.getInsertCount()).isEqualTo(2);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(1);
result = new LevenshteinDetailedDistance(7).apply("aaapppp", "b");
- assertEquals(7, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(6, (int) result.getDeleteCount());
- assertEquals(1, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(7);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(6);
+ assertThat(result.getSubstituteCount()).isEqualTo(1);
result = new LevenshteinDetailedDistance(3).apply("a", "bbb");
- assertEquals(3, (int) result.getDistance());
- assertEquals(2, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(1, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(3);
+ assertThat(result.getInsertCount()).isEqualTo(2);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(1);
result = new LevenshteinDetailedDistance(2).apply("a", "bbb");
- assertEquals(-1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(-1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(2).apply("bbb", "a");
- assertEquals(-1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(-1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(6).apply("aaapppp", "b");
- assertEquals(-1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(-1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(1).apply("a", "bbb");
- assertEquals(-1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(-1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(1).apply("bbb", "a");
- assertEquals(-1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(-1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(1).apply("12345", "1234567");
- assertEquals(-1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(-1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(1).apply("1234567", "12345");
- assertEquals(-1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(-1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(1).apply("frog", "fog");
- assertEquals(1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(1, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(1);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(3).apply("fly", "ant");
- assertEquals(3, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(3, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(3);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(3);
result = new LevenshteinDetailedDistance(7).apply("elephant", "hippo");
- assertEquals(7, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(3, (int) result.getDeleteCount());
- assertEquals(4, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(7);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(3);
+ assertThat(result.getSubstituteCount()).isEqualTo(4);
result = new LevenshteinDetailedDistance(6).apply("elephant", "hippo");
- assertEquals(-1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(-1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(7).apply("hippo", "elephant");
- assertEquals(7, (int) result.getDistance());
- assertEquals(3, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(4, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(7);
+ assertThat(result.getInsertCount()).isEqualTo(3);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(4);
result = new LevenshteinDetailedDistance(7).apply("hippo", "elephant");
- assertEquals(7, (int) result.getDistance());
- assertEquals(3, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(4, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(7);
+ assertThat(result.getInsertCount()).isEqualTo(3);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(4);
result = new LevenshteinDetailedDistance(6).apply("hippo", "elephant");
- assertEquals(-1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(-1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(8).apply("hippo", "zzzzzzzz");
- assertEquals(8, (int) result.getDistance());
- assertEquals(3, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(5, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(8);
+ assertThat(result.getInsertCount()).isEqualTo(3);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(5);
result = new LevenshteinDetailedDistance(8).apply("zzzzzzzz", "hippo");
- assertEquals(8, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(3, (int) result.getDeleteCount());
- assertEquals(5, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(8);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(3);
+ assertThat(result.getSubstituteCount()).isEqualTo(5);
result = new LevenshteinDetailedDistance(1).apply("hello", "hallo");
- assertEquals(1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(1, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(1);
result = new LevenshteinDetailedDistance(Integer.MAX_VALUE).apply("frog", "fog");
- assertEquals(1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(1, (int) result.getDeleteCount());
- assertEquals(0, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(1);
+ assertThat(result.getSubstituteCount()).isEqualTo(0);
result = new LevenshteinDetailedDistance(Integer.MAX_VALUE).apply("fly", "ant");
- assertEquals(3, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(3, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(3);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(3);
result = new LevenshteinDetailedDistance(Integer.MAX_VALUE).apply("elephant", "hippo");
- assertEquals(7, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(3, (int) result.getDeleteCount());
- assertEquals(4, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(7);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(3);
+ assertThat(result.getSubstituteCount()).isEqualTo(4);
result = new LevenshteinDetailedDistance(Integer.MAX_VALUE).apply("hippo", "elephant");
- assertEquals(7, (int) result.getDistance());
- assertEquals(3, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(4, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(7);
+ assertThat(result.getInsertCount()).isEqualTo(3);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(4);
result = new LevenshteinDetailedDistance(Integer.MAX_VALUE).apply("hippo", "zzzzzzzz");
- assertEquals(8, (int) result.getDistance());
- assertEquals(3, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(5, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(8);
+ assertThat(result.getInsertCount()).isEqualTo(3);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(5);
result = new LevenshteinDetailedDistance(Integer.MAX_VALUE).apply("zzzzzzzz", "hippo");
- assertEquals(8, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(3, (int) result.getDeleteCount());
- assertEquals(5, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(8);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(3);
+ assertThat(result.getSubstituteCount()).isEqualTo(5);
result = new LevenshteinDetailedDistance(Integer.MAX_VALUE).apply("hello", "hallo");
- assertEquals(1, (int) result.getDistance());
- assertEquals(0, (int) result.getInsertCount());
- assertEquals(0, (int) result.getDeleteCount());
- assertEquals(1, (int) result.getSubstituteCount());
+ assertThat(result.getDistance()).isEqualTo(1);
+ assertThat(result.getInsertCount()).isEqualTo(0);
+ assertThat(result.getDeleteCount()).isEqualTo(0);
+ assertThat(result.getSubstituteCount()).isEqualTo(1);
}
@Test(expected = IllegalArgumentException.class)
@@ -409,7 +409,7 @@ public class LevenshteinDetailedDistanceTest {
levenshteinDetailedDistance.apply("Distance: -2147483643, Insert: 0, Delete: 0, Substitute: 0",
"Distance: 0, Insert: 2147483536, Delete: 0, Substitute: 0");
- assertEquals(21, (int) levenshteinResults.getDistance());
+ assertThat(levenshteinResults.getDistance()).isEqualTo(21);
}
@Test
@@ -420,7 +420,7 @@ public class LevenshteinDetailedDistanceTest {
levenshteinDetailedDistance.apply("Distance: 2147483647, Insert: 0, Delete: 0, Substitute: 0",
"Distance: 0, Insert: 2147483647, Delete: 0, Substitute: 0");
- assertEquals(20, (int) levenshteinResults.getDistance());
+ assertThat(levenshteinResults.getDistance()).isEqualTo(20);
}
@Test
@@ -429,11 +429,11 @@ public class LevenshteinDetailedDistanceTest {
final LevenshteinResults levenshteinResults =
levenshteinDetailedDistance.apply("", "Distance: 38, Insert: 0, Delete: 0, Substitute: 0");
- assertEquals(0, (int) levenshteinResults.getSubstituteCount());
- assertEquals(0, (int) levenshteinResults.getDeleteCount());
+ assertThat(levenshteinResults.getSubstituteCount()).isEqualTo(0);
+ assertThat(levenshteinResults.getDeleteCount()).isEqualTo(0);
- assertEquals(0, (int) levenshteinResults.getInsertCount());
- assertEquals(-1, (int) levenshteinResults.getDistance());
+ assertThat(levenshteinResults.getInsertCount()).isEqualTo(0);
+ assertThat(levenshteinResults.getDistance()).isEqualTo(-1);
}
@Test(expected = IllegalArgumentException.class)
@@ -453,7 +453,7 @@ public class LevenshteinDetailedDistanceTest {
public void testGetThreshold() {
final LevenshteinDetailedDistance levenshteinDetailedDistance = new LevenshteinDetailedDistance(0);
- assertEquals(0, (int) levenshteinDetailedDistance.getThreshold());
+ assertThat(levenshteinDetailedDistance.getThreshold()).isEqualTo(0);
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/similarity/LevenshteinDistanceTest.java
----------------------------------------------------------------------
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 51cce22..65ee83b 100644
--- a/src/test/java/org/apache/commons/text/similarity/LevenshteinDistanceTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/LevenshteinDistanceTest.java
@@ -18,8 +18,7 @@ package org.apache.commons.text.similarity;
import org.junit.Test;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link LevenshteinDistance}.
@@ -30,16 +29,16 @@ public class LevenshteinDistanceTest {
@Test
public void testGetLevenshteinDistance_StringString() {
- assertEquals(0, (int) UNLIMITED_DISTANCE.apply("", ""));
- assertEquals(1, (int) UNLIMITED_DISTANCE.apply("", "a"));
- assertEquals(7, (int) UNLIMITED_DISTANCE.apply("aaapppp", ""));
- assertEquals(1, (int) UNLIMITED_DISTANCE.apply("frog", "fog"));
- assertEquals(3, (int) UNLIMITED_DISTANCE.apply("fly", "ant"));
- assertEquals(7, (int) UNLIMITED_DISTANCE.apply("elephant", "hippo"));
- assertEquals(7, (int) UNLIMITED_DISTANCE.apply("hippo", "elephant"));
- assertEquals(8, (int) UNLIMITED_DISTANCE.apply("hippo", "zzzzzzzz"));
- assertEquals(8, (int) UNLIMITED_DISTANCE.apply("zzzzzzzz", "hippo"));
- assertEquals(1, (int) UNLIMITED_DISTANCE.apply("hello", "hallo"));
+ assertThat(UNLIMITED_DISTANCE.apply("", "")).isEqualTo(0);
+ assertThat(UNLIMITED_DISTANCE.apply("", "a")).isEqualTo(1);
+ assertThat(UNLIMITED_DISTANCE.apply("aaapppp", "")).isEqualTo(7);
+ assertThat(UNLIMITED_DISTANCE.apply("frog", "fog")).isEqualTo(1);
+ assertThat(UNLIMITED_DISTANCE.apply("fly", "ant")).isEqualTo(3);
+ assertThat(UNLIMITED_DISTANCE.apply("elephant", "hippo")).isEqualTo(7);
+ assertThat(UNLIMITED_DISTANCE.apply("hippo", "elephant")).isEqualTo(7);
+ assertThat(UNLIMITED_DISTANCE.apply("hippo", "zzzzzzzz")).isEqualTo(8);
+ assertThat(UNLIMITED_DISTANCE.apply("zzzzzzzz", "hippo")).isEqualTo(8);
+ assertThat(UNLIMITED_DISTANCE.apply("hello", "hallo")).isEqualTo(1);
}
@Test(expected = IllegalArgumentException.class)
@@ -55,71 +54,65 @@ public class LevenshteinDistanceTest {
@Test
public void testGetLevenshteinDistance_StringStringInt() {
// empty strings
- assertEquals(0, (int) new LevenshteinDistance(0).apply("", ""));
- assertEquals(7, (int) new LevenshteinDistance(8).apply("aaapppp", ""));
- assertEquals(7, (int) new LevenshteinDistance(7).apply("aaapppp", ""));
- assertEquals(-1, (int) new LevenshteinDistance(6).apply("aaapppp", ""));
+ assertThat(new LevenshteinDistance(0).apply("", "")).isEqualTo(0);
+ assertThat(new LevenshteinDistance(8).apply("aaapppp", "")).isEqualTo(7);
+ assertThat(new LevenshteinDistance(7).apply("aaapppp", "")).isEqualTo(7);
+ assertThat(new LevenshteinDistance(6).apply("aaapppp", "")).isEqualTo(-1);
// unequal strings, zero threshold
- assertEquals(-1, (int) new LevenshteinDistance(0).apply("b", "a"));
- assertEquals(-1, (int) new LevenshteinDistance(0).apply("a", "b"));
+ assertThat(new LevenshteinDistance(0).apply("b", "a")).isEqualTo(-1);
+ assertThat(new LevenshteinDistance(0).apply("a", "b")).isEqualTo(-1);
// equal strings
- assertEquals(0, (int) new LevenshteinDistance(0).apply("aa", "aa"));
- assertEquals(0, (int) new LevenshteinDistance(2).apply("aa", "aa"));
+ assertThat(new LevenshteinDistance(0).apply("aa", "aa")).isEqualTo(0);
+ assertThat(new LevenshteinDistance(2).apply("aa", "aa")).isEqualTo(0);
// same length
- assertEquals(-1, (int) new LevenshteinDistance(2).apply("aaa", "bbb"));
- assertEquals(3, (int) new LevenshteinDistance(3).apply("aaa", "bbb"));
+ assertThat(new LevenshteinDistance(2).apply("aaa", "bbb")).isEqualTo(-1);
+ assertThat(new LevenshteinDistance(3).apply("aaa", "bbb")).isEqualTo(3);
// big stripe
- assertEquals(6, (int) new LevenshteinDistance(10).apply("aaaaaa", "b"));
+ assertThat(new LevenshteinDistance(10).apply("aaaaaa", "b")).isEqualTo(6);
// distance less than threshold
- assertEquals(7, (int) new LevenshteinDistance(8).apply("aaapppp", "b"));
- assertEquals(3, (int) new LevenshteinDistance(4).apply("a", "bbb"));
+ assertThat(new LevenshteinDistance(8).apply("aaapppp", "b")).isEqualTo(7);
+ assertThat(new LevenshteinDistance(4).apply("a", "bbb")).isEqualTo(3);
// distance equal to threshold
- assertEquals(7, (int) new LevenshteinDistance(7).apply("aaapppp", "b"));
- assertEquals(3, (int) new LevenshteinDistance(3).apply("a", "bbb"));
+ assertThat(new LevenshteinDistance(7).apply("aaapppp", "b")).isEqualTo(7);
+ assertThat(new LevenshteinDistance(3).apply("a", "bbb")).isEqualTo(3);
// distance greater than threshold
- assertEquals(-1, (int) new LevenshteinDistance(2).apply("a", "bbb"));
- assertEquals(-1, (int) new LevenshteinDistance(2).apply("bbb", "a"));
- assertEquals(-1, (int) new LevenshteinDistance(6).apply("aaapppp", "b"));
+ assertThat(new LevenshteinDistance(2).apply("a", "bbb")).isEqualTo(-1);
+ assertThat(new LevenshteinDistance(2).apply("bbb", "a")).isEqualTo(-1);
+ assertThat(new LevenshteinDistance(6).apply("aaapppp", "b")).isEqualTo(-1);
// stripe runs off array, strings not similar
- assertEquals(-1, (int) new LevenshteinDistance(1).apply("a", "bbb"));
- assertEquals(-1, (int) new LevenshteinDistance(1).apply("bbb", "a"));
+ assertThat(new LevenshteinDistance(1).apply("a", "bbb")).isEqualTo(-1);
+ assertThat(new LevenshteinDistance(1).apply("bbb", "a")).isEqualTo(-1);
// stripe runs off array, strings are similar
- assertEquals(-1, (int) new LevenshteinDistance(1).apply("12345", "1234567"));
- assertEquals(-1, (int) new LevenshteinDistance(1).apply("1234567", "12345"));
+ assertThat(new LevenshteinDistance(1).apply("12345", "1234567")).isEqualTo(-1);
+ assertThat(new LevenshteinDistance(1).apply("1234567", "12345")).isEqualTo(-1);
// old getLevenshteinDistance test cases
- assertEquals(1, (int) new LevenshteinDistance(1).apply("frog", "fog"));
- assertEquals(3, (int) new LevenshteinDistance(3).apply("fly", "ant"));
- assertEquals(7, (int) new LevenshteinDistance(7).apply("elephant", "hippo"));
- assertEquals(-1, (int) new LevenshteinDistance(6).apply("elephant", "hippo"));
- assertEquals(7, (int) new LevenshteinDistance(7).apply("hippo", "elephant"));
- assertEquals(-1, (int) new LevenshteinDistance(6).apply("hippo", "elephant"));
- assertEquals(8, (int) new LevenshteinDistance(8).apply("hippo", "zzzzzzzz"));
- assertEquals(8, (int) new LevenshteinDistance(8).apply("zzzzzzzz", "hippo"));
- assertEquals(1, (int) new LevenshteinDistance(1).apply("hello", "hallo"));
-
- assertEquals(1,
- (int) new LevenshteinDistance(Integer.MAX_VALUE).apply("frog", "fog"));
- assertEquals(3, (int) new LevenshteinDistance(Integer.MAX_VALUE).apply("fly", "ant"));
- assertEquals(7,
- (int) new LevenshteinDistance(Integer.MAX_VALUE).apply("elephant", "hippo"));
- assertEquals(7,
- (int) new LevenshteinDistance(Integer.MAX_VALUE).apply("hippo", "elephant"));
- assertEquals(8,
- (int) new LevenshteinDistance(Integer.MAX_VALUE).apply("hippo", "zzzzzzzz"));
- assertEquals(8,
- (int) new LevenshteinDistance(Integer.MAX_VALUE).apply("zzzzzzzz", "hippo"));
- assertEquals(1,
- (int) new LevenshteinDistance(Integer.MAX_VALUE).apply("hello", "hallo"));
+ assertThat(new LevenshteinDistance(1).apply("frog", "fog")).isEqualTo(1);
+ assertThat(new LevenshteinDistance(3).apply("fly", "ant")).isEqualTo(3);
+ assertThat(new LevenshteinDistance(7).apply("elephant", "hippo")).isEqualTo(7);
+ assertThat(new LevenshteinDistance(6).apply("elephant", "hippo")).isEqualTo(-1);
+ assertThat(new LevenshteinDistance(7).apply("hippo", "elephant")).isEqualTo(7);
+ assertThat(new LevenshteinDistance(6).apply("hippo", "elephant")).isEqualTo(-1);
+ assertThat(new LevenshteinDistance(8).apply("hippo", "zzzzzzzz")).isEqualTo(8);
+ assertThat(new LevenshteinDistance(8).apply("zzzzzzzz", "hippo")).isEqualTo(8);
+ assertThat(new LevenshteinDistance(1).apply("hello", "hallo")).isEqualTo(1);
+
+ assertThat(new LevenshteinDistance(Integer.MAX_VALUE).apply("frog", "fog")).isEqualTo(1);
+ assertThat(new LevenshteinDistance(Integer.MAX_VALUE).apply("fly", "ant")).isEqualTo(3);
+ assertThat(new LevenshteinDistance(Integer.MAX_VALUE).apply("elephant", "hippo")).isEqualTo(7);
+ assertThat(new LevenshteinDistance(Integer.MAX_VALUE).apply("hippo", "elephant")).isEqualTo(7);
+ assertThat(new LevenshteinDistance(Integer.MAX_VALUE).apply("hippo", "zzzzzzzz")).isEqualTo(8);
+ assertThat(new LevenshteinDistance(Integer.MAX_VALUE).apply("zzzzzzzz", "hippo")).isEqualTo(8);
+ assertThat(new LevenshteinDistance(Integer.MAX_VALUE).apply("hello", "hallo")).isEqualTo(1);
}
@Test(expected = IllegalArgumentException.class)
@@ -144,7 +137,7 @@ public class LevenshteinDistanceTest {
@Test
public void testGetThresholdDirectlyAfterObjectInstantiation() {
- assertNull(new LevenshteinDistance().getThreshold());
+ assertThat(new LevenshteinDistance().getThreshold()).isNull();
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/similarity/LevenshteinResultsTest.java
----------------------------------------------------------------------
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 1216bf1..6f306cc 100644
--- a/src/test/java/org/apache/commons/text/similarity/LevenshteinResultsTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/LevenshteinResultsTest.java
@@ -18,8 +18,7 @@ package org.apache.commons.text.similarity;
import org.junit.Test;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
public class LevenshteinResultsTest {
@@ -32,7 +31,7 @@ public class LevenshteinResultsTest {
final LevenshteinResults levenshteinResultsTwo =
new LevenshteinResults(integerOne, integerOne, integerTwo, integerTwo);
- assertFalse(levenshteinResults.equals(levenshteinResultsTwo));
+ assertThat(levenshteinResults.equals(levenshteinResultsTwo)).isFalse();
}
@Test
@@ -41,7 +40,7 @@ public class LevenshteinResultsTest {
final LevenshteinResults levenshteinResults = new LevenshteinResults(null, integer, integer, null);
final LevenshteinResults levenshteinResultsTwo = new LevenshteinResults(null, null, null, null);
- assertFalse(levenshteinResults.equals(levenshteinResultsTwo));
+ assertThat(levenshteinResults.equals(levenshteinResultsTwo)).isFalse();
}
@Test
@@ -49,7 +48,7 @@ public class LevenshteinResultsTest {
final Integer integer = new Integer((-647));
final LevenshteinResults levenshteinResults = new LevenshteinResults(integer, null, null, integer);
- assertFalse(levenshteinResults.equals(null));
+ assertThat(levenshteinResults.equals(null)).isFalse();
}
@Test
@@ -58,7 +57,7 @@ public class LevenshteinResultsTest {
final LevenshteinResults levenshteinResults = new LevenshteinResults(integer, integer, integer, integer);
final LevenshteinResults levenshteinResultsTwo = new LevenshteinResults(integer, integer, integer, null);
- assertFalse(levenshteinResults.equals(levenshteinResultsTwo));
+ assertThat(levenshteinResults.equals(levenshteinResultsTwo)).isFalse();
}
@Test
@@ -66,7 +65,7 @@ public class LevenshteinResultsTest {
final Integer integer = new Integer(1662);
final LevenshteinResults levenshteinResults = new LevenshteinResults(integer, integer, integer, null);
- assertTrue(levenshteinResults.equals(levenshteinResults));
+ assertThat(levenshteinResults.equals(levenshteinResults)).isTrue();
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceDistanceTest.java
----------------------------------------------------------------------
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 e7fe904..516bac2 100644
--- a/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceDistanceTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceDistanceTest.java
@@ -19,7 +19,7 @@ package org.apache.commons.text.similarity;
import org.junit.BeforeClass;
import org.junit.Test;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link LongestCommonSubsequenceDistance}.
@@ -35,20 +35,19 @@ public class LongestCommonSubsequenceDistanceTest {
@Test
public void testGettingLogestCommonSubsequenceDistacne() {
- assertEquals(Integer.valueOf(0), subject.apply("", ""));
- assertEquals(Integer.valueOf(4), subject.apply("left", ""));
- assertEquals(Integer.valueOf(5), subject.apply("", "right"));
- assertEquals(Integer.valueOf(1), subject.apply("frog", "fog"));
- assertEquals(Integer.valueOf(6), subject.apply("fly", "ant"));
- assertEquals(Integer.valueOf(11), subject.apply("elephant", "hippo"));
- assertEquals(Integer.valueOf(7), subject.apply("ABC Corporation", "ABC Corp"));
- assertEquals(Integer.valueOf(4), subject.apply("D N H Enterprises Inc", "D & H Enterprises, Inc."));
- assertEquals(Integer.valueOf(9),
- subject.apply("My Gym Children's Fitness Center", "My Gym. Childrens Fitness"));
- assertEquals(Integer.valueOf(3), subject.apply("PENNSYLVANIA", "PENNCISYLVNIA"));
- assertEquals(Integer.valueOf(7), subject.apply("left", "right"));
- assertEquals(Integer.valueOf(9), subject.apply("leettteft", "ritttght"));
- assertEquals(Integer.valueOf(0), subject.apply("the same string", "the same string"));
+ 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);
}
@Test(expected = IllegalArgumentException.class)
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceTest.java
----------------------------------------------------------------------
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 57efa01..1b0efa5 100644
--- a/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceTest.java
@@ -19,7 +19,7 @@ package org.apache.commons.text.similarity;
import org.junit.BeforeClass;
import org.junit.Test;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link LongestCommonSubsequence}.
@@ -35,20 +35,19 @@ public class LongestCommonSubsequenceTest {
@Test
public void testLongestCommonSubsequenceApply() {
- assertEquals(Integer.valueOf(0), subject.apply("", ""));
- assertEquals(Integer.valueOf(0), subject.apply("left", ""));
- assertEquals(Integer.valueOf(0), subject.apply("", "right"));
- assertEquals(Integer.valueOf(3), subject.apply("frog", "fog"));
- assertEquals(Integer.valueOf(0), subject.apply("fly", "ant"));
- assertEquals(Integer.valueOf(1), subject.apply("elephant", "hippo"));
- assertEquals(Integer.valueOf(8), subject.apply("ABC Corporation", "ABC Corp"));
- assertEquals(Integer.valueOf(20), subject.apply("D N H Enterprises Inc", "D & H Enterprises, Inc."));
- assertEquals(Integer.valueOf(24),
- subject.apply("My Gym Children's Fitness Center", "My Gym. Childrens Fitness"));
- assertEquals(Integer.valueOf(11), subject.apply("PENNSYLVANIA", "PENNCISYLVNIA"));
- assertEquals(Integer.valueOf(1), subject.apply("left", "right"));
- assertEquals(Integer.valueOf(4), subject.apply("leettteft", "ritttght"));
- assertEquals(Integer.valueOf(15), subject.apply("the same string", "the same string"));
+ 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);
}
@Test(expected = IllegalArgumentException.class)
@@ -68,21 +67,21 @@ public class LongestCommonSubsequenceTest {
@Test
public void testLongestCommonSubsequence() {
- 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"));
+ 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");
}
@Test(expected = IllegalArgumentException.class)
@@ -103,21 +102,21 @@ public class LongestCommonSubsequenceTest {
@Test
@Deprecated
public void testLogestCommonSubsequence() {
- 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"));
+ 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");
}
@Test(expected = IllegalArgumentException.class)
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/similarity/SimilarityScoreFromTest.java
----------------------------------------------------------------------
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 8ff381e..1c8468a 100644
--- a/src/test/java/org/apache/commons/text/similarity/SimilarityScoreFromTest.java
+++ b/src/test/java/org/apache/commons/text/similarity/SimilarityScoreFromTest.java
@@ -17,7 +17,7 @@
package org.apache.commons.text.similarity;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Test;
@@ -34,7 +34,7 @@ public class SimilarityScoreFromTest {
final SimilarityScoreFrom<Integer> similarityScoreFrom =
new SimilarityScoreFrom<>(longestCommonSubsequence, "asdf");
- assertEquals(1, (int) similarityScoreFrom.apply("s"));
+ assertThat(similarityScoreFrom.apply("s")).isEqualTo(1);
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/translate/AggregateTranslatorTest.java
----------------------------------------------------------------------
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 c2649b0..8b67f6a 100644
--- a/src/test/java/org/apache/commons/text/translate/AggregateTranslatorTest.java
+++ b/src/test/java/org/apache/commons/text/translate/AggregateTranslatorTest.java
@@ -23,7 +23,7 @@ import java.io.StringWriter;
import java.util.HashMap;
import java.util.Map;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link AggregateTranslator}.
@@ -34,14 +34,14 @@ public class AggregateTranslatorTest {
public void testNullConstructor() throws Exception {
final String testString = "foo";
final AggregateTranslator subject = new AggregateTranslator((CharSequenceTranslator[]) null);
- assertEquals(testString, subject.translate(testString));
+ assertThat(subject.translate(testString)).isEqualTo(testString);
}
@Test
public void testNullVarargConstructor() throws Exception {
final String testString = "foo";
final AggregateTranslator subject = new AggregateTranslator((CharSequenceTranslator) null);
- assertEquals(testString, subject.translate(testString));
+ assertThat(subject.translate(testString)).isEqualTo(testString);
}
@Test
@@ -55,12 +55,12 @@ 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);
- assertEquals("Incorrect codepoint consumption", 3, result1);
- assertEquals("Incorrect value", "two", out1.toString());
+ assertThat(result1).as("Incorrect codepoint consumption").isEqualTo(3);
+ assertThat(out1.toString()).as("Incorrect value").isEqualTo("two");
final StringWriter out2 = new StringWriter();
final int result2 = subject.translate(new StringBuffer("three"), 0, out2);
- assertEquals("Incorrect codepoint consumption", 5, result2);
- assertEquals("Incorrect value", "four", out2.toString());
+ assertThat(result2).as("Incorrect codepoint consumption").isEqualTo(5);
+ assertThat(out2.toString()).as("Incorrect value").isEqualTo("four");
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/translate/CodePointTranslatorTest.java
----------------------------------------------------------------------
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 a60bf0a..6995f67 100644
--- a/src/test/java/org/apache/commons/text/translate/CodePointTranslatorTest.java
+++ b/src/test/java/org/apache/commons/text/translate/CodePointTranslatorTest.java
@@ -22,7 +22,7 @@ import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
public class CodePointTranslatorTest {
@@ -34,7 +34,7 @@ public class CodePointTranslatorTest {
final PipedReader pipedReader = new PipedReader();
final PipedWriter pipedWriter = new PipedWriter(pipedReader);
- assertEquals(1, numericEntityEscaper.translate(string, 0, pipedWriter));
+ assertThat(numericEntityEscaper.translate(string, 0, pipedWriter)).isEqualTo(1);
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/translate/CsvTranslatorsTest.java
----------------------------------------------------------------------
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 a70ffad..231a8d6 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.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
import java.io.IOException;
import java.io.StringWriter;
@@ -34,7 +34,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();
- assertEquals(data, input);
+ assertThat(input).isEqualTo(data);
}
@Test
@@ -44,7 +44,7 @@ public class CsvTranslatorsTest {
final String input = "hi,this,is,a,test";
escaper.translateWhole(input, writer);
final String data = writer.toString();
- assertEquals(data, "\"hi,this,is,a,test\"");
+ assertThat(data).isEqualTo("\"hi,this,is,a,test\"");
}
@Test
@@ -54,7 +54,7 @@ public class CsvTranslatorsTest {
final String input = "hi,this,is,a,\"quote,test";
escaper.translateWhole(input, writer);
final String data = writer.toString();
- assertEquals(data, "\"hi,this,is,a,\"\"quote,test\"");
+ assertThat(data).isEqualTo("\"hi,this,is,a,\"\"quote,test\"");
}
@Test
@@ -64,7 +64,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();
- assertEquals(data, "\"hi,this,is,a,CR,test" + String.valueOf(CharUtils.CR) + "\"");
+ assertThat(data).isEqualTo("\"hi,this,is,a,CR,test" + String.valueOf(CharUtils.CR) + "\"");
}
@Test
@@ -74,7 +74,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();
- assertEquals(data, "\"hi,this,is,a,LF,test" + String.valueOf(CharUtils.LF) + "\"");
+ assertThat(data).isEqualTo("\"hi,this,is,a,LF,test" + String.valueOf(CharUtils.LF) + "\"");
}
@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();
- assertEquals(data, "hi,this,is,unescape,test");
+ assertThat(data).isEqualTo("hi,this,is,unescape,test");
}
@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();
- assertEquals(data, "hi,this,is,unescape,test");
+ assertThat(data).isEqualTo("hi,this,is,unescape,test");
}
@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();
- assertEquals(data, input);
+ assertThat(input).isEqualTo(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();
- assertEquals(data, input);
+ assertThat(input).isEqualTo(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();
- assertEquals(data, "hi,this,is,\"unescape,test");
+ assertThat(data).isEqualTo("hi,this,is,\"unescape,test");
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/translate/EntityArraysTest.java
----------------------------------------------------------------------
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 761c864..9140a48 100644
--- a/src/test/java/org/apache/commons/text/translate/EntityArraysTest.java
+++ b/src/test/java/org/apache/commons/text/translate/EntityArraysTest.java
@@ -23,7 +23,7 @@ import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Map;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link EntityArrays}.
@@ -57,7 +57,7 @@ public class EntityArraysTest {
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
- assertEquals(mapDeclarationCounter, mapValue.keySet().size());
+ assertThat(mapValue.keySet().size()).isEqualTo(mapDeclarationCounter);
}
}
}
@@ -65,8 +65,8 @@ public class EntityArraysTest {
@Test
public void testForDuplicateDeclaredMapValuesISO8859Map() {
- assertEquals(EntityArrays.ISO8859_1_ESCAPE.keySet().size(),
- EntityArrays.ISO8859_1_UNESCAPE.keySet().size());
+ assertThat(EntityArrays.ISO8859_1_ESCAPE.keySet()).hasSameSizeAs(
+ EntityArrays.ISO8859_1_UNESCAPE.keySet());
}
@Test
@@ -76,8 +76,8 @@ public class EntityArraysTest {
@Test
public void testForDuplicateDeclaredMapValuesHtml40ExtendedMap() {
- assertEquals(EntityArrays.HTML40_EXTENDED_ESCAPE.keySet().size(),
- EntityArrays.HTML40_EXTENDED_UNESCAPE.keySet().size());
+ assertThat(EntityArrays.HTML40_EXTENDED_ESCAPE.keySet()).hasSameSizeAs(
+ EntityArrays.HTML40_EXTENDED_UNESCAPE.keySet());
}
@Test
@@ -87,8 +87,8 @@ public class EntityArraysTest {
@Test
public void testForDuplicateDeclaredMapValuesAposMap() {
- assertEquals(EntityArrays.APOS_ESCAPE.keySet().size(),
- EntityArrays.APOS_UNESCAPE.keySet().size());
+ assertThat(EntityArrays.APOS_ESCAPE.keySet()).hasSameSizeAs(
+ EntityArrays.APOS_UNESCAPE.keySet());
}
@Test
@@ -98,8 +98,8 @@ public class EntityArraysTest {
@Test
public void testForDuplicateDeclaredMapValuesBasicMap() {
- assertEquals(EntityArrays.BASIC_ESCAPE.keySet().size(),
- EntityArrays.BASIC_UNESCAPE.keySet().size());
+ assertThat(EntityArrays.BASIC_ESCAPE.keySet()).hasSameSizeAs(
+ EntityArrays.BASIC_UNESCAPE.keySet());
}
@Test
@@ -109,8 +109,8 @@ public class EntityArraysTest {
@Test
public void testForDuplicateDeclaredMapValuesJavaCtrlCharsMap() {
- assertEquals(EntityArrays.JAVA_CTRL_CHARS_ESCAPE.keySet().size(),
- EntityArrays.JAVA_CTRL_CHARS_UNESCAPE.keySet().size());
+ assertThat(EntityArrays.JAVA_CTRL_CHARS_ESCAPE.keySet()).hasSameSizeAs(
+ EntityArrays.JAVA_CTRL_CHARS_UNESCAPE.keySet());
}
@Test
@@ -123,7 +123,7 @@ public class EntityArraysTest {
for (final CharSequence escapeKey : escapeMap.keySet()) {
for (final CharSequence unescapeKey : unescapeMap.keySet()) {
if (escapeKey == unescapeMap.get(unescapeKey)) {
- assertEquals(escapeMap.get(escapeKey), unescapeKey);
+ assertThat(unescapeKey).isEqualTo(escapeMap.get(escapeKey));
}
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/translate/JavaUnicodeEscaperTest.java
----------------------------------------------------------------------
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 b6afb4a..88ad32f 100644
--- a/src/test/java/org/apache/commons/text/translate/JavaUnicodeEscaperTest.java
+++ b/src/test/java/org/apache/commons/text/translate/JavaUnicodeEscaperTest.java
@@ -20,7 +20,7 @@ import org.junit.Test;
import java.io.UnsupportedEncodingException;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link JavaUnicodeEscaper}.
@@ -33,7 +33,8 @@ public class JavaUnicodeEscaperTest {
final String input = "ADFGZ";
final String result = jue.translate(input);
- assertEquals("Failed to escape Unicode characters via the below method", "\\u0041\\u0044FGZ", result);
+ assertThat(result).as("Failed to escape Unicode characters via the below method")
+ .isEqualTo("\\u0041\\u0044FGZ");
}
@Test
@@ -42,7 +43,8 @@ public class JavaUnicodeEscaperTest {
final String input = "ADFGZ";
final String result = jue.translate(input);
- assertEquals("Failed to escape Unicode characters via the between method", "AD\\u0046\\u0047Z", result);
+ assertThat(result).as("Failed to escape Unicode characters via the between method")
+ .isEqualTo("AD\\u0046\\u0047Z");
}
@Test
@@ -51,7 +53,8 @@ public class JavaUnicodeEscaperTest {
final String input = "ADFGZ";
final String result = jue.translate(input);
- assertEquals("Failed to escape Unicode characters via the above method", "ADF\\u0047\\u005A", result);
+ assertThat(result).as("Failed to escape Unicode characters via the above method")
+ .isEqualTo("ADF\\u0047\\u005A");
}
@Test
@@ -61,6 +64,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));
- assertEquals("\\uD852\\uDF62", encoding);
+ assertThat(encoding).isEqualTo("\\uD852\\uDF62");
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/translate/LookupTranslatorTest.java
----------------------------------------------------------------------
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 ebd83cd..77b671f 100644
--- a/src/test/java/org/apache/commons/text/translate/LookupTranslatorTest.java
+++ b/src/test/java/org/apache/commons/text/translate/LookupTranslatorTest.java
@@ -25,7 +25,7 @@ import java.security.InvalidParameterException;
import java.util.HashMap;
import java.util.Map;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link LookupTranslator}.
@@ -39,8 +39,8 @@ public class LookupTranslatorTest {
final LookupTranslator lt = new LookupTranslator(translatorMap);
final StringWriter out = new StringWriter();
final int result = lt.translate("one", 0, out);
- assertEquals("Incorrect codepoint consumption", 3, result);
- assertEquals("Incorrect value", "two", out.toString());
+ assertThat(result).as("Incorrect codepoint consumption").isEqualTo(3);
+ assertThat(out.toString()).as("Incorrect value").isEqualTo("two");
}
// Tests: https://issues.apache.org/jira/browse/LANG-882
@@ -51,8 +51,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);
- assertEquals("Incorrect codepoint consumption", 3, result);
- assertEquals("Incorrect value", "two", out.toString());
+ assertThat(result).as("Incorrect codepoint consumption").isEqualTo(3);
+ assertThat(out.toString()).as("Incorrect value").isEqualTo("two");
}
@Test(expected = InvalidParameterException.class)
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/translate/NumericEntityEscaperTest.java
----------------------------------------------------------------------
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 aa125a6..160795a 100644
--- a/src/test/java/org/apache/commons/text/translate/NumericEntityEscaperTest.java
+++ b/src/test/java/org/apache/commons/text/translate/NumericEntityEscaperTest.java
@@ -19,7 +19,7 @@ package org.apache.commons.text.translate;
import org.junit.Test;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link NumericEntityEscaper}.
@@ -32,7 +32,7 @@ public class NumericEntityEscaperTest {
final String input = "ADFGZ";
final String result = nee.translate(input);
- assertEquals("Failed to escape numeric entities via the below method", "ADFGZ", result);
+ assertThat(result).as("Failed to escape numeric entities via the below method").isEqualTo("ADFGZ");
}
@Test
@@ -41,7 +41,7 @@ public class NumericEntityEscaperTest {
final String input = "ADFGZ";
final String result = nee.translate(input);
- assertEquals("Failed to escape numeric entities via the between method", "ADFGZ", result);
+ assertThat(result).as("Failed to escape numeric entities via the between method").isEqualTo("ADFGZ");
}
@Test
@@ -50,7 +50,7 @@ public class NumericEntityEscaperTest {
final String input = "ADFGZ";
final String result = nee.translate(input);
- assertEquals("Failed to escape numeric entities via the above method", "ADFGZ", result);
+ assertThat(result).as("Failed to escape numeric entities via the above method").isEqualTo("ADFGZ");
}
// See LANG-617
@@ -61,7 +61,7 @@ public class NumericEntityEscaperTest {
final String expected = "𐰢";
final String result = nee.translate(input);
- assertEquals("Failed to escape numeric entities supplementary characters", expected, result);
+ assertThat(result).as("Failed to escape numeric entities supplementary characters").isEqualTo(expected);
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/translate/NumericEntityUnescaperTest.java
----------------------------------------------------------------------
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 e510cbe..08665a2 100644
--- a/src/test/java/org/apache/commons/text/translate/NumericEntityUnescaperTest.java
+++ b/src/test/java/org/apache/commons/text/translate/NumericEntityUnescaperTest.java
@@ -19,8 +19,8 @@ package org.apache.commons.text.translate;
import org.junit.Test;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
/**
* Unit tests for {@link NumericEntityUnescaper}.
@@ -34,17 +34,17 @@ public class NumericEntityUnescaperTest {
final String expected = "\uD803\uDC22";
final String result = neu.translate(input);
- assertEquals("Failed to unescape numeric entities supplementary characters", expected, result);
+ assertThat(result).as("Failed to unescape numeric entities supplementary characters").isEqualTo(expected);
}
@Test
public void testOutOfBounds() {
final NumericEntityUnescaper neu = new NumericEntityUnescaper();
- assertEquals("Failed to ignore when last character is &", "Test &", neu.translate("Test &"));
- assertEquals("Failed to ignore when last character is &", "Test &#", neu.translate("Test &#"));
- assertEquals("Failed to ignore when last character is &", "Test &#x", neu.translate("Test &#x"));
- assertEquals("Failed to ignore when last character is &", "Test &#X", neu.translate("Test &#X"));
+ 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");
}
@Test
@@ -55,7 +55,7 @@ public class NumericEntityUnescaperTest {
String expected = "Test \u0030 not test";
String result = neu.translate(input);
- assertEquals("Failed to support unfinished entities (i.e. missing semi-colon)", expected, result);
+ assertThat(result).as("Failed to support unfinished entities (i.e. missing semi-colon)").isEqualTo(expected);
// ignore it
neu = new NumericEntityUnescaper();
@@ -63,7 +63,7 @@ public class NumericEntityUnescaperTest {
expected = input;
result = neu.translate(input);
- assertEquals("Failed to ignore unfinished entities (i.e. missing semi-colon)", expected, result);
+ assertThat(result).as("Failed to ignore unfinished entities (i.e. missing semi-colon)").isEqualTo(expected);
// fail it
neu = new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.errorIfNoSemiColon);
@@ -83,7 +83,7 @@ public class NumericEntityUnescaperTest {
final NumericEntityUnescaper numericEntityUnescaper =
new NumericEntityUnescaper(numericEntityUnescaperOPTIONArray);
- assertEquals("2|y|O7y`&#uVWj", numericEntityUnescaper.translate("2|y|O7y`&#uVWj"));
+ assertThat(numericEntityUnescaper.translate("2|y|O7y`&#uVWj")).isEqualTo("2|y|O7y`&#uVWj");
}
@Test
@@ -92,7 +92,7 @@ public class NumericEntityUnescaperTest {
final NumericEntityUnescaper numericEntityUnescaper =
new NumericEntityUnescaper(numericEntityUnescaperOPTIONArray);
- assertEquals("Ws2v8|O=7NR&#cB", numericEntityUnescaper.translate("Ws2v8|O=7NR&#cB"));
+ assertThat(numericEntityUnescaper.translate("Ws2v8|O=7NR&#cB")).isEqualTo("Ws2v8|O=7NR&#cB");
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/translate/OctalUnescaperTest.java
----------------------------------------------------------------------
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 864e12e..2d6efd3 100644
--- a/src/test/java/org/apache/commons/text/translate/OctalUnescaperTest.java
+++ b/src/test/java/org/apache/commons/text/translate/OctalUnescaperTest.java
@@ -19,7 +19,7 @@ package org.apache.commons.text.translate;
import org.junit.Test;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link OctalUnescaper}.
@@ -32,51 +32,52 @@ public class OctalUnescaperTest {
String input = "\\45";
String result = oue.translate(input);
- assertEquals("Failed to unescape octal characters via the between method", "\45", result);
+ assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\45");
input = "\\377";
result = oue.translate(input);
- assertEquals("Failed to unescape octal characters via the between method", "\377", result);
+ assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\377");
input = "\\377 and";
result = oue.translate(input);
- assertEquals("Failed to unescape octal characters via the between method", "\377 and", result);
+ assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\377 and");
input = "\\378 and";
result = oue.translate(input);
- assertEquals("Failed to unescape octal characters via the between method", "\37" + "8 and", result);
+ assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\37" + "8 and");
input = "\\378";
result = oue.translate(input);
- assertEquals("Failed to unescape octal characters via the between method", "\37" + "8", result);
+ assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\37" + "8");
input = "\\1";
result = oue.translate(input);
- assertEquals("Failed to unescape octal characters via the between method", "\1", result);
+ assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\1");
input = "\\036";
result = oue.translate(input);
- assertEquals("Failed to unescape octal characters via the between method", "\036", result);
+ assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\036");
input = "\\0365";
result = oue.translate(input);
- assertEquals("Failed to unescape octal characters via the between method", "\036" + "5", result);
+ assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\036" + "5");
input = "\\003";
result = oue.translate(input);
- assertEquals("Failed to unescape octal characters via the between method", "\003", result);
+ assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\003");
input = "\\0003";
result = oue.translate(input);
- assertEquals("Failed to unescape octal characters via the between method", "\000" + "3", result);
+ assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\000" + "3");
input = "\\279";
result = oue.translate(input);
- assertEquals("Failed to unescape octal characters via the between method", "\279", result);
+ assertThat(result).as("Failed to unescape octal characters via the between method").isEqualTo("\279");
input = "\\999";
result = oue.translate(input);
- assertEquals("Failed to ignore an out of range octal character via the between method", "\\999", result);
+ assertThat(result).as("Failed to ignore an out of range octal character via the between method")
+ .isEqualTo("\\999");
}
}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/e55d0ac1/src/test/java/org/apache/commons/text/translate/SinglePassTranslatorTest.java
----------------------------------------------------------------------
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 13e43e2..081dc13 100644
--- a/src/test/java/org/apache/commons/text/translate/SinglePassTranslatorTest.java
+++ b/src/test/java/org/apache/commons/text/translate/SinglePassTranslatorTest.java
@@ -23,7 +23,7 @@ import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit test for {@link SinglePassTranslator}
@@ -45,9 +45,9 @@ public class SinglePassTranslatorTest {
@Test
public void codePointsAreReturned() throws Exception {
- assertEquals(0, dummyTranslator.translate("", 0, out));
- assertEquals(3, dummyTranslator.translate("abc", 0, out));
- assertEquals(7, dummyTranslator.translate("abcdefg", 0, out));
+ assertThat(dummyTranslator.translate("", 0, out)).isEqualTo(0);
+ assertThat(dummyTranslator.translate("abc", 0, out)).isEqualTo(3);
+ assertThat(dummyTranslator.translate("abcdefg", 0, out)).isEqualTo(7);
}
@Test(expected = IllegalArgumentException.class)