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:19 UTC
[4/5] [text] Partial and mostly automated migration of assertions
from JUnit to AssertJ. (closes #70)
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);
}
}