/*
* Copyright (C) 2008 The Guava Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.common.base;
import static com.google.common.base.CharMatcher.anyOf;
import static com.google.common.base.CharMatcher.breakingWhitespace;
import static com.google.common.base.CharMatcher.forPredicate;
import static com.google.common.base.CharMatcher.inRange;
import static com.google.common.base.CharMatcher.is;
import static com.google.common.base.CharMatcher.isNot;
import static com.google.common.base.CharMatcher.noneOf;
import static com.google.common.base.CharMatcher.whitespace;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.collect.Sets;
import com.google.common.testing.NullPointerTester;
import java.util.Arrays;
import java.util.BitSet;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
/**
* Unit test for {@link CharMatcher}.
*
* @author Kevin Bourrillion
*/
@GwtCompatible(emulated = true)
public class CharMatcherTest extends TestCase {
@GwtIncompatible // NullPointerTester
public void testStaticNullPointers() throws Exception {
NullPointerTester tester = new NullPointerTester();
tester.testAllPublicStaticMethods(CharMatcher.class);
tester.testAllPublicInstanceMethods(CharMatcher.any());
tester.testAllPublicInstanceMethods(CharMatcher.anyOf("abc"));
}
private static final CharMatcher WHATEVER = new CharMatcher() {
@Override public boolean matches(char c) {
throw new AssertionFailedError(
"You weren't supposed to actually invoke me!");
}
};
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));
}
// The rest of the behavior of ANY and DEFAULT will be covered in the tests for
// the text processing methods below.
public void testWhitespaceBreakingWhitespaceSubset() throws Exception {
for (int c = 0; c <= Character.MAX_VALUE; c++) {
if (breakingWhitespace().matches((char) c)) {
assertTrue(Integer.toHexString(c), whitespace().matches((char) c));
}
}
}
// The next tests require ICU4J and have, at least for now, been sliced out
// of the open-source view of the tests.
@GwtIncompatible // Character.isISOControl
public void testJavaIsoControl() {
for (int c = 0; c <= Character.MAX_VALUE; c++) {
assertEquals("" + c, Character.isISOControl(c),
CharMatcher.javaIsoControl().matches((char) c));
}
}
// Omitting tests for the rest of the JAVA_* constants as these are defined
// as extremely straightforward pass-throughs to the JDK methods.
// We're testing the is(), isNot(), anyOf(), noneOf() and inRange() methods
// below by testing their text-processing methods.
// The organization of this test class is unusual, as it's not done by
// method, but by overall "scenario". Also, the variety of actual tests we
// do borders on absurd overkill. Better safe than sorry, though?
@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()));
}
@GwtIncompatible // java.util.BitSet
private void doTestSetBits(CharMatcher matcher) {
BitSet bitset = new BitSet();
matcher.setBits(bitset);
for (int i = Character.MIN_VALUE; i <= Character.MAX_VALUE; i++) {
assertEquals(matcher.matches((char) i), bitset.get(i));
}
}
public void testEmpty() throws Exception {
doTestEmpty(CharMatcher.any());
doTestEmpty(CharMatcher.none());
doTestEmpty(is('a'));
doTestEmpty(isNot('a'));
doTestEmpty(anyOf(""));
doTestEmpty(anyOf("x"));
doTestEmpty(anyOf("xy"));
doTestEmpty(anyOf("CharMatcher"));
doTestEmpty(noneOf("CharMatcher"));
doTestEmpty(inRange('n', 'q'));
doTestEmpty(forPredicate(Predicates.equalTo('c')));
}
@GwtIncompatible // NullPointerTester
public void testNull() throws Exception {
doTestNull(CharMatcher.any());
doTestNull(CharMatcher.none());
doTestNull(is('a'));
doTestNull(isNot('a'));
doTestNull(anyOf(""));
doTestNull(anyOf("x"));
doTestNull(anyOf("xy"));
doTestNull(anyOf("CharMatcher"));
doTestNull(noneOf("CharMatcher"));
doTestNull(inRange('n', 'q'));
doTestNull(forPredicate(Predicates.equalTo('c')));
}
private void doTestEmpty(CharMatcher matcher) throws Exception {
reallyTestEmpty(matcher);
reallyTestEmpty(matcher.negate());
reallyTestEmpty(matcher.precomputed());
}
private void reallyTestEmpty(CharMatcher matcher) throws Exception {
assertEquals(-1, matcher.indexIn(""));
assertEquals(-1, matcher.indexIn("", 0));
try {
matcher.indexIn("", 1);
fail();
} catch (IndexOutOfBoundsException expected) {
}
try {
matcher.indexIn("", -1);
fail();
} catch (IndexOutOfBoundsException expected) {
}
assertEquals(-1, matcher.lastIndexIn(""));
assertFalse(matcher.matchesAnyOf(""));
assertTrue(matcher.matchesAllOf(""));
assertTrue(matcher.matchesNoneOf(""));
assertEquals("", matcher.removeFrom(""));
assertEquals("", matcher.replaceFrom("", 'z'));
assertEquals("", matcher.replaceFrom("", "ZZ"));
assertEquals("", matcher.trimFrom(""));
assertEquals(0, matcher.countIn(""));
}
@GwtIncompatible // NullPointerTester
private static void doTestNull(CharMatcher matcher) throws Exception {
NullPointerTester tester = new NullPointerTester();
tester.testAllPublicInstanceMethods(matcher);
}
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 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));
}
public void testAllMatches() {
doTestAllMatches(CharMatcher.any(), "blah");
doTestAllMatches(isNot('a'), "bcde");
doTestAllMatches(is('a'), "aaaa");
doTestAllMatches(noneOf("CharMatcher"), "zxqy");
doTestAllMatches(anyOf("x"), "xxxx");
doTestAllMatches(anyOf("xy"), "xyyx");
doTestAllMatches(anyOf("CharMatcher"), "ChMa");
doTestAllMatches(inRange('m', 'p'), "mom");
doTestAllMatches(forPredicate(Predicates.equalTo('c')), "ccc");
doTestAllMatches(CharMatcher.digit(), "0123456789\u0ED0\u1B59");
doTestAllMatches(CharMatcher.javaDigit(), "0123456789");
doTestAllMatches(CharMatcher.digit().and(CharMatcher.ascii()), "0123456789");
doTestAllMatches(CharMatcher.singleWidth(), "\t0123ABCdef~\u00A0\u2111");
}
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 reallyTestNoMatches(CharMatcher matcher, CharSequence s) {
assertFalse(matcher.matches(s.charAt(0)));
assertEquals(-1, matcher.indexIn(s));
assertEquals(-1, matcher.indexIn(s, 0));
assertEquals(-1, matcher.indexIn(s, 1));
assertEquals(-1, matcher.indexIn(s, s.length()));
try {
matcher.indexIn(s, s.length() + 1);
fail();
} catch (IndexOutOfBoundsException expected) {
}
try {
matcher.indexIn(s, -1);
fail();
} catch (IndexOutOfBoundsException expected) {
}
assertEquals(-1, matcher.lastIndexIn(s));
assertFalse(matcher.matchesAnyOf(s));
assertFalse(matcher.matchesAllOf(s));
assertTrue(matcher.matchesNoneOf(s));
assertEquals(s.toString(), matcher.removeFrom(s));
assertEquals(s.toString(), matcher.replaceFrom(s, 'z'));
assertEquals(s.toString(), matcher.replaceFrom(s, "ZZ"));
assertEquals(s.toString(), matcher.trimFrom(s));
assertEquals(0, matcher.countIn(s));
}
private void reallyTestAllMatches(CharMatcher matcher, CharSequence s) {
assertTrue(matcher.matches(s.charAt(0)));
assertEquals(0, matcher.indexIn(s));
assertEquals(0, matcher.indexIn(s, 0));
assertEquals(1, matcher.indexIn(s, 1));
assertEquals(-1, matcher.indexIn(s, s.length()));
assertEquals(s.length() - 1, matcher.lastIndexIn(s));
assertTrue(matcher.matchesAnyOf(s));
assertTrue(matcher.matchesAllOf(s));
assertFalse(matcher.matchesNoneOf(s));
assertEquals("", matcher.removeFrom(s));
assertEquals(Strings.repeat("z", s.length()),
matcher.replaceFrom(s, 'z'));
assertEquals(Strings.repeat("ZZ", s.length()),
matcher.replaceFrom(s, "ZZ"));
assertEquals("", matcher.trimFrom(s));
assertEquals(s.length(), matcher.countIn(s));
}
public void testGeneral() {
doTestGeneral(is('a'), 'a', 'b');
doTestGeneral(isNot('a'), 'b', 'a');
doTestGeneral(anyOf("x"), 'x', 'z');
doTestGeneral(anyOf("xy"), 'y', 'z');
doTestGeneral(anyOf("CharMatcher"), 'C', 'z');
doTestGeneral(noneOf("CharMatcher"), 'z', 'C');
doTestGeneral(inRange('p', 'x'), 'q', 'z');
}
private void doTestGeneral(CharMatcher matcher, char match, char noMatch) {
doTestOneCharMatch(matcher, "" + match);
doTestOneCharNoMatch(matcher, "" + noMatch);
doTestMatchThenNoMatch(matcher, "" + match + noMatch);
doTestNoMatchThenMatch(matcher, "" + noMatch + match);
}
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 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 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 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);
}
@SuppressWarnings("deprecation") // intentionally testing apply() method
private void reallyTestOneCharMatch(CharMatcher matcher, String s) {
assertTrue(matcher.matches(s.charAt(0)));
assertTrue(matcher.apply(s.charAt(0)));
assertEquals(0, matcher.indexIn(s));
assertEquals(0, matcher.indexIn(s, 0));
assertEquals(-1, matcher.indexIn(s, 1));
assertEquals(0, matcher.lastIndexIn(s));
assertTrue(matcher.matchesAnyOf(s));
assertTrue(matcher.matchesAllOf(s));
assertFalse(matcher.matchesNoneOf(s));
assertEquals("", matcher.removeFrom(s));
assertEquals("z", matcher.replaceFrom(s, 'z'));
assertEquals("ZZ", matcher.replaceFrom(s, "ZZ"));
assertEquals("", matcher.trimFrom(s));
assertEquals(1, matcher.countIn(s));
}
@SuppressWarnings("deprecation") // intentionally testing apply() method
private void reallyTestOneCharNoMatch(CharMatcher matcher, String s) {
assertFalse(matcher.matches(s.charAt(0)));
assertFalse(matcher.apply(s.charAt(0)));
assertEquals(-1, matcher.indexIn(s));
assertEquals(-1, matcher.indexIn(s, 0));
assertEquals(-1, matcher.indexIn(s, 1));
assertEquals(-1, matcher.lastIndexIn(s));
assertFalse(matcher.matchesAnyOf(s));
assertFalse(matcher.matchesAllOf(s));
assertTrue(matcher.matchesNoneOf(s));
assertSame(s, matcher.removeFrom(s));
assertSame(s, matcher.replaceFrom(s, 'z'));
assertSame(s, matcher.replaceFrom(s, "ZZ"));
assertSame(s, matcher.trimFrom(s));
assertSame(0, matcher.countIn(s));
}
private void reallyTestMatchThenNoMatch(CharMatcher matcher, String s) {
assertEquals(0, matcher.indexIn(s));
assertEquals(0, matcher.indexIn(s, 0));
assertEquals(-1, matcher.indexIn(s, 1));
assertEquals(-1, matcher.indexIn(s, 2));
assertEquals(0, matcher.lastIndexIn(s));
assertTrue(matcher.matchesAnyOf(s));
assertFalse(matcher.matchesAllOf(s));
assertFalse(matcher.matchesNoneOf(s));
assertEquals(s.substring(1), matcher.removeFrom(s));
assertEquals("z" + s.substring(1), matcher.replaceFrom(s, 'z'));
assertEquals("ZZ" + s.substring(1), matcher.replaceFrom(s, "ZZ"));
assertEquals(s.substring(1), matcher.trimFrom(s));
assertEquals(1, matcher.countIn(s));
}
private void reallyTestNoMatchThenMatch(CharMatcher matcher, String s) {
assertEquals(1, matcher.indexIn(s));
assertEquals(1, matcher.indexIn(s, 0));
assertEquals(1, matcher.indexIn(s, 1));
assertEquals(-1, matcher.indexIn(s, 2));
assertEquals(1, matcher.lastIndexIn(s));
assertTrue(matcher.matchesAnyOf(s));
assertFalse(matcher.matchesAllOf(s));
assertFalse(matcher.matchesNoneOf(s));
assertEquals(s.substring(0, 1), matcher.removeFrom(s));
assertEquals(s.substring(0, 1) + "z", matcher.replaceFrom(s, 'z'));
assertEquals(s.substring(0, 1) + "ZZ", matcher.replaceFrom(s, "ZZ"));
assertEquals(s.substring(0, 1), matcher.trimFrom(s));
assertEquals(1, matcher.countIn(s));
}
/**
* Checks that expected is equals to out, and further, if in is
* equals to expected, then out is successfully optimized to be
* identical to in, i.e. that "in" is simply returned.
*/
private void assertEqualsSame(String expected, String in, String out) {
if (expected.equals(in)) {
assertSame(in, out);
} else {
assertEquals(expected, out);
}
}
// Test collapse() a little differently than the rest, as we really want to
// cover lots of different configurations of input text
public void testCollapse() {
// collapsing groups of '-' into '_' or '-'
doTestCollapse("-", "_");
doTestCollapse("x-", "x_");
doTestCollapse("-x", "_x");
doTestCollapse("--", "_");
doTestCollapse("x--", "x_");
doTestCollapse("--x", "_x");
doTestCollapse("-x-", "_x_");
doTestCollapse("x-x", "x_x");
doTestCollapse("---", "_");
doTestCollapse("--x-", "_x_");
doTestCollapse("--xx", "_xx");
doTestCollapse("-x--", "_x_");
doTestCollapse("-x-x", "_x_x");
doTestCollapse("-xx-", "_xx_");
doTestCollapse("x--x", "x_x");
doTestCollapse("x-x-", "x_x_");
doTestCollapse("x-xx", "x_xx");
doTestCollapse("x-x--xx---x----x", "x_x_xx_x_x");
doTestCollapseWithNoChange("");
doTestCollapseWithNoChange("x");
doTestCollapseWithNoChange("xx");
}
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 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, '_'));
}
public void testCollapse_any() {
assertEquals("", CharMatcher.any().collapseFrom("", '_'));
assertEquals("_", CharMatcher.any().collapseFrom("a", '_'));
assertEquals("_", CharMatcher.any().collapseFrom("ab", '_'));
assertEquals("_", CharMatcher.any().collapseFrom("abcd", '_'));
}
public void testTrimFrom() {
// trimming -
doTestTrimFrom("-", "");
doTestTrimFrom("x-", "x");
doTestTrimFrom("-x", "x");
doTestTrimFrom("--", "");
doTestTrimFrom("x--", "x");
doTestTrimFrom("--x", "x");
doTestTrimFrom("-x-", "x");
doTestTrimFrom("x-x", "x-x");
doTestTrimFrom("---", "");
doTestTrimFrom("--x-", "x");
doTestTrimFrom("--xx", "xx");
doTestTrimFrom("-x--", "x");
doTestTrimFrom("-x-x", "x-x");
doTestTrimFrom("-xx-", "xx");
doTestTrimFrom("x--x", "x--x");
doTestTrimFrom("x-x-", "x-x");
doTestTrimFrom("x-xx", "x-xx");
doTestTrimFrom("x-x--xx---x----x", "x-x--xx---x----x");
// additional testing using the doc example
assertEquals("cat", anyOf("ab").trimFrom("abacatbab"));
}
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 testTrimLeadingFrom() {
// trimming -
doTestTrimLeadingFrom("-", "");
doTestTrimLeadingFrom("x-", "x-");
doTestTrimLeadingFrom("-x", "x");
doTestTrimLeadingFrom("--", "");
doTestTrimLeadingFrom("x--", "x--");
doTestTrimLeadingFrom("--x", "x");
doTestTrimLeadingFrom("-x-", "x-");
doTestTrimLeadingFrom("x-x", "x-x");
doTestTrimLeadingFrom("---", "");
doTestTrimLeadingFrom("--x-", "x-");
doTestTrimLeadingFrom("--xx", "xx");
doTestTrimLeadingFrom("-x--", "x--");
doTestTrimLeadingFrom("-x-x", "x-x");
doTestTrimLeadingFrom("-xx-", "xx-");
doTestTrimLeadingFrom("x--x", "x--x");
doTestTrimLeadingFrom("x-x-", "x-x-");
doTestTrimLeadingFrom("x-xx", "x-xx");
doTestTrimLeadingFrom("x-x--xx---x----x", "x-x--xx---x----x");
// additional testing using the doc example
assertEquals("catbab", anyOf("ab").trimLeadingFrom("abacatbab"));
}
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));
}
public void testTrimTrailingFrom() {
// trimming -
doTestTrimTrailingFrom("-", "");
doTestTrimTrailingFrom("x-", "x");
doTestTrimTrailingFrom("-x", "-x");
doTestTrimTrailingFrom("--", "");
doTestTrimTrailingFrom("x--", "x");
doTestTrimTrailingFrom("--x", "--x");
doTestTrimTrailingFrom("-x-", "-x");
doTestTrimTrailingFrom("x-x", "x-x");
doTestTrimTrailingFrom("---", "");
doTestTrimTrailingFrom("--x-", "--x");
doTestTrimTrailingFrom("--xx", "--xx");
doTestTrimTrailingFrom("-x--", "-x");
doTestTrimTrailingFrom("-x-x", "-x-x");
doTestTrimTrailingFrom("-xx-", "-xx");
doTestTrimTrailingFrom("x--x", "x--x");
doTestTrimTrailingFrom("x-x-", "x-x");
doTestTrimTrailingFrom("x-xx", "x-xx");
doTestTrimTrailingFrom("x-x--xx---x----x", "x-x--xx---x----x");
// additional testing using the doc example
assertEquals("abacat", anyOf("ab").trimTrailingFrom("abacatbab"));
}
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));
}
public void testTrimAndCollapse() {
// collapsing groups of '-' into '_' or '-'
doTestTrimAndCollapse("", "");
doTestTrimAndCollapse("x", "x");
doTestTrimAndCollapse("-", "");
doTestTrimAndCollapse("x-", "x");
doTestTrimAndCollapse("-x", "x");
doTestTrimAndCollapse("--", "");
doTestTrimAndCollapse("x--", "x");
doTestTrimAndCollapse("--x", "x");
doTestTrimAndCollapse("-x-", "x");
doTestTrimAndCollapse("x-x", "x_x");
doTestTrimAndCollapse("---", "");
doTestTrimAndCollapse("--x-", "x");
doTestTrimAndCollapse("--xx", "xx");
doTestTrimAndCollapse("-x--", "x");
doTestTrimAndCollapse("-x-x", "x_x");
doTestTrimAndCollapse("-xx-", "xx");
doTestTrimAndCollapse("x--x", "x_x");
doTestTrimAndCollapse("x-x-", "x_x");
doTestTrimAndCollapse("x-xx", "x_xx");
doTestTrimAndCollapse("x-x--xx---x----x", "x_x_xx_x_x");
}
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));
}
}
public void testReplaceFrom() {
assertEquals("yoho", is('a').replaceFrom("yaha", 'o'));
assertEquals("yh", is('a').replaceFrom("yaha", ""));
assertEquals("yoho", is('a').replaceFrom("yaha", "o"));
assertEquals("yoohoo", is('a').replaceFrom("yaha", "oo"));
assertEquals("12 > 5", is('>').replaceFrom("12 > 5", ">"));
}
public void testPrecomputedOptimizations() {
// These are testing behavior that's never promised by the API.
// Some matchers are so efficient that it is a waste of effort to
// build a precomputed version.
CharMatcher m1 = is('x');
assertSame(m1, m1.precomputed());
assertEquals(m1.toString(), m1.precomputed().toString());
CharMatcher m2 = anyOf("Az");
assertSame(m2, m2.precomputed());
assertEquals(m2.toString(), m2.precomputed().toString());
CharMatcher m3 = inRange('A', 'Z');
assertSame(m3, m3.precomputed());
assertEquals(m3.toString(), m3.precomputed().toString());
assertSame(CharMatcher.none(), CharMatcher.none().precomputed());
assertSame(CharMatcher.any(), CharMatcher.any().precomputed());
}
@GwtIncompatible // java.util.BitSet
private static BitSet bitSet(String chars) {
return bitSet(chars.toCharArray());
}
@GwtIncompatible // java.util.BitSet
private static BitSet bitSet(char[] chars) {
BitSet tmp = new BitSet();
for (char c : chars) {
tmp.set(c);
}
return tmp;
}
@GwtIncompatible // java.util.Random, java.util.BitSet
public void testSmallCharMatcher() {
CharMatcher len1 = SmallCharMatcher.from(bitSet("#"), "#");
CharMatcher len2 = SmallCharMatcher.from(bitSet("ab"), "ab");
CharMatcher len3 = SmallCharMatcher.from(bitSet("abc"), "abc");
CharMatcher len4 = SmallCharMatcher.from(bitSet("abcd"), "abcd");
assertTrue(len1.matches('#'));
assertFalse(len1.matches('!'));
assertTrue(len2.matches('a'));
assertTrue(len2.matches('b'));
for (char c = 'c'; c < 'z'; c++) {
assertFalse(len2.matches(c));
}
assertTrue(len3.matches('a'));
assertTrue(len3.matches('b'));
assertTrue(len3.matches('c'));
for (char c = 'd'; c < 'z'; c++) {
assertFalse(len3.matches(c));
}
assertTrue(len4.matches('a'));
assertTrue(len4.matches('b'));
assertTrue(len4.matches('c'));
assertTrue(len4.matches('d'));
for (char c = 'e'; c < 'z'; c++) {
assertFalse(len4.matches(c));
}
Random rand = new Random(1234);
for (int testCase = 0; testCase < 100; testCase++) {
char[] chars = randomChars(rand, rand.nextInt(63) + 1);
CharMatcher m = SmallCharMatcher.from(bitSet(chars), new String(chars));
checkExactMatches(m, chars);
}
}
static void checkExactMatches(CharMatcher m, char[] chars) {
Set<Character> positive = Sets.newHashSetWithExpectedSize(chars.length);
for (char c : chars) {
positive.add(c);
}
for (int c = 0; c <= Character.MAX_VALUE; c++) {
assertFalse(positive.contains(new Character((char) c)) ^ m.matches((char) c));
}
}
static char[] randomChars(Random rand, int size) {
Set<Character> chars = new HashSet<Character>(size);
for (int i = 0; i < size; i++) {
char c;
while (true) {
c = (char) rand.nextInt(Character.MAX_VALUE - Character.MIN_VALUE + 1);
if (!chars.contains(c)) {
break;
}
}
chars.add(c);
}
char[] retValue = new char[chars.size()];
int i = 0;
for (char c : chars) {
retValue[i++] = c;
}
Arrays.sort(retValue);
return retValue;
}
public void testToString() {
assertToStringWorks("CharMatcher.none()", CharMatcher.anyOf(""));
assertToStringWorks("CharMatcher.is('\\u0031')", CharMatcher.anyOf("1"));
assertToStringWorks("CharMatcher.isNot('\\u0031')", CharMatcher.isNot('1'));
assertToStringWorks("CharMatcher.anyOf(\"\\u0031\\u0032\")", CharMatcher.anyOf("12"));
assertToStringWorks("CharMatcher.anyOf(\"\\u0031\\u0032\\u0033\")",
CharMatcher.anyOf("321"));
assertToStringWorks("CharMatcher.inRange('\\u0031', '\\u0033')",
CharMatcher.inRange('1', '3'));
}
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());
}
}