This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-text.git
The following commit(s) were added to refs/heads/master by this push:
new b64446f Add
org.apache.commons.text.matcher.StringMatcherFactory.andMatcher(StringMatcher...).
b64446f is described below
commit b64446fcb3b8fcd8292129415281fd6348cbece3
Author: Gary Gregory <garydgreg...@gmail.com>
AuthorDate: Mon Jul 13 15:53:13 2020 -0400
Add
org.apache.commons.text.matcher.StringMatcherFactory.andMatcher(StringMatcher...).
---
src/changes/changes.xml | 1 +
.../text/matcher/AbstractStringMatcher.java | 283 ++++++++++-------
.../apache/commons/text/matcher/StringMatcher.java | 19 +-
.../commons/text/matcher/StringMatcherFactory.java | 38 ++-
.../text/matcher/StringMatcherFactoryTest.java | 6 +
.../text/matcher/StringMatcherOnCharArrayTest.java | 337 +++++++++++----------
.../StringMatcherOnCharSequenceStringTest.java | 337 +++++++++++----------
.../text/matcher/StringSubstitutorGetSetTest.java | 16 +-
8 files changed, 588 insertions(+), 449 deletions(-)
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index 427e475..ecb8286 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -58,6 +58,7 @@ The <action> type attribute can be add,update,fix,remove.
<action type="add" dev="ggregory" due-to="Gary
Gregory">Add
org.apache.commons.text.matcher.StringMatcher.isMatch(CharSequence,
int).</action>
<action type="add" dev="ggregory" due-to="Gary
Gregory">Add
org.apache.commons.text.matcher.StringMatcher.isMatch(CharSequence, int, int,
int).</action>
<action type="add" dev="ggregory" due-to="Gary
Gregory">Add
org.apache.commons.text.matcher.StringMatcherFactory.stringMatcher(char...).</action>
+ <action type="add" dev="ggregory" due-to="Gary
Gregory">Add
org.apache.commons.text.matcher.StringMatcherFactory.andMatcher(StringMatcher...).</action>
<action type="add" dev="ggregory" due-to="Gary
Gregory">Add org.apache.commons.text.TextStringBuilder.toString(int,
int).</action>
<action type="add" dev="ggregory" due-to="Gary
Gregory">Add org.apache.commons.text.TextStringBuilder.readFrom(Reader,
int).</action>
<action type="add" dev="ggregory" due-to="Gary
Gregory">Add
org.apache.commons.text.TextStringBuilder.charAtDelete(int).</action>
diff --git
a/src/main/java/org/apache/commons/text/matcher/AbstractStringMatcher.java
b/src/main/java/org/apache/commons/text/matcher/AbstractStringMatcher.java
index 18419d7..17457b9 100644
--- a/src/main/java/org/apache/commons/text/matcher/AbstractStringMatcher.java
+++ b/src/main/java/org/apache/commons/text/matcher/AbstractStringMatcher.java
@@ -33,7 +33,181 @@ import org.apache.commons.lang3.StringUtils;
abstract class AbstractStringMatcher implements StringMatcher {
/**
- * Class used to define a character for matching purposes.
+ * Matches all of the given matchers in order.
+ *
+ * @since 1.9
+ */
+ static final class AndStringMatcher extends AbstractStringMatcher {
+
+ /**
+ * Matchers in order.
+ */
+ private final StringMatcher[] stringMatchers;
+
+ /**
+ * Constructs a new initialized instance.
+ *
+ * @param stringMatchers Matchers in order.
+ */
+ AndStringMatcher(StringMatcher... stringMatchers) {
+ this.stringMatchers = stringMatchers;
+ }
+
+ @Override
+ public int isMatch(char[] buffer, int start, int bufferStart, int
bufferEnd) {
+ int total = 0;
+ if (stringMatchers != null) {
+ int curStart = start;
+ for (StringMatcher stringMatcher : stringMatchers) {
+ if (stringMatcher != null) {
+ int len = stringMatcher.isMatch(buffer, curStart,
bufferStart, bufferEnd);
+ if (len == 0) {
+ return 0;
+ }
+ total += len;
+ curStart += len;
+ }
+ }
+ }
+ return total;
+ }
+
+ @Override
+ public int isMatch(CharSequence buffer, int start, int bufferStart,
int bufferEnd) {
+ int total = 0;
+ if (stringMatchers != null) {
+ int curStart = start;
+ for (StringMatcher stringMatcher : stringMatchers) {
+ if (stringMatcher != null) {
+ int len = stringMatcher.isMatch(buffer, curStart,
bufferStart, bufferEnd);
+ if (len == 0) {
+ return 0;
+ }
+ total += len;
+ curStart += len;
+ }
+ }
+ }
+ return total;
+ }
+
+ @Override
+ public int size() {
+ int total = 0;
+ if (stringMatchers != null) {
+ for (StringMatcher stringMatcher : stringMatchers) {
+ if (stringMatcher != null) {
+ total += stringMatcher.size();
+ }
+ }
+ }
+ return total;
+ }
+ }
+
+ /**
+ * Matches out of a set of characters.
+ * <p>
+ * Thread=safe.
+ * </p>
+ */
+ static final class CharArrayMatcher extends AbstractStringMatcher {
+
+ /** The string to match, as a character array, implementation treats
as immutable. */
+ private final char[] chars;
+
+ /** The string to match. */
+ private final String string;
+
+ /**
+ * Constructs a matcher from a String.
+ *
+ * @param str the string to match, must not be null
+ */
+ CharArrayMatcher(final char... chars) {
+ super();
+ this.string = String.valueOf(chars);
+ this.chars = chars.clone();
+ }
+
+ /**
+ * Constructs a matcher from a String.
+ *
+ * @param str the string to match, must not be null
+ */
+ CharArrayMatcher(final String string) {
+ super();
+ this.string = string;
+ this.chars = string.toCharArray();
+ }
+
+ /**
+ * Returns the number of matching characters, {@code 0} if there is no
match.
+ *
+ * @param buffer the text content to match against, do not change
+ * @param start the starting position for the match, valid for buffer
+ * @param bufferStart unused
+ * @param bufferEnd the end index of the active buffer, valid for
buffer
+ * @return The number of matching characters, zero for no match
+ */
+ @Override
+ public int isMatch(final char[] buffer, final int start, final int
bufferStart, final int bufferEnd) {
+ final int len = size();
+ if (start + len > bufferEnd) {
+ return 0;
+ }
+ int j = start;
+ for (int i = 0; i < len; i++, j++) {
+ if (chars[i] != buffer[j]) {
+ return 0;
+ }
+ }
+ return len;
+ }
+
+ /**
+ * Returns the number of matching characters, {@code 0} if there is no
match.
+ *
+ * @param buffer the text content to match against, do not change
+ * @param start the starting position for the match, valid for buffer
+ * @param bufferStart unused
+ * @param bufferEnd the end index of the active buffer, valid for
buffer
+ * @return The number of matching characters, zero for no match
+ */
+ @Override
+ public int isMatch(final CharSequence buffer, final int start, final
int bufferStart, final int bufferEnd) {
+ final int len = size();
+ if (start + len > bufferEnd) {
+ return 0;
+ }
+ int j = start;
+ for (int i = 0; i < len; i++, j++) {
+ if (chars[i] != buffer.charAt(j)) {
+ return 0;
+ }
+ }
+ return len;
+ }
+
+ /**
+ * Returns the size of the string to match given in the constructor.
+ *
+ * @since 1.9
+ */
+ @Override
+ public int size() {
+ return chars.length;
+ }
+
+ @Override
+ public String toString() {
+ return super.toString() + "[\"" + string + "\"]";
+ }
+
+ }
+
+ /**
+ * Matches a character.
* <p>
* Thread=safe.
* </p>
@@ -98,7 +272,7 @@ abstract class AbstractStringMatcher implements
StringMatcher {
}
/**
- * Class used to define a set of characters for matching purposes.
+ * Matches a set of characters.
* <p>
* Thread=safe.
* </p>
@@ -165,7 +339,7 @@ abstract class AbstractStringMatcher implements
StringMatcher {
}
/**
- * Class used to match no characters.
+ * Matches nothing.
* <p>
* Thread=safe.
* </p>
@@ -220,108 +394,7 @@ abstract class AbstractStringMatcher implements
StringMatcher {
}
/**
- * Class used to define a set of characters for matching purposes.
- * <p>
- * Thread=safe.
- * </p>
- */
- static final class StringMatcher extends AbstractStringMatcher {
-
- /** The string to match, as a character array, implementation treats
as immutable. */
- private final char[] chars;
-
- /** The string to match. */
- private final String string;
-
- /**
- * Constructs a matcher from a String.
- *
- * @param str the string to match, must not be null
- */
- StringMatcher(final char... chars) {
- super();
- this.string = String.valueOf(chars);
- this.chars = chars.clone();
- }
-
- /**
- * Constructs a matcher from a String.
- *
- * @param str the string to match, must not be null
- */
- StringMatcher(final String string) {
- super();
- this.string = string;
- this.chars = string.toCharArray();
- }
-
- /**
- * Returns the number of matching characters, {@code 0} if there is no
match.
- *
- * @param buffer the text content to match against, do not change
- * @param start the starting position for the match, valid for buffer
- * @param bufferStart unused
- * @param bufferEnd the end index of the active buffer, valid for
buffer
- * @return The number of matching characters, zero for no match
- */
- @Override
- public int isMatch(final char[] buffer, final int start, final int
bufferStart, final int bufferEnd) {
- final int len = size();
- if (start + len > bufferEnd) {
- return 0;
- }
- int j = start;
- for (int i = 0; i < len; i++, j++) {
- if (chars[i] != buffer[j]) {
- return 0;
- }
- }
- return len;
- }
-
- /**
- * Returns the number of matching characters, {@code 0} if there is no
match.
- *
- * @param buffer the text content to match against, do not change
- * @param start the starting position for the match, valid for buffer
- * @param bufferStart unused
- * @param bufferEnd the end index of the active buffer, valid for
buffer
- * @return The number of matching characters, zero for no match
- */
- @Override
- public int isMatch(final CharSequence buffer, final int start, final
int bufferStart, final int bufferEnd) {
- final int len = size();
- if (start + len > bufferEnd) {
- return 0;
- }
- int j = start;
- for (int i = 0; i < len; i++, j++) {
- if (chars[i] != buffer.charAt(j)) {
- return 0;
- }
- }
- return len;
- }
-
- /**
- * Returns the size of the string to match given in the constructor.
- *
- * @since 1.9
- */
- @Override
- public int size() {
- return chars.length;
- }
-
- @Override
- public String toString() {
- return super.toString() + "[\"" + string + "\"]";
- }
-
- }
-
- /**
- * Class used to match whitespace as per trim().
+ * Matches whitespace as per trim().
* <p>
* Thread=safe.
* </p>
diff --git a/src/main/java/org/apache/commons/text/matcher/StringMatcher.java
b/src/main/java/org/apache/commons/text/matcher/StringMatcher.java
index 61b7055..3dc14cf 100644
--- a/src/main/java/org/apache/commons/text/matcher/StringMatcher.java
+++ b/src/main/java/org/apache/commons/text/matcher/StringMatcher.java
@@ -25,6 +25,17 @@ package org.apache.commons.text.matcher;
public interface StringMatcher {
/**
+ * Returns a matcher that matches this matcher followed by the given
matcher.
+ *
+ * @param stringMatcher the next matcher.
+ * @return a matcher that matches this matcher followed by the given
matcher.
+ * @since 1.9
+ */
+ default StringMatcher andThen(StringMatcher stringMatcher) {
+ return StringMatcherFactory.INSTANCE.andMatcher(this, stringMatcher);
+ }
+
+ /**
* Returns the number of matching characters, zero for no match.
* <p>
* This method is called to check for a match. The parameter {@code pos}
represents the current position to be
@@ -53,8 +64,8 @@ public interface StringMatcher {
* Returns the number of matching characters, {@code 0} if there is no
match.
* <p>
* This method is called to check for a match against a source {@code
buffer}. The parameter {@code start}
- * represents the start position to be checked in the {@code buffer} (a
character array which MUST not be
- * changed). The implementation SHOULD guarantees that {@code start} is a
valid index in {@code buffer}.
+ * represents the start position to be checked in the {@code buffer} (a
character array which MUST not be changed).
+ * The implementation SHOULD guarantees that {@code start} is a valid
index in {@code buffer}.
* </p>
* <p>
* The character array may be larger than the active area to be matched.
Only values in the buffer between the
@@ -106,8 +117,8 @@ public interface StringMatcher {
* Returns the number of matching characters, {@code 0} if there is no
match.
* <p>
* This method is called to check for a match against a source {@code
buffer}. The parameter {@code start}
- * represents the start position to be checked in the {@code buffer} (a
character array which MUST not be
- * changed). The implementation SHOULD guarantees that {@code start} is a
valid index in {@code buffer}.
+ * represents the start position to be checked in the {@code buffer} (a
character array which MUST not be changed).
+ * The implementation SHOULD guarantees that {@code start} is a valid
index in {@code buffer}.
* </p>
* <p>
* The character array may be larger than the active area to be matched.
Only values in the buffer between the
diff --git
a/src/main/java/org/apache/commons/text/matcher/StringMatcherFactory.java
b/src/main/java/org/apache/commons/text/matcher/StringMatcherFactory.java
index 8e66281..75222de 100644
--- a/src/main/java/org/apache/commons/text/matcher/StringMatcherFactory.java
+++ b/src/main/java/org/apache/commons/text/matcher/StringMatcherFactory.java
@@ -36,7 +36,7 @@ public final class StringMatcherFactory {
* Matches the double quote character.
*/
private static final AbstractStringMatcher.CharMatcher
DOUBLE_QUOTE_MATCHER = new AbstractStringMatcher.CharMatcher(
- '"');
+ '"');
/**
* Defines the singleton for this class.
@@ -52,13 +52,13 @@ public final class StringMatcherFactory {
* Matches the single or double quote character.
*/
private static final AbstractStringMatcher.CharSetMatcher QUOTE_MATCHER =
new AbstractStringMatcher.CharSetMatcher(
- "'\"".toCharArray());
+ "'\"".toCharArray());
/**
* Matches the double quote character.
*/
private static final AbstractStringMatcher.CharMatcher
SINGLE_QUOTE_MATCHER = new AbstractStringMatcher.CharMatcher(
- '\'');
+ '\'');
/**
* Matches the space character.
@@ -69,7 +69,7 @@ public final class StringMatcherFactory {
* Matches the same characters as StringTokenizer, namely space, tab,
newline, form feed.
*/
private static final AbstractStringMatcher.CharSetMatcher SPLIT_MATCHER =
new AbstractStringMatcher.CharSetMatcher(
- " \t\n\r\f".toCharArray());
+ " \t\n\r\f".toCharArray());
/**
* Matches the tab character.
@@ -89,10 +89,20 @@ public final class StringMatcherFactory {
}
/**
+ * Creates a matcher that matches all of the given matchers in order.
+ *
+ * @param stringMatchers the matcher
+ * @return a matcher that matches all of the given matchers in order.
+ * @since 1.9
+ */
+ public StringMatcher andMatcher(StringMatcher... stringMatchers) {
+ return new AbstractStringMatcher.AndStringMatcher(stringMatchers);
+ }
+
+ /**
* Constructor that creates a matcher from a character.
*
- * @param ch
- * the character to match, must not be null
+ * @param ch the character to match, must not be null
* @return a new Matcher for the given char
*/
public StringMatcher charMatcher(final char ch) {
@@ -102,8 +112,7 @@ public final class StringMatcherFactory {
/**
* Constructor that creates a matcher from a set of characters.
*
- * @param chars
- * the characters to match, null or empty matches nothing
+ * @param chars the characters to match, null or empty matches nothing
* @return a new matcher for the given char[]
*/
public StringMatcher charSetMatcher(final char... chars) {
@@ -119,8 +128,7 @@ public final class StringMatcherFactory {
/**
* Creates a matcher from a string representing a set of characters.
*
- * @param chars
- * the characters to match, null or empty matches nothing
+ * @param chars the characters to match, null or empty matches nothing
* @return a new Matcher for the given characters
*/
public StringMatcher charSetMatcher(final String chars) {
@@ -199,24 +207,22 @@ public final class StringMatcherFactory {
/**
* Creates a matcher from a string.
*
- * @param chars
- * the string to match, null or empty matches nothing
+ * @param chars the string to match, null or empty matches nothing
* @return a new Matcher for the given String
* @since 1.9
*/
public StringMatcher stringMatcher(final char... chars) {
- return ArrayUtils.isEmpty(chars) ? NONE_MATCHER : new
AbstractStringMatcher.StringMatcher(chars);
+ return ArrayUtils.isEmpty(chars) ? NONE_MATCHER : new
AbstractStringMatcher.CharArrayMatcher(chars);
}
/**
* Creates a matcher from a string.
*
- * @param str
- * the string to match, null or empty matches nothing
+ * @param str the string to match, null or empty matches nothing
* @return a new Matcher for the given String
*/
public StringMatcher stringMatcher(final String str) {
- return StringUtils.isEmpty(str) ? NONE_MATCHER : new
AbstractStringMatcher.StringMatcher(str);
+ return StringUtils.isEmpty(str) ? NONE_MATCHER : new
AbstractStringMatcher.CharArrayMatcher(str);
}
/**
diff --git
a/src/test/java/org/apache/commons/text/matcher/StringMatcherFactoryTest.java
b/src/test/java/org/apache/commons/text/matcher/StringMatcherFactoryTest.java
index 2da69f2..58bb279 100644
---
a/src/test/java/org/apache/commons/text/matcher/StringMatcherFactoryTest.java
+++
b/src/test/java/org/apache/commons/text/matcher/StringMatcherFactoryTest.java
@@ -27,6 +27,12 @@ import org.junit.jupiter.api.Test;
public class StringMatcherFactoryTest {
@Test
+ public void test_andMatcher() {
+
assertNotNull(StringMatcherFactory.INSTANCE.andMatcher(StringMatcherFactory.INSTANCE.charMatcher('1'),
+ StringMatcherFactory.INSTANCE.stringMatcher("2")));
+ }
+
+ @Test
public void test_charMatcher() {
assertNotNull(StringMatcherFactory.INSTANCE.charMatcher('1'));
}
diff --git
a/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharArrayTest.java
b/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharArrayTest.java
index 71a6f37..750acaa 100644
---
a/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharArrayTest.java
+++
b/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharArrayTest.java
@@ -26,30 +26,51 @@ import org.junit.jupiter.api.Test;
*/
public class StringMatcherOnCharArrayTest {
- private static final char[] BUFFER1 = "0,1\t2
3\n\r\f\u0000'\"".toCharArray();
+ private static final char[] INPUT1 = "0,1\t2
3\n\r\f\u0000'\"".toCharArray();
- private static final char[] BUFFER2 = "abcdef".toCharArray();
+ private static final char[] INPUT2 = "abcdef".toCharArray();
- private static final int BUFFER2_LENGTH = BUFFER2.length;
+ private static final int INPUT2_LENGTH = INPUT2.length;
+
+ @Test
+ public void testAndMatcher_char() {
+ final StringMatcher matcher = StringMatcherFactory.INSTANCE.andMatcher(
+ StringMatcherFactory.INSTANCE.charMatcher('c'),
StringMatcherFactory.INSTANCE.stringMatcher("de"));
+ assertEquals(3, matcher.size());
+ //
+ assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(3);
+ assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
+ //
+ assertThat(matcher.isMatch(INPUT2, 0)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(3);
+ assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
+ }
@Test
public void testCharMatcher_char() {
final StringMatcher matcher =
StringMatcherFactory.INSTANCE.charMatcher('c');
assertEquals(1, matcher.size());
//
- assertThat(matcher.isMatch(BUFFER2, 0, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 1, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 2, 0,
BUFFER2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 3, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 4, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 5, 0,
BUFFER2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
//
- 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);
+ assertThat(matcher.isMatch(INPUT2, 0)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
}
@Test
@@ -57,26 +78,26 @@ public class StringMatcherOnCharArrayTest {
final StringMatcher matcher =
StringMatcherFactory.INSTANCE.charSetMatcher("ace".toCharArray());
assertEquals(1, matcher.size());
//
- assertThat(matcher.isMatch(BUFFER2, 0, 0,
BUFFER2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 1, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 2, 0,
BUFFER2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 3, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 4, 0,
BUFFER2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 5, 0,
BUFFER2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
//
- 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(matcher.isMatch(INPUT2, 0)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
//
assertThat(StringMatcherFactory.INSTANCE.charSetMatcher())
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
+ .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
assertThat(StringMatcherFactory.INSTANCE.charSetMatcher((char[]) null))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
+ .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
assertThat(StringMatcherFactory.INSTANCE
- .charSetMatcher("a".toCharArray()) instanceof
AbstractStringMatcher.CharMatcher).isTrue();
+ .charSetMatcher("a".toCharArray()) instanceof
AbstractStringMatcher.CharMatcher).isTrue();
}
@Test
@@ -84,26 +105,26 @@ public class StringMatcherOnCharArrayTest {
final StringMatcher matcher =
StringMatcherFactory.INSTANCE.charSetMatcher("ace");
assertEquals(1, matcher.size());
//
- assertThat(matcher.isMatch(BUFFER2, 0, 0,
BUFFER2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 1, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 2, 0,
BUFFER2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 3, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 4, 0,
BUFFER2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 5, 0,
BUFFER2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
//
- 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(matcher.isMatch(INPUT2, 0)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
//
assertThat(StringMatcherFactory.INSTANCE.charSetMatcher(""))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
+ .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
assertThat(StringMatcherFactory.INSTANCE.charSetMatcher((String) null))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
+ .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
assertThat(StringMatcherFactory.INSTANCE.charSetMatcher("a")
instanceof AbstractStringMatcher.CharMatcher)
- .isTrue();
+ .isTrue();
}
@Test
@@ -112,13 +133,13 @@ public class StringMatcherOnCharArrayTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.commaMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 0, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 1, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 2, 0,
BUFFER1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 0, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 1, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length)).isEqualTo(0);
//
- assertThat(matcher.isMatch(BUFFER1, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 1)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 2)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 0)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 1)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
}
@Test
@@ -127,11 +148,11 @@ public class StringMatcherOnCharArrayTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.doubleQuoteMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 11, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 12, 0,
BUFFER1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 11, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 12, 0, INPUT1.length)).isEqualTo(1);
//
- assertThat(matcher.isMatch(BUFFER1, 11)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(1);
}
@Test
@@ -141,9 +162,9 @@ public class StringMatcherOnCharArrayTest {
// the concern of StringMatcher, and are not bugs
final StringMatcher matcher =
StringMatcherFactory.INSTANCE.stringMatcher("bc");
assertEquals(2, matcher.size());
- assertThat(matcher.isMatch(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);
+ assertThat(matcher.isMatch(INPUT2, 1, 1, INPUT2_LENGTH)).isEqualTo(2);
+ assertThat(matcher.isMatch(INPUT2, 1, 0, 3)).isEqualTo(2);
+ assertThat(matcher.isMatch(INPUT2, 1, 0, 2)).isEqualTo(0);
}
@Test
@@ -152,33 +173,33 @@ public class StringMatcherOnCharArrayTest {
assertEquals(0, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.noneMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 0, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 1, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 2, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 3, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 4, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 5, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 6, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 7, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 8, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 9, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 10, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 11, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 12, 0,
BUFFER1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 0, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 1, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 6, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 7, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 8, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 9, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 11, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 12, 0, INPUT1.length)).isEqualTo(0);
//
- 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);
+ assertThat(matcher.isMatch(INPUT1, 0)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 1)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 7)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 8)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 9)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(0);
}
@Test
@@ -187,13 +208,13 @@ public class StringMatcherOnCharArrayTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.quoteMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 10, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 11, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 12, 0,
BUFFER1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 11, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 12, 0, INPUT1.length)).isEqualTo(1);
//
- assertThat(matcher.isMatch(BUFFER1, 10)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 11)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(1);
}
@Test
@@ -202,13 +223,13 @@ public class StringMatcherOnCharArrayTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.singleQuoteMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 10, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 11, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 12, 0,
BUFFER1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 11, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 12, 0, INPUT1.length)).isEqualTo(0);
//
- assertThat(matcher.isMatch(BUFFER1, 10)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 11)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(0);
}
@Test
@@ -217,13 +238,13 @@ public class StringMatcherOnCharArrayTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.spaceMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 4, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 5, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 6, 0,
BUFFER1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 6, 0, INPUT1.length)).isEqualTo(0);
//
- assertThat(matcher.isMatch(BUFFER1, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 5)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 6)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
}
@Test
@@ -232,48 +253,48 @@ public class StringMatcherOnCharArrayTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.splitMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 2, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 3, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 4, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 5, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 6, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 7, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 8, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 9, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 10, 0,
BUFFER1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 6, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 7, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 8, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 9, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length)).isEqualTo(0);
//
- 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);
+ assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 7)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 8)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 9)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
}
private void testStringMatcher_String(final StringMatcher matcher) {
assertEquals(2, matcher.size());
//
- assertThat(matcher.isMatch(BUFFER2, 0, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 1, 0,
BUFFER2_LENGTH)).isEqualTo(2);
- assertThat(matcher.isMatch(BUFFER2, 2, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 3, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 4, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 5, 0,
BUFFER2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(2);
+ assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
//
- 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(matcher.isMatch(INPUT2, 0)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(2);
+ assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
//
assertThat(StringMatcherFactory.INSTANCE.stringMatcher(""))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
+ .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
assertThat(StringMatcherFactory.INSTANCE.stringMatcher((String) null))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
+ .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
}
@Test
@@ -294,13 +315,13 @@ public class StringMatcherOnCharArrayTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.tabMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 2, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 3, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 4, 0,
BUFFER1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length)).isEqualTo(0);
//
- assertThat(matcher.isMatch(BUFFER1, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 3)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
}
@Test
@@ -309,25 +330,25 @@ public class StringMatcherOnCharArrayTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.trimMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 2, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 3, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 4, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 5, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 6, 0,
BUFFER1.length)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 7, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 8, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 9, 0,
BUFFER1.length)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 10, 0,
BUFFER1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 2, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 4, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 6, 0, INPUT1.length)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 7, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 8, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 9, 0, INPUT1.length)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 10, 0, INPUT1.length)).isEqualTo(1);
//
- 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);
+ assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 7)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 8)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 9)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(1);
}
}
diff --git
a/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharSequenceStringTest.java
b/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharSequenceStringTest.java
index 31b350f..de89159 100644
---
a/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharSequenceStringTest.java
+++
b/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharSequenceStringTest.java
@@ -26,30 +26,51 @@ import org.junit.jupiter.api.Test;
*/
public class StringMatcherOnCharSequenceStringTest {
- private static final String BUFFER1 = "0,1\t2 3\n\r\f\u0000'\"";
+ private static final String INPUT1 = "0,1\t2 3\n\r\f\u0000'\"";
- private static final String BUFFER2 = "abcdef";
+ private static final String INPUT2 = "abcdef";
- private static final int BUFFER2_LENGTH = BUFFER2.length();
+ private static final int INPUT2_LENGTH = INPUT2.length();
+
+ @Test
+ public void testAndMatcher_char() {
+ final StringMatcher matcher = StringMatcherFactory.INSTANCE.andMatcher(
+ StringMatcherFactory.INSTANCE.charMatcher('c'),
StringMatcherFactory.INSTANCE.stringMatcher("de"));
+ assertEquals(3, matcher.size());
+ //
+ assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(3);
+ assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
+ //
+ assertThat(matcher.isMatch(INPUT2, 0)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(3);
+ assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
+ }
@Test
public void testCharMatcher_char() {
final StringMatcher matcher =
StringMatcherFactory.INSTANCE.charMatcher('c');
assertEquals(1, matcher.size());
//
- assertThat(matcher.isMatch(BUFFER2, 0, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 1, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 2, 0,
BUFFER2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 3, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 4, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 5, 0,
BUFFER2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
//
- 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);
+ assertThat(matcher.isMatch(INPUT2, 0)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
}
@Test
@@ -57,26 +78,26 @@ public class StringMatcherOnCharSequenceStringTest {
final StringMatcher matcher =
StringMatcherFactory.INSTANCE.charSetMatcher("ace".toCharArray());
assertEquals(1, matcher.size());
//
- assertThat(matcher.isMatch(BUFFER2, 0, 0,
BUFFER2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 1, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 2, 0,
BUFFER2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 3, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 4, 0,
BUFFER2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 5, 0,
BUFFER2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
//
- 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(matcher.isMatch(INPUT2, 0)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
//
assertThat(StringMatcherFactory.INSTANCE.charSetMatcher())
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
+ .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
assertThat(StringMatcherFactory.INSTANCE.charSetMatcher((char[]) null))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
+ .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
assertThat(StringMatcherFactory.INSTANCE
- .charSetMatcher("a".toCharArray()) instanceof
AbstractStringMatcher.CharMatcher).isTrue();
+ .charSetMatcher("a".toCharArray()) instanceof
AbstractStringMatcher.CharMatcher).isTrue();
}
@Test
@@ -84,26 +105,26 @@ public class StringMatcherOnCharSequenceStringTest {
final StringMatcher matcher =
StringMatcherFactory.INSTANCE.charSetMatcher("ace");
assertEquals(1, matcher.size());
//
- assertThat(matcher.isMatch(BUFFER2, 0, 0,
BUFFER2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 1, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 2, 0,
BUFFER2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 3, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 4, 0,
BUFFER2_LENGTH)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER2, 5, 0,
BUFFER2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
//
- 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(matcher.isMatch(INPUT2, 0)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
//
assertThat(StringMatcherFactory.INSTANCE.charSetMatcher(""))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
+ .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
assertThat(StringMatcherFactory.INSTANCE.charSetMatcher((String) null))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
+ .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
assertThat(StringMatcherFactory.INSTANCE.charSetMatcher("a")
instanceof AbstractStringMatcher.CharMatcher)
- .isTrue();
+ .isTrue();
}
@Test
@@ -112,13 +133,13 @@ public class StringMatcherOnCharSequenceStringTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.commaMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 0, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 1, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 2, 0,
BUFFER1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 0, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 1, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 2, 0,
INPUT1.length())).isEqualTo(0);
//
- assertThat(matcher.isMatch(BUFFER1, 0)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 1)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 2)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 0)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 1)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
}
@Test
@@ -127,11 +148,11 @@ public class StringMatcherOnCharSequenceStringTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.doubleQuoteMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 11, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 12, 0,
BUFFER1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 11, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 12, 0,
INPUT1.length())).isEqualTo(1);
//
- assertThat(matcher.isMatch(BUFFER1, 11)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(1);
}
@Test
@@ -141,9 +162,9 @@ public class StringMatcherOnCharSequenceStringTest {
// the concern of StringMatcher, and are not bugs
final StringMatcher matcher =
StringMatcherFactory.INSTANCE.stringMatcher("bc");
assertEquals(2, matcher.size());
- assertThat(matcher.isMatch(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);
+ assertThat(matcher.isMatch(INPUT2, 1, 1, INPUT2_LENGTH)).isEqualTo(2);
+ assertThat(matcher.isMatch(INPUT2, 1, 0, 3)).isEqualTo(2);
+ assertThat(matcher.isMatch(INPUT2, 1, 0, 2)).isEqualTo(0);
}
@Test
@@ -152,33 +173,33 @@ public class StringMatcherOnCharSequenceStringTest {
assertEquals(0, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.noneMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 0, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 1, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 2, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 3, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 4, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 5, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 6, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 7, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 8, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 9, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 10, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 11, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 12, 0,
BUFFER1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 0, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 1, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 2, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 4, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 6, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 7, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 8, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 9, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 10, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 11, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 12, 0,
INPUT1.length())).isEqualTo(0);
//
- 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);
+ assertThat(matcher.isMatch(INPUT1, 0)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 1)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 7)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 8)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 9)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(0);
}
@Test
@@ -187,13 +208,13 @@ public class StringMatcherOnCharSequenceStringTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.quoteMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 10, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 11, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 12, 0,
BUFFER1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 10, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 11, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 12, 0,
INPUT1.length())).isEqualTo(1);
//
- assertThat(matcher.isMatch(BUFFER1, 10)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 11)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(1);
}
@Test
@@ -202,13 +223,13 @@ public class StringMatcherOnCharSequenceStringTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.singleQuoteMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 10, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 11, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 12, 0,
BUFFER1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 10, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 11, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 12, 0,
INPUT1.length())).isEqualTo(0);
//
- assertThat(matcher.isMatch(BUFFER1, 10)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 11)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 11)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 12)).isEqualTo(0);
}
@Test
@@ -217,13 +238,13 @@ public class StringMatcherOnCharSequenceStringTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.spaceMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 4, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 5, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 6, 0,
BUFFER1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 4, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 6, 0,
INPUT1.length())).isEqualTo(0);
//
- assertThat(matcher.isMatch(BUFFER1, 4)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 5)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 6)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
}
@Test
@@ -232,25 +253,25 @@ public class StringMatcherOnCharSequenceStringTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.splitMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 2, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 3, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 4, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 5, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 6, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 7, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 8, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 9, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 10, 0,
BUFFER1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 2, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 4, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 6, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 7, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 8, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 9, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 10, 0,
INPUT1.length())).isEqualTo(0);
//
- 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);
+ assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 7)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 8)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 9)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(0);
}
@Test
@@ -258,24 +279,24 @@ public class StringMatcherOnCharSequenceStringTest {
final StringMatcher matcher =
StringMatcherFactory.INSTANCE.stringMatcher("bc");
assertEquals(2, matcher.size());
//
- assertThat(matcher.isMatch(BUFFER2, 0, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 1, 0,
BUFFER2_LENGTH)).isEqualTo(2);
- assertThat(matcher.isMatch(BUFFER2, 2, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 3, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 4, 0,
BUFFER2_LENGTH)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER2, 5, 0,
BUFFER2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 0, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 1, 0, INPUT2_LENGTH)).isEqualTo(2);
+ assertThat(matcher.isMatch(INPUT2, 2, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 3, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4, 0, INPUT2_LENGTH)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 5, 0, INPUT2_LENGTH)).isEqualTo(0);
//
- 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(matcher.isMatch(INPUT2, 0)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 1)).isEqualTo(2);
+ assertThat(matcher.isMatch(INPUT2, 2)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 3)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT2, 5)).isEqualTo(0);
//
assertThat(StringMatcherFactory.INSTANCE.stringMatcher(""))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
+ .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
assertThat(StringMatcherFactory.INSTANCE.stringMatcher((String) null))
- .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
+ .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
}
// -----------------------------------------------------------------------
@@ -285,13 +306,13 @@ public class StringMatcherOnCharSequenceStringTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.tabMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 2, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 3, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 4, 0,
BUFFER1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 2, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 4, 0,
INPUT1.length())).isEqualTo(0);
//
- assertThat(matcher.isMatch(BUFFER1, 2)).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 3)).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
}
@Test
@@ -300,25 +321,25 @@ public class StringMatcherOnCharSequenceStringTest {
assertEquals(1, matcher.size());
assertThat(StringMatcherFactory.INSTANCE.trimMatcher()).isSameAs(matcher);
//
- assertThat(matcher.isMatch(BUFFER1, 2, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 3, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 4, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 5, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 6, 0,
BUFFER1.length())).isEqualTo(0);
- assertThat(matcher.isMatch(BUFFER1, 7, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 8, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 9, 0,
BUFFER1.length())).isEqualTo(1);
- assertThat(matcher.isMatch(BUFFER1, 10, 0,
BUFFER1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 2, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 4, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 6, 0,
INPUT1.length())).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 7, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 8, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 9, 0,
INPUT1.length())).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 10, 0,
INPUT1.length())).isEqualTo(1);
//
- 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);
+ assertThat(matcher.isMatch(INPUT1, 2)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 3)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 4)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 5)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 6)).isEqualTo(0);
+ assertThat(matcher.isMatch(INPUT1, 7)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 8)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 9)).isEqualTo(1);
+ assertThat(matcher.isMatch(INPUT1, 10)).isEqualTo(1);
}
}
diff --git
a/src/test/java/org/apache/commons/text/matcher/StringSubstitutorGetSetTest.java
b/src/test/java/org/apache/commons/text/matcher/StringSubstitutorGetSetTest.java
index 2009bdf..7be17e9 100644
---
a/src/test/java/org/apache/commons/text/matcher/StringSubstitutorGetSetTest.java
+++
b/src/test/java/org/apache/commons/text/matcher/StringSubstitutorGetSetTest.java
@@ -36,14 +36,14 @@ public class StringSubstitutorGetSetTest {
@Test
public void testGetSetPrefix() {
final StringSubstitutor sub = new StringSubstitutor();
- assertTrue(sub.getVariablePrefixMatcher() instanceof
AbstractStringMatcher.StringMatcher);
+ assertTrue(sub.getVariablePrefixMatcher() instanceof
AbstractStringMatcher.CharArrayMatcher);
sub.setVariablePrefix('<');
assertTrue(sub.getVariablePrefixMatcher() instanceof
AbstractStringMatcher.CharMatcher);
sub.setVariablePrefix("<<");
- assertTrue(sub.getVariablePrefixMatcher() instanceof
AbstractStringMatcher.StringMatcher);
+ assertTrue(sub.getVariablePrefixMatcher() instanceof
AbstractStringMatcher.CharArrayMatcher);
assertThrows(IllegalArgumentException.class, () ->
sub.setVariablePrefix((String) null));
- assertTrue(sub.getVariablePrefixMatcher() instanceof
AbstractStringMatcher.StringMatcher);
+ assertTrue(sub.getVariablePrefixMatcher() instanceof
AbstractStringMatcher.CharArrayMatcher);
final StringMatcher matcher =
StringMatcherFactory.INSTANCE.commaMatcher();
sub.setVariablePrefixMatcher(matcher);
@@ -58,14 +58,14 @@ public class StringSubstitutorGetSetTest {
@Test
public void testGetSetSuffix() {
final StringSubstitutor sub = new StringSubstitutor();
- assertTrue(sub.getVariableSuffixMatcher() instanceof
AbstractStringMatcher.StringMatcher);
+ assertTrue(sub.getVariableSuffixMatcher() instanceof
AbstractStringMatcher.CharArrayMatcher);
sub.setVariableSuffix('<');
assertTrue(sub.getVariableSuffixMatcher() instanceof
AbstractStringMatcher.CharMatcher);
sub.setVariableSuffix("<<");
- assertTrue(sub.getVariableSuffixMatcher() instanceof
AbstractStringMatcher.StringMatcher);
+ assertTrue(sub.getVariableSuffixMatcher() instanceof
AbstractStringMatcher.CharArrayMatcher);
assertThrows(IllegalArgumentException.class, () ->
sub.setVariableSuffix((String) null));
- assertTrue(sub.getVariableSuffixMatcher() instanceof
AbstractStringMatcher.StringMatcher);
+ assertTrue(sub.getVariableSuffixMatcher() instanceof
AbstractStringMatcher.CharArrayMatcher);
final StringMatcher matcher =
StringMatcherFactory.INSTANCE.commaMatcher();
sub.setVariableSuffixMatcher(matcher);
@@ -80,12 +80,12 @@ public class StringSubstitutorGetSetTest {
@Test
public void testGetSetValueDelimiter() {
final StringSubstitutor sub = new StringSubstitutor();
- assertTrue(sub.getValueDelimiterMatcher() instanceof
AbstractStringMatcher.StringMatcher);
+ assertTrue(sub.getValueDelimiterMatcher() instanceof
AbstractStringMatcher.CharArrayMatcher);
sub.setValueDelimiter(':');
assertTrue(sub.getValueDelimiterMatcher() instanceof
AbstractStringMatcher.CharMatcher);
sub.setValueDelimiter("||");
- assertTrue(sub.getValueDelimiterMatcher() instanceof
AbstractStringMatcher.StringMatcher);
+ assertTrue(sub.getValueDelimiterMatcher() instanceof
AbstractStringMatcher.CharArrayMatcher);
sub.setValueDelimiter((String) null);
assertNull(sub.getValueDelimiterMatcher());
