/** * Returns a {@code char} matcher that matches any BMP character not present in the given * character sequence. Returns a bogus matcher if the sequence contains supplementary characters. */ public static CharMatcher noneOf(CharSequence sequence) { return anyOf(sequence).negate(); }
/** * Returns a string containing all matching BMP characters of a character sequence, in order. For * example: * * <pre>{@code * CharMatcher.is('a').retainFrom("bazaar") * }</pre> * * ... returns {@code "aaa"}. */ public String retainFrom(CharSequence sequence) { return negate().removeFrom(sequence); }
String consumeTokenIfPresent(CharMatcher matcher) { checkState(hasMore()); int startPosition = position; position = matcher.negate().indexIn(input, startPosition); return hasMore() ? input.substring(startPosition, position) : input.substring(startPosition); }
private static void assertToStringWorks(String expected, CharMatcher matcher) { assertEquals(expected, matcher.toString()); assertEquals(expected, matcher.precomputed().toString()); assertEquals(expected, matcher.negate().negate().toString()); assertEquals(expected, matcher.negate().precomputed().negate().toString()); assertEquals(expected, matcher.negate().precomputed().negate().precomputed().toString()); } }
private void doTestOneCharMatch(CharMatcher matcher, String s) { reallyTestOneCharMatch(matcher, s); reallyTestOneCharNoMatch(matcher.negate(), s); reallyTestOneCharMatch(matcher.precomputed(), s); reallyTestOneCharNoMatch(matcher.negate().precomputed(), s); reallyTestOneCharNoMatch(matcher.precomputed().negate(), s); }
private void doTestMatchThenNoMatch(CharMatcher matcher, String s) { reallyTestMatchThenNoMatch(matcher, s); reallyTestNoMatchThenMatch(matcher.negate(), s); reallyTestMatchThenNoMatch(matcher.precomputed(), s); reallyTestNoMatchThenMatch(matcher.negate().precomputed(), s); reallyTestNoMatchThenMatch(matcher.precomputed().negate(), s); }
private void doTestOneCharNoMatch(CharMatcher matcher, String s) { reallyTestOneCharNoMatch(matcher, s); reallyTestOneCharMatch(matcher.negate(), s); reallyTestOneCharNoMatch(matcher.precomputed(), s); reallyTestOneCharMatch(matcher.negate().precomputed(), s); reallyTestOneCharMatch(matcher.precomputed().negate(), s); }
private void doTestNoMatchThenMatch(CharMatcher matcher, String s) { reallyTestNoMatchThenMatch(matcher, s); reallyTestMatchThenNoMatch(matcher.negate(), s); reallyTestNoMatchThenMatch(matcher.precomputed(), s); reallyTestMatchThenNoMatch(matcher.negate().precomputed(), s); reallyTestMatchThenNoMatch(matcher.precomputed().negate(), s); }
private void doTestNoMatches(CharMatcher matcher, String s) { reallyTestNoMatches(matcher, s); reallyTestAllMatches(matcher.negate(), s); reallyTestNoMatches(matcher.precomputed(), s); reallyTestAllMatches(matcher.negate().precomputed(), s); reallyTestAllMatches(matcher.precomputed().negate(), s); reallyTestNoMatches(forPredicate(matcher), s); reallyTestNoMatches(matcher, new StringBuilder(s)); }
private void doTestAllMatches(CharMatcher matcher, String s) { reallyTestAllMatches(matcher, s); reallyTestNoMatches(matcher.negate(), s); reallyTestAllMatches(matcher.precomputed(), s); reallyTestNoMatches(matcher.negate().precomputed(), s); reallyTestNoMatches(matcher.precomputed().negate(), s); reallyTestAllMatches(forPredicate(matcher), s); reallyTestAllMatches(matcher, new StringBuilder(s)); }
private void doTestEmpty(CharMatcher matcher) throws Exception { reallyTestEmpty(matcher); reallyTestEmpty(matcher.negate()); reallyTestEmpty(matcher.precomputed()); }
public void testAnyAndNone_logicalOps() throws Exception { // These are testing behavior that's never promised by the API, but since // we're lucky enough that these do pass, it saves us from having to write // more excruciating tests! Hooray! assertSame(CharMatcher.any(), CharMatcher.none().negate()); assertSame(CharMatcher.none(), CharMatcher.any().negate()); assertSame(WHATEVER, CharMatcher.any().and(WHATEVER)); assertSame(CharMatcher.any(), CharMatcher.any().or(WHATEVER)); assertSame(CharMatcher.none(), CharMatcher.none().and(WHATEVER)); assertSame(WHATEVER, CharMatcher.none().or(WHATEVER)); }
private void doTestTrimAndCollapse(String in, String out) { // Try a few different matchers which all match '-' and not 'x' for (char replacement : new char[] {'_', '-'}) { String expected = out.replace('_', replacement); assertEqualsSame(expected, in, is('-').trimAndCollapseFrom(in, replacement)); assertEqualsSame(expected, in, is('-').or(is('#')).trimAndCollapseFrom(in, replacement)); assertEqualsSame(expected, in, isNot('x').trimAndCollapseFrom(in, replacement)); assertEqualsSame(expected, in, is('x').negate().trimAndCollapseFrom(in, replacement)); assertEqualsSame(expected, in, anyOf("-").trimAndCollapseFrom(in, replacement)); assertEqualsSame(expected, in, anyOf("-#").trimAndCollapseFrom(in, replacement)); assertEqualsSame(expected, in, anyOf("-#123").trimAndCollapseFrom(in, replacement)); } }
private void doTestTrimLeadingFrom(String in, String out) { // Try a few different matchers which all match '-' and not 'x' assertEquals(out, is('-').trimLeadingFrom(in)); assertEquals(out, is('-').or(is('#')).trimLeadingFrom(in)); assertEquals(out, isNot('x').trimLeadingFrom(in)); assertEquals(out, is('x').negate().trimLeadingFrom(in)); assertEquals(out, anyOf("-#").trimLeadingFrom(in)); assertEquals(out, anyOf("-#123").trimLeadingFrom(in)); }
private void doTestTrimTrailingFrom(String in, String out) { // Try a few different matchers which all match '-' and not 'x' assertEquals(out, is('-').trimTrailingFrom(in)); assertEquals(out, is('-').or(is('#')).trimTrailingFrom(in)); assertEquals(out, isNot('x').trimTrailingFrom(in)); assertEquals(out, is('x').negate().trimTrailingFrom(in)); assertEquals(out, anyOf("-#").trimTrailingFrom(in)); assertEquals(out, anyOf("-#123").trimTrailingFrom(in)); }
private void doTestCollapse(String in, String out) { // Try a few different matchers which all match '-' and not 'x' // Try replacement chars that both do and do not change the value. for (char replacement : new char[] {'_', '-'}) { String expected = out.replace('_', replacement); assertEqualsSame(expected, in, is('-').collapseFrom(in, replacement)); assertEqualsSame(expected, in, is('-').collapseFrom(in, replacement)); assertEqualsSame(expected, in, is('-').or(is('#')).collapseFrom(in, replacement)); assertEqualsSame(expected, in, isNot('x').collapseFrom(in, replacement)); assertEqualsSame(expected, in, is('x').negate().collapseFrom(in, replacement)); assertEqualsSame(expected, in, anyOf("-").collapseFrom(in, replacement)); assertEqualsSame(expected, in, anyOf("-#").collapseFrom(in, replacement)); assertEqualsSame(expected, in, anyOf("-#123").collapseFrom(in, replacement)); } }
private void doTestTrimFrom(String in, String out) { // Try a few different matchers which all match '-' and not 'x' assertEquals(out, is('-').trimFrom(in)); assertEquals(out, is('-').or(is('#')).trimFrom(in)); assertEquals(out, isNot('x').trimFrom(in)); assertEquals(out, is('x').negate().trimFrom(in)); assertEquals(out, anyOf("-").trimFrom(in)); assertEquals(out, anyOf("-#").trimFrom(in)); assertEquals(out, anyOf("-#123").trimFrom(in)); }
public void testNoMatches() { doTestNoMatches(CharMatcher.none(), "blah"); doTestNoMatches(is('a'), "bcde"); doTestNoMatches(isNot('a'), "aaaa"); doTestNoMatches(anyOf(""), "abcd"); doTestNoMatches(anyOf("x"), "abcd"); doTestNoMatches(anyOf("xy"), "abcd"); doTestNoMatches(anyOf("CharMatcher"), "zxqy"); doTestNoMatches(noneOf("CharMatcher"), "ChMa"); doTestNoMatches(inRange('p', 'x'), "mom"); doTestNoMatches(forPredicate(Predicates.equalTo('c')), "abe"); doTestNoMatches(inRange('A', 'Z').and(inRange('F', 'K').negate()), "F1a"); doTestNoMatches(CharMatcher.digit(), "\tAz()"); doTestNoMatches(CharMatcher.javaDigit(), "\tAz()"); doTestNoMatches(CharMatcher.digit().and(CharMatcher.ascii()), "\tAz()"); doTestNoMatches(CharMatcher.singleWidth(), "\u05bf\u3000"); }
private void doTestCollapseWithNoChange(String inout) { assertSame(inout, is('-').collapseFrom(inout, '_')); assertSame(inout, is('-').or(is('#')).collapseFrom(inout, '_')); assertSame(inout, isNot('x').collapseFrom(inout, '_')); assertSame(inout, is('x').negate().collapseFrom(inout, '_')); assertSame(inout, anyOf("-").collapseFrom(inout, '_')); assertSame(inout, anyOf("-#").collapseFrom(inout, '_')); assertSame(inout, anyOf("-#123").collapseFrom(inout, '_')); assertSame(inout, CharMatcher.none().collapseFrom(inout, '_')); }
@GwtIncompatible // java.util.BitSet public void testSetBits() { doTestSetBits(CharMatcher.any()); doTestSetBits(CharMatcher.none()); doTestSetBits(is('a')); doTestSetBits(isNot('a')); doTestSetBits(anyOf("")); doTestSetBits(anyOf("x")); doTestSetBits(anyOf("xy")); doTestSetBits(anyOf("CharMatcher")); doTestSetBits(noneOf("CharMatcher")); doTestSetBits(inRange('n', 'q')); doTestSetBits(forPredicate(Predicates.equalTo('c'))); doTestSetBits(CharMatcher.ascii()); doTestSetBits(CharMatcher.digit()); doTestSetBits(CharMatcher.invisible()); doTestSetBits(CharMatcher.whitespace()); doTestSetBits(inRange('A', 'Z').and(inRange('F', 'K').negate())); }