aboutsummaryrefslogtreecommitdiffstats
path: root/guava-tests/test/com/google/common/base/SplitterTest.java
diff options
context:
space:
mode:
Diffstat (limited to 'guava-tests/test/com/google/common/base/SplitterTest.java')
-rw-r--r--guava-tests/test/com/google/common/base/SplitterTest.java235
1 files changed, 99 insertions, 136 deletions
diff --git a/guava-tests/test/com/google/common/base/SplitterTest.java b/guava-tests/test/com/google/common/base/SplitterTest.java
index 57e44b0..25e963f 100644
--- a/guava-tests/test/com/google/common/base/SplitterTest.java
+++ b/guava-tests/test/com/google/common/base/SplitterTest.java
@@ -16,7 +16,7 @@
package com.google.common.base;
-import static org.truth0.Truth.ASSERT;
+import static org.junit.contrib.truth.Truth.ASSERT;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
@@ -51,49 +51,43 @@ public class SplitterTest extends TestCase {
public void testCharacterSimpleSplit() {
String simple = "a,b,c";
Iterable<String> letters = COMMA_SPLITTER.split(simple);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c");
- }
-
- public void testToString() {
- assertEquals("[]", Splitter.on(',').split("").toString());
- assertEquals("[a, b, c]", Splitter.on(',').split("a,b,c").toString());
- assertEquals("[yam, bam, jam, ham]", Splitter.on(", ").split("yam, bam, jam, ham").toString());
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c");
}
public void testCharacterSimpleSplitWithNoDelimiter() {
String simple = "a,b,c";
Iterable<String> letters = Splitter.on('.').split(simple);
- ASSERT.that(letters).iteratesOverSequence("a,b,c");
+ ASSERT.that(letters).hasContentsInOrder("a,b,c");
}
public void testCharacterSplitWithDoubleDelimiter() {
String doubled = "a,,b,c";
Iterable<String> letters = COMMA_SPLITTER.split(doubled);
- ASSERT.that(letters).iteratesOverSequence("a", "", "b", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "", "b", "c");
}
public void testCharacterSplitWithDoubleDelimiterAndSpace() {
String doubled = "a,, b,c";
Iterable<String> letters = COMMA_SPLITTER.split(doubled);
- ASSERT.that(letters).iteratesOverSequence("a", "", " b", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "", " b", "c");
}
public void testCharacterSplitWithTrailingDelimiter() {
String trailing = "a,b,c,";
Iterable<String> letters = COMMA_SPLITTER.split(trailing);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c", "");
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c", "");
}
public void testCharacterSplitWithLeadingDelimiter() {
String leading = ",a,b,c";
Iterable<String> letters = COMMA_SPLITTER.split(leading);
- ASSERT.that(letters).iteratesOverSequence("", "a", "b", "c");
+ ASSERT.that(letters).hasContentsInOrder("", "a", "b", "c");
}
public void testCharacterSplitWithMulitpleLetters() {
Iterable<String> testCharacteringMotto = Splitter.on('-').split(
"Testing-rocks-Debugging-sucks");
- ASSERT.that(testCharacteringMotto).iteratesOverSequence(
+ ASSERT.that(testCharacteringMotto).hasContentsInOrder(
"Testing", "rocks", "Debugging", "sucks");
}
@@ -101,7 +95,7 @@ public class SplitterTest extends TestCase {
Iterable<String> testCharacteringMotto = Splitter
.on(CharMatcher.WHITESPACE)
.split("Testing\nrocks\tDebugging sucks");
- ASSERT.that(testCharacteringMotto).iteratesOverSequence(
+ ASSERT.that(testCharacteringMotto).hasContentsInOrder(
"Testing", "rocks", "Debugging", "sucks");
}
@@ -109,26 +103,26 @@ public class SplitterTest extends TestCase {
String doubled = "a..b.c";
Iterable<String> letters = Splitter.on('.')
.omitEmptyStrings().split(doubled);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c");
}
public void testCharacterSplitEmptyToken() {
String emptyToken = "a. .c";
Iterable<String> letters = Splitter.on('.').trimResults()
.split(emptyToken);
- ASSERT.that(letters).iteratesOverSequence("a", "", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "", "c");
}
public void testCharacterSplitEmptyTokenOmitEmptyStrings() {
String emptyToken = "a. .c";
Iterable<String> letters = Splitter.on('.')
.omitEmptyStrings().trimResults().split(emptyToken);
- ASSERT.that(letters).iteratesOverSequence("a", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "c");
}
public void testCharacterSplitOnEmptyString() {
Iterable<String> nothing = Splitter.on('.').split("");
- ASSERT.that(nothing).iteratesOverSequence("");
+ ASSERT.that(nothing).hasContentsInOrder("");
}
public void testCharacterSplitOnEmptyStringOmitEmptyStrings() {
@@ -137,7 +131,7 @@ public class SplitterTest extends TestCase {
public void testCharacterSplitOnOnlyDelimiter() {
Iterable<String> blankblank = Splitter.on('.').split(".");
- ASSERT.that(blankblank).iteratesOverSequence("", "");
+ ASSERT.that(blankblank).hasContentsInOrder("", "");
}
public void testCharacterSplitOnOnlyDelimitersOmitEmptyStrings() {
@@ -151,97 +145,97 @@ public class SplitterTest extends TestCase {
Iterable<String> family = COMMA_SPLITTER
.trimResults(CharMatcher.anyOf("afro").or(CharMatcher.WHITESPACE))
.split(jacksons);
- ASSERT.that(family).iteratesOverSequence(
+ ASSERT.that(family).hasContentsInOrder(
"(Marlon)", "(Michael)", "(Jackie)", "(Jemaine)", "(Tito)");
}
public void testStringSimpleSplit() {
String simple = "a,b,c";
- Iterable<String> letters = Splitter.on(',').split(simple);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c");
+ Iterable<String> letters = Splitter.on(",").split(simple);
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c");
}
public void testStringSimpleSplitWithNoDelimiter() {
String simple = "a,b,c";
- Iterable<String> letters = Splitter.on('.').split(simple);
- ASSERT.that(letters).iteratesOverSequence("a,b,c");
+ Iterable<String> letters = Splitter.on(".").split(simple);
+ ASSERT.that(letters).hasContentsInOrder("a,b,c");
}
public void testStringSplitWithDoubleDelimiter() {
String doubled = "a,,b,c";
- Iterable<String> letters = Splitter.on(',').split(doubled);
- ASSERT.that(letters).iteratesOverSequence("a", "", "b", "c");
+ Iterable<String> letters = Splitter.on(",").split(doubled);
+ ASSERT.that(letters).hasContentsInOrder("a", "", "b", "c");
}
public void testStringSplitWithDoubleDelimiterAndSpace() {
String doubled = "a,, b,c";
- Iterable<String> letters = Splitter.on(',').split(doubled);
- ASSERT.that(letters).iteratesOverSequence("a", "", " b", "c");
+ Iterable<String> letters = Splitter.on(",").split(doubled);
+ ASSERT.that(letters).hasContentsInOrder("a", "", " b", "c");
}
public void testStringSplitWithTrailingDelimiter() {
String trailing = "a,b,c,";
- Iterable<String> letters = Splitter.on(',').split(trailing);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c", "");
+ Iterable<String> letters = Splitter.on(",").split(trailing);
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c", "");
}
public void testStringSplitWithLeadingDelimiter() {
String leading = ",a,b,c";
- Iterable<String> letters = Splitter.on(',').split(leading);
- ASSERT.that(letters).iteratesOverSequence("", "a", "b", "c");
+ Iterable<String> letters = Splitter.on(",").split(leading);
+ ASSERT.that(letters).hasContentsInOrder("", "a", "b", "c");
}
public void testStringSplitWithMultipleLetters() {
- Iterable<String> testStringingMotto = Splitter.on('-').split(
+ Iterable<String> testStringingMotto = Splitter.on("-").split(
"Testing-rocks-Debugging-sucks");
- ASSERT.that(testStringingMotto).iteratesOverSequence(
+ ASSERT.that(testStringingMotto).hasContentsInOrder(
"Testing", "rocks", "Debugging", "sucks");
}
public void testStringSplitWithDoubleDelimiterOmitEmptyStrings() {
String doubled = "a..b.c";
- Iterable<String> letters = Splitter.on('.')
+ Iterable<String> letters = Splitter.on(".")
.omitEmptyStrings().split(doubled);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c");
}
public void testStringSplitEmptyToken() {
String emptyToken = "a. .c";
- Iterable<String> letters = Splitter.on('.').trimResults()
+ Iterable<String> letters = Splitter.on(".").trimResults()
.split(emptyToken);
- ASSERT.that(letters).iteratesOverSequence("a", "", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "", "c");
}
public void testStringSplitEmptyTokenOmitEmptyStrings() {
String emptyToken = "a. .c";
- Iterable<String> letters = Splitter.on('.')
+ Iterable<String> letters = Splitter.on(".")
.omitEmptyStrings().trimResults().split(emptyToken);
- ASSERT.that(letters).iteratesOverSequence("a", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "c");
}
public void testStringSplitWithLongDelimiter() {
String longDelimiter = "a, b, c";
Iterable<String> letters = Splitter.on(", ").split(longDelimiter);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c");
}
public void testStringSplitWithLongLeadingDelimiter() {
String longDelimiter = ", a, b, c";
Iterable<String> letters = Splitter.on(", ").split(longDelimiter);
- ASSERT.that(letters).iteratesOverSequence("", "a", "b", "c");
+ ASSERT.that(letters).hasContentsInOrder("", "a", "b", "c");
}
public void testStringSplitWithLongTrailingDelimiter() {
String longDelimiter = "a, b, c, ";
Iterable<String> letters = Splitter.on(", ").split(longDelimiter);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c", "");
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c", "");
}
public void testStringSplitWithDelimiterSubstringInValue() {
String fourCommasAndFourSpaces = ",,,, ";
Iterable<String> threeCommasThenThreeSpaces = Splitter.on(", ").split(
fourCommasAndFourSpaces);
- ASSERT.that(threeCommasThenThreeSpaces).iteratesOverSequence(",,,", " ");
+ ASSERT.that(threeCommasThenThreeSpaces).hasContentsInOrder(",,,", " ");
}
public void testStringSplitWithEmptyString() {
@@ -253,31 +247,31 @@ public class SplitterTest extends TestCase {
}
public void testStringSplitOnEmptyString() {
- Iterable<String> notMuch = Splitter.on('.').split("");
- ASSERT.that(notMuch).iteratesOverSequence("");
+ Iterable<String> notMuch = Splitter.on(".").split("");
+ ASSERT.that(notMuch).hasContentsInOrder("");
}
public void testStringSplitOnEmptyStringOmitEmptyString() {
- ASSERT.that(Splitter.on('.').omitEmptyStrings().split("")).isEmpty();
+ ASSERT.that(Splitter.on(".").omitEmptyStrings().split("")).isEmpty();
}
public void testStringSplitOnOnlyDelimiter() {
- Iterable<String> blankblank = Splitter.on('.').split(".");
- ASSERT.that(blankblank).iteratesOverSequence("", "");
+ Iterable<String> blankblank = Splitter.on(".").split(".");
+ ASSERT.that(blankblank).hasContentsInOrder("", "");
}
public void testStringSplitOnOnlyDelimitersOmitEmptyStrings() {
- Iterable<String> empty = Splitter.on('.').omitEmptyStrings().split("...");
+ Iterable<String> empty = Splitter.on(".").omitEmptyStrings().split("...");
ASSERT.that(empty).isEmpty();
}
public void testStringSplitWithTrim() {
String jacksons = "arfo(Marlon)aorf, (Michael)orfa, afro(Jackie)orfa, "
+ "ofar(Jemaine), aff(Tito)";
- Iterable<String> family = Splitter.on(',')
+ Iterable<String> family = Splitter.on(",")
.trimResults(CharMatcher.anyOf("afro").or(CharMatcher.WHITESPACE))
.split(jacksons);
- ASSERT.that(family).iteratesOverSequence(
+ ASSERT.that(family).hasContentsInOrder(
"(Marlon)", "(Michael)", "(Jackie)", "(Jemaine)", "(Tito)");
}
@@ -285,42 +279,42 @@ public class SplitterTest extends TestCase {
public void testPatternSimpleSplit() {
String simple = "a,b,c";
Iterable<String> letters = Splitter.onPattern(",").split(simple);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c");
}
@GwtIncompatible("Splitter.onPattern")
public void testPatternSimpleSplitWithNoDelimiter() {
String simple = "a,b,c";
Iterable<String> letters = Splitter.onPattern("foo").split(simple);
- ASSERT.that(letters).iteratesOverSequence("a,b,c");
+ ASSERT.that(letters).hasContentsInOrder("a,b,c");
}
@GwtIncompatible("Splitter.onPattern")
public void testPatternSplitWithDoubleDelimiter() {
String doubled = "a,,b,c";
Iterable<String> letters = Splitter.onPattern(",").split(doubled);
- ASSERT.that(letters).iteratesOverSequence("a", "", "b", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "", "b", "c");
}
@GwtIncompatible("Splitter.onPattern")
public void testPatternSplitWithDoubleDelimiterAndSpace() {
String doubled = "a,, b,c";
Iterable<String> letters = Splitter.onPattern(",").split(doubled);
- ASSERT.that(letters).iteratesOverSequence("a", "", " b", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "", " b", "c");
}
@GwtIncompatible("Splitter.onPattern")
public void testPatternSplitWithTrailingDelimiter() {
String trailing = "a,b,c,";
Iterable<String> letters = Splitter.onPattern(",").split(trailing);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c", "");
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c", "");
}
@GwtIncompatible("Splitter.onPattern")
public void testPatternSplitWithLeadingDelimiter() {
String leading = ",a,b,c";
Iterable<String> letters = Splitter.onPattern(",").split(leading);
- ASSERT.that(letters).iteratesOverSequence("", "a", "b", "c");
+ ASSERT.that(letters).hasContentsInOrder("", "a", "b", "c");
}
// TODO(kevinb): the name of this method suggests it might not actually be testing what it
@@ -329,7 +323,7 @@ public class SplitterTest extends TestCase {
public void testPatternSplitWithMultipleLetters() {
Iterable<String> testPatterningMotto = Splitter.onPattern("-").split(
"Testing-rocks-Debugging-sucks");
- ASSERT.that(testPatterningMotto).iteratesOverSequence("Testing", "rocks", "Debugging", "sucks");
+ ASSERT.that(testPatterningMotto).hasContentsInOrder("Testing", "rocks", "Debugging", "sucks");
}
@GwtIncompatible("java.util.regex.Pattern")
@@ -342,30 +336,14 @@ public class SplitterTest extends TestCase {
String doubled = "a..b.c";
Iterable<String> letters = Splitter.on(literalDotPattern())
.omitEmptyStrings().split(doubled);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c");
- }
-
- @GwtIncompatible("java.util.regex.Pattern")
- public void testPatternSplitLookBehind() {
- String toSplit = ":foo::barbaz:";
- String regexPattern = "(?<=:)";
- Iterable<String> split = Splitter.onPattern(regexPattern).split(toSplit);
- ASSERT.that(split).iteratesOverSequence(":", "foo:", ":", "barbaz:");
- // splits into chunks ending in :
- }
-
- @GwtIncompatible("java.util.regex.Pattern")
- public void testPatternSplitWordBoundary() {
- String string = "foo<bar>bletch";
- Iterable<String> words = Splitter.on(Pattern.compile("\\b")).split(string);
- ASSERT.that(words).iteratesOverSequence("foo", "<", "bar", ">", "bletch");
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c");
}
@GwtIncompatible("java.util.regex.Pattern")
public void testPatternSplitEmptyToken() {
String emptyToken = "a. .c";
Iterable<String> letters = Splitter.on(literalDotPattern()).trimResults().split(emptyToken);
- ASSERT.that(letters).iteratesOverSequence("a", "", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "", "c");
}
@GwtIncompatible("java.util.regex.Pattern")
@@ -373,14 +351,14 @@ public class SplitterTest extends TestCase {
String emptyToken = "a. .c";
Iterable<String> letters = Splitter.on(literalDotPattern())
.omitEmptyStrings().trimResults().split(emptyToken);
- ASSERT.that(letters).iteratesOverSequence("a", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "c");
}
@GwtIncompatible("java.util.regex.Pattern")
public void testPatternSplitOnOnlyDelimiter() {
Iterable<String> blankblank = Splitter.on(literalDotPattern()).split(".");
- ASSERT.that(blankblank).iteratesOverSequence("", "");
+ ASSERT.that(blankblank).hasContentsInOrder("", "");
}
@GwtIncompatible("java.util.regex.Pattern")
@@ -395,7 +373,7 @@ public class SplitterTest extends TestCase {
String longDelimiter = "a, b, c";
Iterable<String> letters = Splitter.on(Pattern.compile(",\\s*"))
.split(longDelimiter);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c");
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c");
}
@GwtIncompatible("java.util.regex.Pattern")
@@ -403,7 +381,7 @@ public class SplitterTest extends TestCase {
String longDelimiter = ", a, b, c";
Iterable<String> letters = Splitter.on(Pattern.compile(", "))
.split(longDelimiter);
- ASSERT.that(letters).iteratesOverSequence("", "a", "b", "c");
+ ASSERT.that(letters).hasContentsInOrder("", "a", "b", "c");
}
@GwtIncompatible("java.util.regex.Pattern")
@@ -411,7 +389,7 @@ public class SplitterTest extends TestCase {
String longDelimiter = "a, b, c/ ";
Iterable<String> letters = Splitter.on(Pattern.compile("[,/]\\s"))
.split(longDelimiter);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c", "");
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c", "");
}
@GwtIncompatible("java.util.regex.Pattern")
@@ -430,7 +408,7 @@ public class SplitterTest extends TestCase {
Iterable<String> family = Splitter.on(Pattern.compile(","))
.trimResults(CharMatcher.anyOf("afro").or(CharMatcher.WHITESPACE))
.split(jacksons);
- ASSERT.that(family).iteratesOverSequence(
+ ASSERT.that(family).hasContentsInOrder(
"(Marlon)", "(Michael)", "(Jackie)", "(Jemaine)", "(Tito)");
}
@@ -439,7 +417,7 @@ public class SplitterTest extends TestCase {
}
public void testSplitterIterableIsUnmodifiable_string() {
- assertIteratorIsUnmodifiable(Splitter.on(',').split("a,b").iterator());
+ assertIteratorIsUnmodifiable(Splitter.on(",").split("a,b").iterator());
}
@GwtIncompatible("java.util.regex.Pattern")
@@ -462,7 +440,7 @@ public class SplitterTest extends TestCase {
}
public void testSplitterIterableIsLazy_string() {
- assertSplitterIterableIsLazy(Splitter.on(','));
+ assertSplitterIterableIsLazy(Splitter.on(","));
}
@GwtIncompatible("java.util.regex.Pattern")
@@ -488,47 +466,47 @@ public class SplitterTest extends TestCase {
assertFalse(iterator.hasNext());
}
- public void testFixedLengthSimpleSplit() {
+ public void testAtEachSimpleSplit() {
String simple = "abcde";
Iterable<String> letters = Splitter.fixedLength(2).split(simple);
- ASSERT.that(letters).iteratesOverSequence("ab", "cd", "e");
+ ASSERT.that(letters).hasContentsInOrder("ab", "cd", "e");
}
- public void testFixedLengthSplitEqualChunkLength() {
+ public void testAtEachSplitEqualChunkLength() {
String simple = "abcdef";
Iterable<String> letters = Splitter.fixedLength(2).split(simple);
- ASSERT.that(letters).iteratesOverSequence("ab", "cd", "ef");
+ ASSERT.that(letters).hasContentsInOrder("ab", "cd", "ef");
}
- public void testFixedLengthSplitOnlyOneChunk() {
+ public void testAtEachSplitOnlyOneChunk() {
String simple = "abc";
Iterable<String> letters = Splitter.fixedLength(3).split(simple);
- ASSERT.that(letters).iteratesOverSequence("abc");
+ ASSERT.that(letters).hasContentsInOrder("abc");
}
- public void testFixedLengthSplitSmallerString() {
+ public void testAtEachSplitSmallerString() {
String simple = "ab";
Iterable<String> letters = Splitter.fixedLength(3).split(simple);
- ASSERT.that(letters).iteratesOverSequence("ab");
+ ASSERT.that(letters).hasContentsInOrder("ab");
}
- public void testFixedLengthSplitEmptyString() {
+ public void testAtEachSplitEmptyString() {
String simple = "";
Iterable<String> letters = Splitter.fixedLength(3).split(simple);
- ASSERT.that(letters).iteratesOverSequence("");
+ ASSERT.that(letters).hasContentsInOrder("");
}
- public void testFixedLengthSplitEmptyStringWithOmitEmptyStrings() {
+ public void testAtEachSplitEmptyStringWithOmitEmptyStrings() {
ASSERT.that(Splitter.fixedLength(3).omitEmptyStrings().split("")).isEmpty();
}
- public void testFixedLengthSplitIntoChars() {
+ public void testAtEachSplitIntoChars() {
String simple = "abcd";
Iterable<String> letters = Splitter.fixedLength(1).split(simple);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c", "d");
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c", "d");
}
- public void testFixedLengthSplitZeroChunkLen() {
+ public void testAtEachSplitZeroChunkLen() {
try {
Splitter.fixedLength(0);
fail();
@@ -536,7 +514,7 @@ public class SplitterTest extends TestCase {
}
}
- public void testFixedLengthSplitNegativeChunkLen() {
+ public void testAtEachSplitNegativeChunkLen() {
try {
Splitter.fixedLength(-1);
fail();
@@ -547,73 +525,73 @@ public class SplitterTest extends TestCase {
public void testLimitLarge() {
String simple = "abcd";
Iterable<String> letters = Splitter.fixedLength(1).limit(100).split(simple);
- ASSERT.that(letters).iteratesOverSequence("a", "b", "c", "d");
+ ASSERT.that(letters).hasContentsInOrder("a", "b", "c", "d");
}
public void testLimitOne() {
String simple = "abcd";
Iterable<String> letters = Splitter.fixedLength(1).limit(1).split(simple);
- ASSERT.that(letters).iteratesOverSequence("abcd");
+ ASSERT.that(letters).hasContentsInOrder("abcd");
}
public void testLimitFixedLength() {
String simple = "abcd";
Iterable<String> letters = Splitter.fixedLength(1).limit(2).split(simple);
- ASSERT.that(letters).iteratesOverSequence("a", "bcd");
+ ASSERT.that(letters).hasContentsInOrder("a", "bcd");
}
public void testLimitSeparator() {
String simple = "a,b,c,d";
Iterable<String> items = COMMA_SPLITTER.limit(2).split(simple);
- ASSERT.that(items).iteratesOverSequence("a", "b,c,d");
+ ASSERT.that(items).hasContentsInOrder("a", "b,c,d");
}
public void testLimitExtraSeparators() {
String text = "a,,,b,,c,d";
Iterable<String> items = COMMA_SPLITTER.limit(2).split(text);
- ASSERT.that(items).iteratesOverSequence("a", ",,b,,c,d");
+ ASSERT.that(items).hasContentsInOrder("a", ",,b,,c,d");
}
public void testLimitExtraSeparatorsOmitEmpty() {
String text = "a,,,b,,c,d";
Iterable<String> items = COMMA_SPLITTER.limit(2).omitEmptyStrings().split(text);
- ASSERT.that(items).iteratesOverSequence("a", "b,,c,d");
+ ASSERT.that(items).hasContentsInOrder("a", "b,,c,d");
}
public void testLimitExtraSeparatorsOmitEmpty3() {
String text = "a,,,b,,c,d";
Iterable<String> items = COMMA_SPLITTER.limit(3).omitEmptyStrings().split(text);
- ASSERT.that(items).iteratesOverSequence("a", "b", "c,d");
+ ASSERT.that(items).hasContentsInOrder("a", "b", "c,d");
}
public void testLimitExtraSeparatorsTrim() {
String text = ",,a,, , b ,, c,d ";
Iterable<String> items = COMMA_SPLITTER.limit(2).omitEmptyStrings().trimResults().split(text);
- ASSERT.that(items).iteratesOverSequence("a", "b ,, c,d");
+ ASSERT.that(items).hasContentsInOrder("a", "b ,, c,d");
}
public void testLimitExtraSeparatorsTrim3() {
String text = ",,a,, , b ,, c,d ";
Iterable<String> items = COMMA_SPLITTER.limit(3).omitEmptyStrings().trimResults().split(text);
- ASSERT.that(items).iteratesOverSequence("a", "b", "c,d");
+ ASSERT.that(items).hasContentsInOrder("a", "b", "c,d");
}
public void testLimitExtraSeparatorsTrim1() {
String text = ",,a,, , b ,, c,d ";
Iterable<String> items = COMMA_SPLITTER.limit(1).omitEmptyStrings().trimResults().split(text);
- ASSERT.that(items).iteratesOverSequence("a,, , b ,, c,d");
+ ASSERT.that(items).hasContentsInOrder("a,, , b ,, c,d");
}
public void testLimitExtraSeparatorsTrim1NoOmit() {
String text = ",,a,, , b ,, c,d ";
Iterable<String> items = COMMA_SPLITTER.limit(1).trimResults().split(text);
- ASSERT.that(items).iteratesOverSequence(",,a,, , b ,, c,d");
+ ASSERT.that(items).hasContentsInOrder(",,a,, , b ,, c,d");
}
public void testLimitExtraSeparatorsTrim1Empty() {
String text = "";
Iterable<String> items = COMMA_SPLITTER.limit(1).split(text);
- ASSERT.that(items).iteratesOverSequence("");
+ ASSERT.that(items).hasContentsInOrder("");
}
public void testLimitExtraSeparatorsTrim1EmptyOmit() {
@@ -622,7 +600,6 @@ public class SplitterTest extends TestCase {
ASSERT.that(items).isEmpty();
}
- @SuppressWarnings("ReturnValueIgnored")
public void testInvalidZeroLimit() {
try {
COMMA_SPLITTER.limit(0);
@@ -632,11 +609,11 @@ public class SplitterTest extends TestCase {
}
@GwtIncompatible("NullPointerTester")
- public void testNullPointers() {
+ public void testNullPointers() throws Exception {
NullPointerTester tester = new NullPointerTester();
tester.testAllPublicStaticMethods(Splitter.class);
- tester.testAllPublicInstanceMethods(Splitter.on(','));
- tester.testAllPublicInstanceMethods(Splitter.on(',').trimResults());
+ tester.testAllPublicInstanceMethods(Splitter.on(","));
+ tester.testAllPublicInstanceMethods(Splitter.on(",").trimResults());
}
private static <E> List<E> asList(Collection<E> collection){
@@ -685,19 +662,6 @@ public class SplitterTest extends TestCase {
ASSERT.that(asList(m.entrySet())).is(asList(expected.entrySet()));
}
- public void testMapSplitter_CharacterSeparator() {
- // try different delimiters.
- Map<String, String> m = Splitter
- .on(",")
- .withKeyValueSeparator(':')
- .split("boy:tom,girl:tina,cat:kitty,dog:tommy");
- ImmutableMap<String, String> expected =
- ImmutableMap.of("boy", "tom", "girl", "tina", "cat", "kitty", "dog", "tommy");
-
- ASSERT.that(m).isEqualTo(expected);
- ASSERT.that(asList(m.entrySet())).is(asList(expected.entrySet()));
- }
-
public void testMapSplitter_multiCharacterSeparator() {
// try different delimiters.
Map<String, String> m = Splitter
@@ -711,7 +675,6 @@ public class SplitterTest extends TestCase {
ASSERT.that(asList(m.entrySet())).is(asList(expected.entrySet()));
}
- @SuppressWarnings("ReturnValueIgnored")
public void testMapSplitter_emptySeparator() {
try {
COMMA_SPLITTER.withKeyValueSeparator("");
@@ -729,27 +692,27 @@ public class SplitterTest extends TestCase {
}
public void testMapSplitter_orderedResults() {
- Map<String, String> m = Splitter.on(',')
+ Map<String, String> m = Splitter.on(",")
.withKeyValueSeparator(":")
.split("boy:tom,girl:tina,cat:kitty,dog:tommy");
- ASSERT.that(m.keySet()).iteratesOverSequence("boy", "girl", "cat", "dog");
+ ASSERT.that(m.keySet()).hasContentsInOrder("boy", "girl", "cat", "dog");
ASSERT.that(m).isEqualTo(
ImmutableMap.of("boy", "tom", "girl", "tina", "cat", "kitty", "dog", "tommy"));
// try in a different order
- m = Splitter.on(',')
+ m = Splitter.on(",")
.withKeyValueSeparator(":")
.split("girl:tina,boy:tom,dog:tommy,cat:kitty");
- ASSERT.that(m.keySet()).iteratesOverSequence("girl", "boy", "dog", "cat");
+ ASSERT.that(m.keySet()).hasContentsInOrder("girl", "boy", "dog", "cat");
ASSERT.that(m).isEqualTo(
ImmutableMap.of("boy", "tom", "girl", "tina", "cat", "kitty", "dog", "tommy"));
}
public void testMapSplitter_duplicateKeys() {
try {
- Splitter.on(',').withKeyValueSeparator(":").split("a:1,b:2,a:3");
+ Splitter.on(",").withKeyValueSeparator(":").split("a:1,b:2,a:3");
fail();
} catch (IllegalArgumentException expected) {
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-23 23:31:34 +0000