rft - replace assertTrue and assertFalse with assertThat with matcher

Author: MerkushevKirill

src/test/java/ru/lanwen/verbalregex/BasicFunctionalityUnitTest.java

@@ -5,16 +5,17 @@
 import static org.hamcrest.CoreMatchers.*;
 import static org.junit.Assert.*;
 import static ru.lanwen.verbalregex.VerbalExpression.regex;
+import static ru.lanwen.verbalregex.matchers.TestMatchMatcher.matchesTo;
 import static ru.lanwen.verbalregex.matchers.TestsExactMatcher.matchesExactly;
 
 public class BasicFunctionalityUnitTest {
     @Test
     public void testSomething() {
         VerbalExpression testRegex = new VerbalExpression.Builder().something().build();
 
-        assertFalse("Null object doesn't have something", testRegex.test(null));
-        assertFalse("empty string doesn't have something", testRegex.test(""));
-        assertTrue("a", testRegex.test("a"));
+        assertThat("Null object doesn't have something", testRegex, not(matchesTo(null)));
+        assertThat("empty string doesn't have something", testRegex, not(matchesTo("")));
+        assertThat("a", testRegex, matchesTo("a"));
     }
 
     @Test
@@ -24,9 +25,9 @@ public void testAnything() {
                 .anything()
                 .build();
 
-        assertTrue(testRegex.test("what"));
-        assertFalse(testRegex.test(""));
-        assertTrue(testRegex.test(" "));
+        assertThat(testRegex, matchesTo("what"));
+        assertThat(testRegex, not(matchesTo("")));
+        assertThat(testRegex, matchesTo(" "));
     }
 
     @Test
@@ -63,9 +64,9 @@ public void testStartOfLine() {
 
         assertFalse("Null string", testRegex.testExact(null));
         assertFalse("empty string doesn't have something", testRegex.testExact(""));
-        assertTrue("Starts with a", testRegex.test("a"));
-        assertTrue("Starts with a", testRegex.test("ab"));
-        assertFalse("Doesn't start with a", testRegex.test("ba"));
+        assertThat("Starts with a", testRegex, matchesTo("a"));
+        assertThat("Starts with a", testRegex, matchesTo("ab"));
+        assertThat("Doesn't start with a", testRegex, not(matchesTo("ba")));
     }
 
     @Test
@@ -74,17 +75,17 @@ public void testStartOfLineFalse() {
                 .startOfLine(false)
                 .then("a")
                 .build();
-        assertThat(testRegex.test("ba"), is(true));
-        assertThat(testRegex.test("ab"), is(true));
+        assertThat(testRegex, matchesTo("ba"));
+        assertThat(testRegex, matchesTo("ab"));
     }
 
     @Test
     public void testRangeWithMultiplyRanges() throws Exception {
         VerbalExpression regex = regex().range("a", "z", "A", "Z").build();
 
         assertThat("Regex with multi-range differs from expected", regex.toString(), equalTo("[a-zA-Z]"));
-        assertThat("Regex don't matches letter", regex.test("b"), is(true));
-        assertThat("Regex matches digit, but should match only letter", regex.test("1"), is(false));
+        assertThat("Regex don't matches letter", regex, matchesTo("b"));
+        assertThat("Regex matches digit, but should match only letter", regex, not(matchesTo("1")));
     }
 
     @Test
@@ -94,10 +95,10 @@ public void testEndOfLine() {
                 .endOfLine()
                 .build();
 
-        assertTrue("Ends with a", testRegex.test("bba"));
-        assertTrue("Ends with a", testRegex.test("a"));
-        assertFalse("Ends with a", testRegex.test(null));
-        assertFalse("Doesn't end with a", testRegex.test("ab"));
+        assertThat("Ends with a", testRegex, matchesTo("bba"));
+        assertThat("Ends with a", testRegex, matchesTo("a"));
+        assertThat("Ends with a", testRegex, not(matchesTo(null)));
+        assertThat("Doesn't end with a", testRegex, not(matchesTo("ab")));
     }
 
 
@@ -107,8 +108,8 @@ public void testEndOfLineIsFalse() {
                 .find("a")
                 .endOfLine(false)
                 .build();
-        assertThat(testRegex.test("ba"), is(true));
-        assertThat(testRegex.test("ab"), is(true));
+        assertThat(testRegex, matchesTo("ba"));
+        assertThat(testRegex, matchesTo("ab"));
     }
 
 
@@ -122,9 +123,9 @@ public void testMaybe() {
 
         assertThat("Regex isn't correct", testRegex.toString(), equalTo("^(?:a)(?:b)?"));
 
-        assertTrue("Maybe has a 'b' after an 'a'", testRegex.test("acb"));
-        assertTrue("Maybe has a 'b' after an 'a'", testRegex.test("abc"));
-        assertFalse("Maybe has a 'b' after an 'a'", testRegex.test("cab"));
+        assertThat("Maybe has a 'b' after an 'a'", testRegex, matchesTo("acb"));
+        assertThat("Maybe has a 'b' after an 'a'", testRegex, matchesTo("abc"));
+        assertThat("Maybe has a 'b' after an 'a'", testRegex, not(matchesTo("cab")));
     }
 
     @Test
@@ -135,8 +136,8 @@ public void testAnyOf() {
                 .anyOf("xyz")
                 .build();
 
-        assertTrue("Has an x, y, or z after a", testRegex.test("ay"));
-        assertFalse("Doesn't have an x, y, or z after a", testRegex.test("abc"));
+        assertThat("Has an x, y, or z after a", testRegex, matchesTo("ay"));
+        assertThat("Doesn't have an x, y, or z after a", testRegex, not(matchesTo("abc")));
     }
 
 
@@ -156,8 +157,8 @@ public void testOr() {
                 .or("def")
                 .build();
 
-        assertTrue("Starts with abc or def", testRegex.test("defzzz"));
-        assertFalse("Doesn't start with abc or def", testRegex.test("xyzabc"));
+        assertThat("Starts with abc or def", testRegex, matchesTo("defzzz"));
+        assertThat("Doesn't start with abc or def", testRegex, not(matchesTo("xyzabc")));
     }
 
     @Test
@@ -169,9 +170,9 @@ public void testLineBreak() {
                 .then("def")
                 .build();
 
-        assertTrue("abc then line break then def", testRegex.test("abc\r\ndef"));
-        assertTrue("abc then line break then def", testRegex.test("abc\ndef"));
-        assertFalse("abc then line break then space then def", testRegex.test("abc\r\n def"));
+        assertThat("abc then line break then def", testRegex, matchesTo("abc\r\ndef"));
+        assertThat("abc then line break then def", testRegex, matchesTo("abc\ndef"));
+        assertThat("abc then line break then space then def", testRegex, not(matchesTo("abc\r\n def")));
     }
 
     @Test
@@ -201,8 +202,8 @@ public void testTab() {
                 .then("abc")
                 .build();
 
-        assertTrue("tab then abc", testRegex.test("\tabc"));
-        assertFalse("no tab then abc", testRegex.test("abc"));
+        assertThat("tab then abc", testRegex, matchesTo("\tabc"));
+        assertThat("no tab then abc", testRegex, not(matchesTo("abc")));
     }
 
     @Test
@@ -212,15 +213,15 @@ public void testWithAnyCase() {
                 .then("a")
                 .build();
 
-        assertFalse("not case insensitive", testRegex.test("A"));
+        assertThat("not case insensitive", testRegex, not(matchesTo("A")));
         testRegex = new VerbalExpression.Builder()
                 .startOfLine()
                 .then("a")
                 .withAnyCase()
                 .build();
 
-        assertTrue("case insensitive", testRegex.test("A"));
-        assertTrue("case insensitive", testRegex.test("a"));
+        assertThat("case insensitive", testRegex, matchesTo("A"));
+        assertThat("case insensitive", testRegex, matchesTo("a"));
     }
 
     @Test
@@ -232,7 +233,7 @@ public void testWithAnyCaseIsFalse() {
                 .withAnyCase(false)
                 .build();
 
-        assertThat(testRegex.test("A"), is(false));
+        assertThat(testRegex, not(matchesTo("A")));
     }
 
     @Test
@@ -245,7 +246,7 @@ public void testSearchOneLine() {
                 .endOfLine()
                 .build();
 
-        assertTrue("b is on the second line", testRegex.test("a\nb"));
+        assertThat("b is on the second line", testRegex, matchesTo("a\nb"));
 
         testRegex = new VerbalExpression.Builder()
                 .startOfLine()
@@ -256,7 +257,7 @@ public void testSearchOneLine() {
                 .searchOneLine(true)
                 .build();
 
-        assertTrue("b is on the second line but we are only searching the first", testRegex.test("a\nb"));
+        assertThat("b is on the second line but we are only searching the first", testRegex, matchesTo("a\nb"));
     }
 
     @Test
@@ -309,7 +310,7 @@ public void testCountWithRange() {
 
         assertThat("regex don't match string", regex.getText(text4c), equalTo("ccc"));
         assertThat("regex don't match string", regex.getText(text2c), equalTo("cc"));
-        assertThat("regex don't match string", regex.test(text1c), is(false));
+        assertThat("regex don't match string", regex, not(matchesTo(text1c)));
     }
 
     @Test
@@ -342,9 +343,9 @@ public void testOrWithCapture() {
                 .find("abc")
                 .or("def")
                 .build();
-        assertTrue("Starts with abc or def", testRegex.test("defzzz"));
-        assertTrue("Starts with abc or def", testRegex.test("abczzz"));
-        assertFalse("Doesn't start with abc or def", testRegex.testExact("xyzabcefg"));
+        assertThat("Starts with abc or def", testRegex, matchesTo("defzzz"));
+        assertThat("Starts with abc or def", testRegex, matchesTo("abczzz"));
+        assertThat("Doesn't start with abc or def", testRegex, not(matchesExactly("xyzabcefg")));
 
         assertThat(testRegex.getText("xxxabcdefzzz", 1), equalTo("abcdef"));
         assertThat(testRegex.getText("xxxdefzzz", 2), equalTo("null"));

src/test/java/ru/lanwen/verbalregex/NegativeCasesTest.java

@@ -6,8 +6,8 @@
 
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
+import static ru.lanwen.verbalregex.matchers.TestMatchMatcher.matchesTo;
 
 /**
  * User: lanwen
@@ -49,8 +49,8 @@ public void rangeWithThreeArgsUsesOnlyFirstTwo() throws Exception {
     @Test
     public void orWithNullMatchesAny() throws Exception {
         VerbalExpression regex = VerbalExpression.regex().startOfLine().then("a").or(null).build();
-        assertThat("regex don't matches writed letter", regex.test("a"), is(true));
-        assertThat("or(null) should match any", regex.test("bcd"), is(true));
+        assertThat("regex don't matches writed letter", regex, matchesTo("a"));
+        assertThat("or(null) should match any", regex, matchesTo("bcd"));
 
         assertThat("or(null) extract only first", regex.getText("abcd"), equalTo("a"));
     }

src/test/java/ru/lanwen/verbalregex/PredefinedCharClassesTest.java

@@ -7,6 +7,7 @@
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static ru.lanwen.verbalregex.VerbalExpression.regex;
+import static ru.lanwen.verbalregex.matchers.TestMatchMatcher.matchesTo;
 
 /**
  * User: lanwen
@@ -24,8 +25,8 @@ public class PredefinedCharClassesTest {
     public void testWordChar() throws Exception {
         VerbalExpression regex = regex().wordChar().build();
 
-        assertThat("Not matches on letters", regex.test(LETTERS_NO_DIGITS + DIGITS), is(true));
-        assertThat("matches on non letters", regex.test(NON_LETTERS + SPACE), is(false));
+        assertThat("Not matches on letters", regex, matchesTo(LETTERS_NO_DIGITS + DIGITS));
+        assertThat("matches on non letters", regex, not(matchesTo((NON_LETTERS + SPACE))));
         assertThat("Extracts wrong word chars",
                 regex.getText(LETTERS_NO_DIGITS + DIGITS + NON_LETTERS + SPACE), equalTo(LETTERS_NO_DIGITS + DIGITS));
 
@@ -35,8 +36,8 @@ public void testWordChar() throws Exception {
     public void testNonWordChar() throws Exception {
         VerbalExpression regex = regex().nonWordChar().build();
 
-        assertThat("matches on letters", regex.test(LETTERS_NO_DIGITS + DIGITS), is(false));
-        assertThat("Not matches on non letters", regex.test(NON_LETTERS + SPACE), is(true));
+        assertThat("matches on letters", regex, not(matchesTo((LETTERS_NO_DIGITS + DIGITS))));
+        assertThat("Not matches on non letters", regex, matchesTo(NON_LETTERS + SPACE));
         assertThat("Extracts wrong chars",
                 regex.getText(LETTERS_NO_DIGITS + DIGITS + NON_LETTERS + SPACE), equalTo(NON_LETTERS + SPACE));
 
@@ -46,8 +47,8 @@ public void testNonWordChar() throws Exception {
     public void testSpace() throws Exception {
         VerbalExpression regex = regex().space().build();
 
-        assertThat("matches on letters", regex.test(LETTERS_NO_DIGITS + DIGITS + NON_LETTERS), is(false));
-        assertThat("Not matches on space", regex.test(SPACE), is(true));
+        assertThat("matches on letters", regex, not(matchesTo((LETTERS_NO_DIGITS + DIGITS + NON_LETTERS))));
+        assertThat("Not matches on space", regex, matchesTo(SPACE));
         assertThat("Extracts wrong chars",
                 regex.getText(LETTERS_NO_DIGITS + DIGITS + NON_LETTERS + SPACE), equalTo(SPACE));
 
@@ -57,8 +58,8 @@ public void testSpace() throws Exception {
     public void testNonSpace() throws Exception {
         VerbalExpression regex = regex().nonSpace().build();
 
-        assertThat("Not matches on non space", regex.test(LETTERS_NO_DIGITS + DIGITS + NON_LETTERS), is(true));
-        assertThat("matches on space", regex.test(SPACE), is(false));
+        assertThat("Not matches on non space", regex, matchesTo(LETTERS_NO_DIGITS + DIGITS + NON_LETTERS));
+        assertThat("matches on space", regex, not(matchesTo((SPACE))));
         assertThat("Extracts wrong chars",
                 regex.getText(LETTERS_NO_DIGITS + DIGITS + NON_LETTERS + SPACE), not(SPACE));
 
@@ -68,8 +69,8 @@ public void testNonSpace() throws Exception {
     public void testDigit() throws Exception {
         VerbalExpression regex = regex().digit().build();
 
-        assertThat("matches on letters", regex.test(LETTERS_NO_DIGITS + SPACE + NON_LETTERS), is(false));
-        assertThat("Not matches on digits", regex.test(DIGITS), is(true));
+        assertThat("matches on letters", regex, not(matchesTo((LETTERS_NO_DIGITS + SPACE + NON_LETTERS))));
+        assertThat("Not matches on digits", regex, matchesTo(DIGITS));
         assertThat("Extracts wrong chars",
                 regex.getText(LETTERS_NO_DIGITS + DIGITS + NON_LETTERS + SPACE), is(DIGITS));
 
@@ -79,8 +80,8 @@ public void testDigit() throws Exception {
     public void testNonDigit() throws Exception {
         VerbalExpression regex = regex().nonDigit().build();
 
-        assertThat("Not matches on letters", regex.test(LETTERS_NO_DIGITS + SPACE + NON_LETTERS), is(true));
-        assertThat("matches on digits", regex.test(DIGITS), is(false));
+        assertThat("Not matches on letters", regex, matchesTo(LETTERS_NO_DIGITS + SPACE + NON_LETTERS));
+        assertThat("matches on digits", regex, not(matchesTo((DIGITS))));
         assertThat("Extracts wrong chars",
                 regex.getText(LETTERS_NO_DIGITS + DIGITS + NON_LETTERS + SPACE), not(DIGITS));
 
@@ -90,8 +91,8 @@ public void testNonDigit() throws Exception {
     public void testWord() throws Exception {
         VerbalExpression regex = regex().word().build();
 
-        assertThat("not matches on word", regex.test(LETTERS_NO_DIGITS + DIGITS), is(true));
-        assertThat("matches on space and non letters", regex.test(SPACE + NON_LETTERS), is(false));
+        assertThat("not matches on word", regex, matchesTo(LETTERS_NO_DIGITS + DIGITS));
+        assertThat("matches on space and non letters", regex, not(matchesTo(SPACE + NON_LETTERS)));
         assertThat("extracts wrong chars",
                 regex.getText(LETTERS_NO_DIGITS + DIGITS + NON_LETTERS + SPACE), is(LETTERS_NO_DIGITS + DIGITS));