guava-gwt/test-super/com/google/common/base/super/com/google/common/base/SplitterTest.java - platform/external/guava - Git at Google

 /*
  * Copyright (C) 2009 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.truth.Truth.assertThat;

 import com.google.common.annotations.GwtCompatible;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;

 import junit.framework.TestCase;

 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 /**
  * @author Julien Silland
  */
 @GwtCompatible(emulated = true)
 public class SplitterTest extends TestCase {

   private static final Splitter COMMA_SPLITTER = Splitter.on(',');

   public void testSplitNullString() {
     try {
       COMMA_SPLITTER.split(null);
       fail();
     } catch (NullPointerException expected) {
     }
   }

   public void testCharacterSimpleSplit() {
     String simple = "a,b,c";
     Iterable<String> letters = COMMA_SPLITTER.split(simple);
     assertThat(letters).iteratesAs("a", "b", "c");
   }

   /**
    * All of the infrastructure of split and splitToString is identical, so we
    * do one test of splitToString. All other cases should be covered by testing
    * of split.
    *
    * <p>TODO(user): It would be good to make all the relevant tests run on
    * both split and splitToString automatically.
    */
   public void testCharacterSimpleSplitToList() {
     String simple = "a,b,c";
     List<String> letters = COMMA_SPLITTER.splitToList(simple);
     assertThat(letters).iteratesAs("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());
   }

   public void testCharacterSimpleSplitWithNoDelimiter() {
     String simple = "a,b,c";
     Iterable<String> letters = Splitter.on('.').split(simple);
     assertThat(letters).iteratesAs("a,b,c");
   }

   public void testCharacterSplitWithDoubleDelimiter() {
     String doubled = "a,,b,c";
     Iterable<String> letters = COMMA_SPLITTER.split(doubled);
     assertThat(letters).iteratesAs("a", "", "b", "c");
   }

   public void testCharacterSplitWithDoubleDelimiterAndSpace() {
     String doubled = "a,, b,c";
     Iterable<String> letters = COMMA_SPLITTER.split(doubled);
     assertThat(letters).iteratesAs("a", "", " b", "c");
   }

   public void testCharacterSplitWithTrailingDelimiter() {
     String trailing = "a,b,c,";
     Iterable<String> letters = COMMA_SPLITTER.split(trailing);
     assertThat(letters).iteratesAs("a", "b", "c", "");
   }

   public void testCharacterSplitWithLeadingDelimiter() {
     String leading = ",a,b,c";
     Iterable<String> letters = COMMA_SPLITTER.split(leading);
     assertThat(letters).iteratesAs("", "a", "b", "c");
   }

   public void testCharacterSplitWithMulitpleLetters() {
     Iterable<String> testCharacteringMotto = Splitter.on('-').split(
         "Testing-rocks-Debugging-sucks");
     assertThat(testCharacteringMotto).iteratesAs(
         "Testing", "rocks", "Debugging", "sucks");
   }

   public void testCharacterSplitWithMatcherDelimiter() {
     Iterable<String> testCharacteringMotto = Splitter
         .on(CharMatcher.WHITESPACE)
         .split("Testing\nrocks\tDebugging sucks");
     assertThat(testCharacteringMotto).iteratesAs(
         "Testing", "rocks", "Debugging", "sucks");
   }

   public void testCharacterSplitWithDoubleDelimiterOmitEmptyStrings() {
     String doubled = "a..b.c";
     Iterable<String> letters = Splitter.on('.')
         .omitEmptyStrings().split(doubled);
     assertThat(letters).iteratesAs("a", "b", "c");
   }

   public void testCharacterSplitEmptyToken() {
     String emptyToken = "a. .c";
     Iterable<String> letters = Splitter.on('.').trimResults()
         .split(emptyToken);
     assertThat(letters).iteratesAs("a", "", "c");
   }

   public void testCharacterSplitEmptyTokenOmitEmptyStrings() {
     String emptyToken = "a. .c";
     Iterable<String> letters = Splitter.on('.')
         .omitEmptyStrings().trimResults().split(emptyToken);
     assertThat(letters).iteratesAs("a", "c");
   }

   public void testCharacterSplitOnEmptyString() {
     Iterable<String> nothing = Splitter.on('.').split("");
     assertThat(nothing).iteratesAs("");
   }

   public void testCharacterSplitOnEmptyStringOmitEmptyStrings() {
     assertThat(Splitter.on('.').omitEmptyStrings().split("")).isEmpty();
   }

   public void testCharacterSplitOnOnlyDelimiter() {
     Iterable<String> blankblank = Splitter.on('.').split(".");
     assertThat(blankblank).iteratesAs("", "");
   }

   public void testCharacterSplitOnOnlyDelimitersOmitEmptyStrings() {
     Iterable<String> empty = Splitter.on('.').omitEmptyStrings().split("...");
     assertThat(empty).isEmpty();
   }

   public void testCharacterSplitWithTrim() {
     String jacksons = "arfo(Marlon)aorf, (Michael)orfa, afro(Jackie)orfa, "
         + "ofar(Jemaine), aff(Tito)";
     Iterable<String> family = COMMA_SPLITTER
         .trimResults(CharMatcher.anyOf("afro").or(CharMatcher.WHITESPACE))
         .split(jacksons);
     assertThat(family).iteratesAs(
         "(Marlon)", "(Michael)", "(Jackie)", "(Jemaine)", "(Tito)");
   }

   public void testStringSimpleSplit() {
     String simple = "a,b,c";
     Iterable<String> letters = Splitter.on(',').split(simple);
     assertThat(letters).iteratesAs("a", "b", "c");
   }

   public void testStringSimpleSplitWithNoDelimiter() {
     String simple = "a,b,c";
     Iterable<String> letters = Splitter.on('.').split(simple);
     assertThat(letters).iteratesAs("a,b,c");
   }

   public void testStringSplitWithDoubleDelimiter() {
     String doubled = "a,,b,c";
     Iterable<String> letters = Splitter.on(',').split(doubled);
     assertThat(letters).iteratesAs("a", "", "b", "c");
   }

   public void testStringSplitWithDoubleDelimiterAndSpace() {
     String doubled = "a,, b,c";
     Iterable<String> letters = Splitter.on(',').split(doubled);
     assertThat(letters).iteratesAs("a", "", " b", "c");
   }

   public void testStringSplitWithTrailingDelimiter() {
     String trailing = "a,b,c,";
     Iterable<String> letters = Splitter.on(',').split(trailing);
     assertThat(letters).iteratesAs("a", "b", "c", "");
   }

   public void testStringSplitWithLeadingDelimiter() {
     String leading = ",a,b,c";
     Iterable<String> letters = Splitter.on(',').split(leading);
     assertThat(letters).iteratesAs("", "a", "b", "c");
   }

   public void testStringSplitWithMultipleLetters() {
     Iterable<String> testStringingMotto = Splitter.on('-').split(
         "Testing-rocks-Debugging-sucks");
     assertThat(testStringingMotto).iteratesAs(
         "Testing", "rocks", "Debugging", "sucks");
   }

   public void testStringSplitWithDoubleDelimiterOmitEmptyStrings() {
     String doubled = "a..b.c";
     Iterable<String> letters = Splitter.on('.')
         .omitEmptyStrings().split(doubled);
     assertThat(letters).iteratesAs("a", "b", "c");
   }

   public void testStringSplitEmptyToken() {
     String emptyToken = "a. .c";
     Iterable<String> letters = Splitter.on('.').trimResults()
         .split(emptyToken);
     assertThat(letters).iteratesAs("a", "", "c");
   }

   public void testStringSplitEmptyTokenOmitEmptyStrings() {
     String emptyToken = "a. .c";
     Iterable<String> letters = Splitter.on('.')
         .omitEmptyStrings().trimResults().split(emptyToken);
     assertThat(letters).iteratesAs("a", "c");
   }

   public void testStringSplitWithLongDelimiter() {
     String longDelimiter = "a, b, c";
     Iterable<String> letters = Splitter.on(", ").split(longDelimiter);
     assertThat(letters).iteratesAs("a", "b", "c");
   }

   public void testStringSplitWithLongLeadingDelimiter() {
     String longDelimiter = ", a, b, c";
     Iterable<String> letters = Splitter.on(", ").split(longDelimiter);
     assertThat(letters).iteratesAs("", "a", "b", "c");
   }

   public void testStringSplitWithLongTrailingDelimiter() {
     String longDelimiter = "a, b, c, ";
     Iterable<String> letters = Splitter.on(", ").split(longDelimiter);
     assertThat(letters).iteratesAs("a", "b", "c", "");
   }

   public void testStringSplitWithDelimiterSubstringInValue() {
     String fourCommasAndFourSpaces = ",,,,    ";
     Iterable<String> threeCommasThenThreeSpaces = Splitter.on(", ").split(
         fourCommasAndFourSpaces);
     assertThat(threeCommasThenThreeSpaces).iteratesAs(",,,", "   ");
   }

   public void testStringSplitWithEmptyString() {
     try {
       Splitter.on("");
       fail();
     } catch (IllegalArgumentException expected) {
     }
   }

   public void testStringSplitOnEmptyString() {
     Iterable<String> notMuch = Splitter.on('.').split("");
     assertThat(notMuch).iteratesAs("");
   }

   public void testStringSplitOnEmptyStringOmitEmptyString() {
     assertThat(Splitter.on('.').omitEmptyStrings().split("")).isEmpty();
   }

   public void testStringSplitOnOnlyDelimiter() {
     Iterable<String> blankblank = Splitter.on('.').split(".");
     assertThat(blankblank).iteratesAs("", "");
   }

   public void testStringSplitOnOnlyDelimitersOmitEmptyStrings() {
     Iterable<String> empty = Splitter.on('.').omitEmptyStrings().split("...");
     assertThat(empty).isEmpty();
   }

   public void testStringSplitWithTrim() {
     String jacksons = "arfo(Marlon)aorf, (Michael)orfa, afro(Jackie)orfa, "
         + "ofar(Jemaine), aff(Tito)";
     Iterable<String> family = Splitter.on(',')
         .trimResults(CharMatcher.anyOf("afro").or(CharMatcher.WHITESPACE))
         .split(jacksons);
     assertThat(family).iteratesAs(
         "(Marlon)", "(Michael)", "(Jackie)", "(Jemaine)", "(Tito)");
   }

   // TODO(kevinb): the name of this method suggests it might not actually be testing what it
   // intends to be testing?

   public void testSplitterIterableIsUnmodifiable_char() {
     assertIteratorIsUnmodifiable(COMMA_SPLITTER.split("a,b").iterator());
   }

   public void testSplitterIterableIsUnmodifiable_string() {
     assertIteratorIsUnmodifiable(Splitter.on(',').split("a,b").iterator());
   }

   private void assertIteratorIsUnmodifiable(Iterator<?> iterator) {
     iterator.next();
     try {
       iterator.remove();
       fail();
     } catch (UnsupportedOperationException expected) {
     }
   }

   public void testSplitterIterableIsLazy_char() {
     assertSplitterIterableIsLazy(COMMA_SPLITTER);
   }

   public void testSplitterIterableIsLazy_string() {
     assertSplitterIterableIsLazy(Splitter.on(','));
   }

   /**
    * This test really pushes the boundaries of what we support. In general the
    * splitter's behaviour is not well defined if the char sequence it's
    * splitting is mutated during iteration.
    */
   private void assertSplitterIterableIsLazy(Splitter splitter) {
     StringBuilder builder = new StringBuilder();
     Iterator<String> iterator = splitter.split(builder).iterator();

     builder.append("A,");
     assertEquals("A", iterator.next());
     builder.append("B,");
     assertEquals("B", iterator.next());
     builder.append("C");
     assertEquals("C", iterator.next());
     assertFalse(iterator.hasNext());
   }

   public void testFixedLengthSimpleSplit() {
     String simple = "abcde";
     Iterable<String> letters = Splitter.fixedLength(2).split(simple);
     assertThat(letters).iteratesAs("ab", "cd", "e");
   }

   public void testFixedLengthSplitEqualChunkLength() {
     String simple = "abcdef";
     Iterable<String> letters = Splitter.fixedLength(2).split(simple);
     assertThat(letters).iteratesAs("ab", "cd", "ef");
   }

   public void testFixedLengthSplitOnlyOneChunk() {
     String simple = "abc";
     Iterable<String> letters = Splitter.fixedLength(3).split(simple);
     assertThat(letters).iteratesAs("abc");
   }

   public void testFixedLengthSplitSmallerString() {
     String simple = "ab";
     Iterable<String> letters = Splitter.fixedLength(3).split(simple);
     assertThat(letters).iteratesAs("ab");
   }

   public void testFixedLengthSplitEmptyString() {
     String simple = "";
     Iterable<String> letters = Splitter.fixedLength(3).split(simple);
     assertThat(letters).iteratesAs("");
   }

   public void testFixedLengthSplitEmptyStringWithOmitEmptyStrings() {
     assertThat(Splitter.fixedLength(3).omitEmptyStrings().split("")).isEmpty();
   }

   public void testFixedLengthSplitIntoChars() {
     String simple = "abcd";
     Iterable<String> letters = Splitter.fixedLength(1).split(simple);
     assertThat(letters).iteratesAs("a", "b", "c", "d");
   }

   public void testFixedLengthSplitZeroChunkLen() {
     try {
       Splitter.fixedLength(0);
       fail();
     } catch (IllegalArgumentException expected) {
     }
   }

   public void testFixedLengthSplitNegativeChunkLen() {
     try {
       Splitter.fixedLength(-1);
       fail();
     } catch (IllegalArgumentException expected) {
     }
   }

   public void testLimitLarge() {
     String simple = "abcd";
     Iterable<String> letters = Splitter.fixedLength(1).limit(100).split(simple);
     assertThat(letters).iteratesAs("a", "b", "c", "d");
   }

   public void testLimitOne() {
     String simple = "abcd";
     Iterable<String> letters = Splitter.fixedLength(1).limit(1).split(simple);
     assertThat(letters).iteratesAs("abcd");
   }

   public void testLimitFixedLength() {
     String simple = "abcd";
     Iterable<String> letters = Splitter.fixedLength(1).limit(2).split(simple);
     assertThat(letters).iteratesAs("a", "bcd");
   }

   public void testLimitSeparator() {
     String simple = "a,b,c,d";
     Iterable<String> items = COMMA_SPLITTER.limit(2).split(simple);
     assertThat(items).iteratesAs("a", "b,c,d");
   }

   public void testLimitExtraSeparators() {
     String text = "a,,,b,,c,d";
     Iterable<String> items = COMMA_SPLITTER.limit(2).split(text);
     assertThat(items).iteratesAs("a", ",,b,,c,d");
   }

   public void testLimitExtraSeparatorsOmitEmpty() {
     String text = "a,,,b,,c,d";
     Iterable<String> items = COMMA_SPLITTER.limit(2).omitEmptyStrings().split(text);
     assertThat(items).iteratesAs("a", "b,,c,d");
   }

   public void testLimitExtraSeparatorsOmitEmpty3() {
     String text = "a,,,b,,c,d";
     Iterable<String> items = COMMA_SPLITTER.limit(3).omitEmptyStrings().split(text);
     assertThat(items).iteratesAs("a", "b", "c,d");
   }

   public void testLimitExtraSeparatorsTrim() {
     String text = ",,a,,  , b ,, c,d ";
     Iterable<String> items = COMMA_SPLITTER.limit(2).omitEmptyStrings().trimResults().split(text);
     assertThat(items).iteratesAs("a", "b ,, c,d");
   }

   public void testLimitExtraSeparatorsTrim3() {
     String text = ",,a,,  , b ,, c,d ";
     Iterable<String> items = COMMA_SPLITTER.limit(3).omitEmptyStrings().trimResults().split(text);
     assertThat(items).iteratesAs("a", "b", "c,d");
   }

   public void testLimitExtraSeparatorsTrim1() {
     String text = ",,a,,  , b ,, c,d ";
     Iterable<String> items = COMMA_SPLITTER.limit(1).omitEmptyStrings().trimResults().split(text);
     assertThat(items).iteratesAs("a,,  , b ,, c,d");
   }

   public void testLimitExtraSeparatorsTrim1NoOmit() {
     String text = ",,a,,  , b ,, c,d ";
     Iterable<String> items = COMMA_SPLITTER.limit(1).trimResults().split(text);
     assertThat(items).iteratesAs(",,a,,  , b ,, c,d");
   }

   public void testLimitExtraSeparatorsTrim1Empty() {
     String text = "";
     Iterable<String> items = COMMA_SPLITTER.limit(1).split(text);
     assertThat(items).iteratesAs("");
   }

   public void testLimitExtraSeparatorsTrim1EmptyOmit() {
     String text = "";
     Iterable<String> items = COMMA_SPLITTER.omitEmptyStrings().limit(1).split(text);
     assertThat(items).isEmpty();
   }

   @SuppressWarnings("ReturnValueIgnored") // testing for exception
   public void testInvalidZeroLimit() {
     try {
       COMMA_SPLITTER.limit(0);
       fail();
     } catch (IllegalArgumentException expected) {
     }
   }

   private static <E> List<E> asList(Collection<E> collection) {
     return ImmutableList.copyOf(collection);
   }

   public void testMapSplitter_trimmedBoth() {
     Map<String, String> m = COMMA_SPLITTER
         .trimResults()
         .withKeyValueSeparator(Splitter.on(':').trimResults())
         .split("boy  : tom , girl: tina , cat  : kitty , dog: tommy ");
     ImmutableMap<String, String> expected =
           ImmutableMap.of("boy", "tom", "girl", "tina", "cat", "kitty", "dog", "tommy");
     assertThat(m).isEqualTo(expected);
     assertThat(asList(m.entrySet())).isEqualTo(asList(expected.entrySet()));
   }

   public void testMapSplitter_trimmedEntries() {
     Map<String, String> m = COMMA_SPLITTER
         .trimResults()
         .withKeyValueSeparator(":")
         .split("boy  : tom , girl: tina , cat  : kitty , dog: tommy ");
     ImmutableMap<String, String> expected =
         ImmutableMap.of("boy  ", " tom", "girl", " tina", "cat  ", " kitty", "dog", " tommy");

     assertThat(m).isEqualTo(expected);
     assertThat(asList(m.entrySet())).isEqualTo(asList(expected.entrySet()));
   }

   public void testMapSplitter_trimmedKeyValue() {
     Map<String, String> m =
         COMMA_SPLITTER.withKeyValueSeparator(Splitter.on(':').trimResults()).split(
             "boy  : tom , girl: tina , cat  : kitty , dog: tommy ");
     ImmutableMap<String, String> expected =
         ImmutableMap.of("boy", "tom", "girl", "tina", "cat", "kitty", "dog", "tommy");
     assertThat(m).isEqualTo(expected);
     assertThat(asList(m.entrySet())).isEqualTo(asList(expected.entrySet()));
   }

   public void testMapSplitter_notTrimmed() {
     Map<String, String> m = COMMA_SPLITTER.withKeyValueSeparator(":").split(
         " boy:tom , girl: tina , cat :kitty , dog:  tommy ");
     ImmutableMap<String, String> expected =
         ImmutableMap.of(" boy", "tom ", " girl", " tina ", " cat ", "kitty ", " dog", "  tommy ");
     assertThat(m).isEqualTo(expected);
     assertThat(asList(m.entrySet())).isEqualTo(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");

     assertThat(m).isEqualTo(expected);
     assertThat(asList(m.entrySet())).isEqualTo(asList(expected.entrySet()));
   }

   public void testMapSplitter_multiCharacterSeparator() {
     // 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");

     assertThat(m).isEqualTo(expected);
     assertThat(asList(m.entrySet())).isEqualTo(asList(expected.entrySet()));
   }

   @SuppressWarnings("ReturnValueIgnored") // testing for exception
   public void testMapSplitter_emptySeparator() {
     try {
       COMMA_SPLITTER.withKeyValueSeparator("");
       fail();
     } catch (IllegalArgumentException expected) {
     }
   }

   public void testMapSplitter_malformedEntry() {
     try {
       COMMA_SPLITTER.withKeyValueSeparator("=").split("a=1,b,c=2");
       fail();
     } catch (IllegalArgumentException expected) {
     }
   }

   public void testMapSplitter_orderedResults() {
     Map<String, String> m = Splitter.on(',')
         .withKeyValueSeparator(":")
         .split("boy:tom,girl:tina,cat:kitty,dog:tommy");

     assertThat(m.keySet()).iteratesAs("boy", "girl", "cat", "dog");
     assertThat(m).isEqualTo(
         ImmutableMap.of("boy", "tom", "girl", "tina", "cat", "kitty", "dog", "tommy"));

     // try in a different order
     m = Splitter.on(',')
         .withKeyValueSeparator(":")
         .split("girl:tina,boy:tom,dog:tommy,cat:kitty");

     assertThat(m.keySet()).iteratesAs("girl", "boy", "dog", "cat");
     assertThat(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");
       fail();
     } catch (IllegalArgumentException expected) {
     }
   }
 }
	/*
	* Copyright (C) 2009 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.truth.Truth.assertThat;

	import com.google.common.annotations.GwtCompatible;
	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.ImmutableMap;

	import junit.framework.TestCase;

	import java.util.Collection;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	/**
	* @author Julien Silland
	*/
	@GwtCompatible(emulated = true)
	public class SplitterTest extends TestCase {

	private static final Splitter COMMA_SPLITTER = Splitter.on(',');

	public void testSplitNullString() {
	try {
	COMMA_SPLITTER.split(null);
	fail();
	} catch (NullPointerException expected) {
	}
	}

	public void testCharacterSimpleSplit() {
	String simple = "a,b,c";
	Iterable<String> letters = COMMA_SPLITTER.split(simple);
	assertThat(letters).iteratesAs("a", "b", "c");
	}

	/**
	* All of the infrastructure of split and splitToString is identical, so we
	* do one test of splitToString. All other cases should be covered by testing
	* of split.
	*
	* <p>TODO(user): It would be good to make all the relevant tests run on
	* both split and splitToString automatically.
	*/
	public void testCharacterSimpleSplitToList() {
	String simple = "a,b,c";
	List<String> letters = COMMA_SPLITTER.splitToList(simple);
	assertThat(letters).iteratesAs("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());
	}

	public void testCharacterSimpleSplitWithNoDelimiter() {
	String simple = "a,b,c";
	Iterable<String> letters = Splitter.on('.').split(simple);
	assertThat(letters).iteratesAs("a,b,c");
	}

	public void testCharacterSplitWithDoubleDelimiter() {
	String doubled = "a,,b,c";
	Iterable<String> letters = COMMA_SPLITTER.split(doubled);
	assertThat(letters).iteratesAs("a", "", "b", "c");
	}

	public void testCharacterSplitWithDoubleDelimiterAndSpace() {
	String doubled = "a,, b,c";
	Iterable<String> letters = COMMA_SPLITTER.split(doubled);
	assertThat(letters).iteratesAs("a", "", " b", "c");
	}

	public void testCharacterSplitWithTrailingDelimiter() {
	String trailing = "a,b,c,";
	Iterable<String> letters = COMMA_SPLITTER.split(trailing);
	assertThat(letters).iteratesAs("a", "b", "c", "");
	}

	public void testCharacterSplitWithLeadingDelimiter() {
	String leading = ",a,b,c";
	Iterable<String> letters = COMMA_SPLITTER.split(leading);
	assertThat(letters).iteratesAs("", "a", "b", "c");
	}

	public void testCharacterSplitWithMulitpleLetters() {
	Iterable<String> testCharacteringMotto = Splitter.on('-').split(
	"Testing-rocks-Debugging-sucks");
	assertThat(testCharacteringMotto).iteratesAs(
	"Testing", "rocks", "Debugging", "sucks");
	}

	public void testCharacterSplitWithMatcherDelimiter() {
	Iterable<String> testCharacteringMotto = Splitter
	.on(CharMatcher.WHITESPACE)
	.split("Testing\nrocks\tDebugging sucks");
	assertThat(testCharacteringMotto).iteratesAs(
	"Testing", "rocks", "Debugging", "sucks");
	}

	public void testCharacterSplitWithDoubleDelimiterOmitEmptyStrings() {
	String doubled = "a..b.c";
	Iterable<String> letters = Splitter.on('.')
	.omitEmptyStrings().split(doubled);
	assertThat(letters).iteratesAs("a", "b", "c");
	}

	public void testCharacterSplitEmptyToken() {
	String emptyToken = "a. .c";
	Iterable<String> letters = Splitter.on('.').trimResults()
	.split(emptyToken);
	assertThat(letters).iteratesAs("a", "", "c");
	}

	public void testCharacterSplitEmptyTokenOmitEmptyStrings() {
	String emptyToken = "a. .c";
	Iterable<String> letters = Splitter.on('.')
	.omitEmptyStrings().trimResults().split(emptyToken);
	assertThat(letters).iteratesAs("a", "c");
	}

	public void testCharacterSplitOnEmptyString() {
	Iterable<String> nothing = Splitter.on('.').split("");
	assertThat(nothing).iteratesAs("");
	}

	public void testCharacterSplitOnEmptyStringOmitEmptyStrings() {
	assertThat(Splitter.on('.').omitEmptyStrings().split("")).isEmpty();
	}

	public void testCharacterSplitOnOnlyDelimiter() {
	Iterable<String> blankblank = Splitter.on('.').split(".");
	assertThat(blankblank).iteratesAs("", "");
	}

	public void testCharacterSplitOnOnlyDelimitersOmitEmptyStrings() {
	Iterable<String> empty = Splitter.on('.').omitEmptyStrings().split("...");
	assertThat(empty).isEmpty();
	}

	public void testCharacterSplitWithTrim() {
	String jacksons = "arfo(Marlon)aorf, (Michael)orfa, afro(Jackie)orfa, "
	+ "ofar(Jemaine), aff(Tito)";
	Iterable<String> family = COMMA_SPLITTER
	.trimResults(CharMatcher.anyOf("afro").or(CharMatcher.WHITESPACE))
	.split(jacksons);
	assertThat(family).iteratesAs(
	"(Marlon)", "(Michael)", "(Jackie)", "(Jemaine)", "(Tito)");
	}

	public void testStringSimpleSplit() {
	String simple = "a,b,c";
	Iterable<String> letters = Splitter.on(',').split(simple);
	assertThat(letters).iteratesAs("a", "b", "c");
	}

	public void testStringSimpleSplitWithNoDelimiter() {
	String simple = "a,b,c";
	Iterable<String> letters = Splitter.on('.').split(simple);
	assertThat(letters).iteratesAs("a,b,c");
	}

	public void testStringSplitWithDoubleDelimiter() {
	String doubled = "a,,b,c";
	Iterable<String> letters = Splitter.on(',').split(doubled);
	assertThat(letters).iteratesAs("a", "", "b", "c");
	}

	public void testStringSplitWithDoubleDelimiterAndSpace() {
	String doubled = "a,, b,c";
	Iterable<String> letters = Splitter.on(',').split(doubled);
	assertThat(letters).iteratesAs("a", "", " b", "c");
	}

	public void testStringSplitWithTrailingDelimiter() {
	String trailing = "a,b,c,";
	Iterable<String> letters = Splitter.on(',').split(trailing);
	assertThat(letters).iteratesAs("a", "b", "c", "");
	}

	public void testStringSplitWithLeadingDelimiter() {
	String leading = ",a,b,c";
	Iterable<String> letters = Splitter.on(',').split(leading);
	assertThat(letters).iteratesAs("", "a", "b", "c");
	}

	public void testStringSplitWithMultipleLetters() {
	Iterable<String> testStringingMotto = Splitter.on('-').split(
	"Testing-rocks-Debugging-sucks");
	assertThat(testStringingMotto).iteratesAs(
	"Testing", "rocks", "Debugging", "sucks");
	}

	public void testStringSplitWithDoubleDelimiterOmitEmptyStrings() {
	String doubled = "a..b.c";
	Iterable<String> letters = Splitter.on('.')
	.omitEmptyStrings().split(doubled);
	assertThat(letters).iteratesAs("a", "b", "c");
	}

	public void testStringSplitEmptyToken() {
	String emptyToken = "a. .c";
	Iterable<String> letters = Splitter.on('.').trimResults()
	.split(emptyToken);
	assertThat(letters).iteratesAs("a", "", "c");
	}

	public void testStringSplitEmptyTokenOmitEmptyStrings() {
	String emptyToken = "a. .c";
	Iterable<String> letters = Splitter.on('.')
	.omitEmptyStrings().trimResults().split(emptyToken);
	assertThat(letters).iteratesAs("a", "c");
	}

	public void testStringSplitWithLongDelimiter() {
	String longDelimiter = "a, b, c";
	Iterable<String> letters = Splitter.on(", ").split(longDelimiter);
	assertThat(letters).iteratesAs("a", "b", "c");
	}

	public void testStringSplitWithLongLeadingDelimiter() {
	String longDelimiter = ", a, b, c";
	Iterable<String> letters = Splitter.on(", ").split(longDelimiter);
	assertThat(letters).iteratesAs("", "a", "b", "c");
	}

	public void testStringSplitWithLongTrailingDelimiter() {
	String longDelimiter = "a, b, c, ";
	Iterable<String> letters = Splitter.on(", ").split(longDelimiter);
	assertThat(letters).iteratesAs("a", "b", "c", "");
	}

	public void testStringSplitWithDelimiterSubstringInValue() {
	String fourCommasAndFourSpaces = ",,,, ";
	Iterable<String> threeCommasThenThreeSpaces = Splitter.on(", ").split(
	fourCommasAndFourSpaces);
	assertThat(threeCommasThenThreeSpaces).iteratesAs(",,,", " ");
	}

	public void testStringSplitWithEmptyString() {
	try {
	Splitter.on("");
	fail();
	} catch (IllegalArgumentException expected) {
	}
	}

	public void testStringSplitOnEmptyString() {
	Iterable<String> notMuch = Splitter.on('.').split("");
	assertThat(notMuch).iteratesAs("");
	}

	public void testStringSplitOnEmptyStringOmitEmptyString() {
	assertThat(Splitter.on('.').omitEmptyStrings().split("")).isEmpty();
	}

	public void testStringSplitOnOnlyDelimiter() {
	Iterable<String> blankblank = Splitter.on('.').split(".");
	assertThat(blankblank).iteratesAs("", "");
	}

	public void testStringSplitOnOnlyDelimitersOmitEmptyStrings() {
	Iterable<String> empty = Splitter.on('.').omitEmptyStrings().split("...");
	assertThat(empty).isEmpty();
	}

	public void testStringSplitWithTrim() {
	String jacksons = "arfo(Marlon)aorf, (Michael)orfa, afro(Jackie)orfa, "
	+ "ofar(Jemaine), aff(Tito)";
	Iterable<String> family = Splitter.on(',')
	.trimResults(CharMatcher.anyOf("afro").or(CharMatcher.WHITESPACE))
	.split(jacksons);
	assertThat(family).iteratesAs(
	"(Marlon)", "(Michael)", "(Jackie)", "(Jemaine)", "(Tito)");
	}

	// TODO(kevinb): the name of this method suggests it might not actually be testing what it
	// intends to be testing?

	public void testSplitterIterableIsUnmodifiable_char() {
	assertIteratorIsUnmodifiable(COMMA_SPLITTER.split("a,b").iterator());
	}

	public void testSplitterIterableIsUnmodifiable_string() {
	assertIteratorIsUnmodifiable(Splitter.on(',').split("a,b").iterator());
	}

	private void assertIteratorIsUnmodifiable(Iterator<?> iterator) {
	iterator.next();
	try {
	iterator.remove();
	fail();
	} catch (UnsupportedOperationException expected) {
	}
	}

	public void testSplitterIterableIsLazy_char() {
	assertSplitterIterableIsLazy(COMMA_SPLITTER);
	}

	public void testSplitterIterableIsLazy_string() {
	assertSplitterIterableIsLazy(Splitter.on(','));
	}

	/**
	* This test really pushes the boundaries of what we support. In general the
	* splitter's behaviour is not well defined if the char sequence it's
	* splitting is mutated during iteration.
	*/
	private void assertSplitterIterableIsLazy(Splitter splitter) {
	StringBuilder builder = new StringBuilder();
	Iterator<String> iterator = splitter.split(builder).iterator();

	builder.append("A,");
	assertEquals("A", iterator.next());
	builder.append("B,");
	assertEquals("B", iterator.next());
	builder.append("C");
	assertEquals("C", iterator.next());
	assertFalse(iterator.hasNext());
	}

	public void testFixedLengthSimpleSplit() {
	String simple = "abcde";
	Iterable<String> letters = Splitter.fixedLength(2).split(simple);
	assertThat(letters).iteratesAs("ab", "cd", "e");
	}

	public void testFixedLengthSplitEqualChunkLength() {
	String simple = "abcdef";
	Iterable<String> letters = Splitter.fixedLength(2).split(simple);
	assertThat(letters).iteratesAs("ab", "cd", "ef");
	}

	public void testFixedLengthSplitOnlyOneChunk() {
	String simple = "abc";
	Iterable<String> letters = Splitter.fixedLength(3).split(simple);
	assertThat(letters).iteratesAs("abc");
	}

	public void testFixedLengthSplitSmallerString() {
	String simple = "ab";
	Iterable<String> letters = Splitter.fixedLength(3).split(simple);
	assertThat(letters).iteratesAs("ab");
	}

	public void testFixedLengthSplitEmptyString() {
	String simple = "";
	Iterable<String> letters = Splitter.fixedLength(3).split(simple);
	assertThat(letters).iteratesAs("");
	}

	public void testFixedLengthSplitEmptyStringWithOmitEmptyStrings() {
	assertThat(Splitter.fixedLength(3).omitEmptyStrings().split("")).isEmpty();
	}

	public void testFixedLengthSplitIntoChars() {
	String simple = "abcd";
	Iterable<String> letters = Splitter.fixedLength(1).split(simple);
	assertThat(letters).iteratesAs("a", "b", "c", "d");
	}

	public void testFixedLengthSplitZeroChunkLen() {
	try {
	Splitter.fixedLength(0);
	fail();
	} catch (IllegalArgumentException expected) {
	}
	}

	public void testFixedLengthSplitNegativeChunkLen() {
	try {
	Splitter.fixedLength(-1);
	fail();
	} catch (IllegalArgumentException expected) {
	}
	}

	public void testLimitLarge() {
	String simple = "abcd";
	Iterable<String> letters = Splitter.fixedLength(1).limit(100).split(simple);
	assertThat(letters).iteratesAs("a", "b", "c", "d");
	}

	public void testLimitOne() {
	String simple = "abcd";
	Iterable<String> letters = Splitter.fixedLength(1).limit(1).split(simple);
	assertThat(letters).iteratesAs("abcd");
	}

	public void testLimitFixedLength() {
	String simple = "abcd";
	Iterable<String> letters = Splitter.fixedLength(1).limit(2).split(simple);
	assertThat(letters).iteratesAs("a", "bcd");
	}

	public void testLimitSeparator() {
	String simple = "a,b,c,d";
	Iterable<String> items = COMMA_SPLITTER.limit(2).split(simple);
	assertThat(items).iteratesAs("a", "b,c,d");
	}

	public void testLimitExtraSeparators() {
	String text = "a,,,b,,c,d";
	Iterable<String> items = COMMA_SPLITTER.limit(2).split(text);
	assertThat(items).iteratesAs("a", ",,b,,c,d");
	}

	public void testLimitExtraSeparatorsOmitEmpty() {
	String text = "a,,,b,,c,d";
	Iterable<String> items = COMMA_SPLITTER.limit(2).omitEmptyStrings().split(text);
	assertThat(items).iteratesAs("a", "b,,c,d");
	}

	public void testLimitExtraSeparatorsOmitEmpty3() {
	String text = "a,,,b,,c,d";
	Iterable<String> items = COMMA_SPLITTER.limit(3).omitEmptyStrings().split(text);
	assertThat(items).iteratesAs("a", "b", "c,d");
	}

	public void testLimitExtraSeparatorsTrim() {
	String text = ",,a,, , b ,, c,d ";
	Iterable<String> items = COMMA_SPLITTER.limit(2).omitEmptyStrings().trimResults().split(text);
	assertThat(items).iteratesAs("a", "b ,, c,d");
	}

	public void testLimitExtraSeparatorsTrim3() {
	String text = ",,a,, , b ,, c,d ";
	Iterable<String> items = COMMA_SPLITTER.limit(3).omitEmptyStrings().trimResults().split(text);
	assertThat(items).iteratesAs("a", "b", "c,d");
	}

	public void testLimitExtraSeparatorsTrim1() {
	String text = ",,a,, , b ,, c,d ";
	Iterable<String> items = COMMA_SPLITTER.limit(1).omitEmptyStrings().trimResults().split(text);
	assertThat(items).iteratesAs("a,, , b ,, c,d");
	}

	public void testLimitExtraSeparatorsTrim1NoOmit() {
	String text = ",,a,, , b ,, c,d ";
	Iterable<String> items = COMMA_SPLITTER.limit(1).trimResults().split(text);
	assertThat(items).iteratesAs(",,a,, , b ,, c,d");
	}

	public void testLimitExtraSeparatorsTrim1Empty() {
	String text = "";
	Iterable<String> items = COMMA_SPLITTER.limit(1).split(text);
	assertThat(items).iteratesAs("");
	}

	public void testLimitExtraSeparatorsTrim1EmptyOmit() {
	String text = "";
	Iterable<String> items = COMMA_SPLITTER.omitEmptyStrings().limit(1).split(text);
	assertThat(items).isEmpty();
	}

	@SuppressWarnings("ReturnValueIgnored") // testing for exception
	public void testInvalidZeroLimit() {
	try {
	COMMA_SPLITTER.limit(0);
	fail();
	} catch (IllegalArgumentException expected) {
	}
	}

	private static <E> List<E> asList(Collection<E> collection) {
	return ImmutableList.copyOf(collection);
	}

	public void testMapSplitter_trimmedBoth() {
	Map<String, String> m = COMMA_SPLITTER
	.trimResults()
	.withKeyValueSeparator(Splitter.on(':').trimResults())
	.split("boy : tom , girl: tina , cat : kitty , dog: tommy ");
	ImmutableMap<String, String> expected =
	ImmutableMap.of("boy", "tom", "girl", "tina", "cat", "kitty", "dog", "tommy");
	assertThat(m).isEqualTo(expected);
	assertThat(asList(m.entrySet())).isEqualTo(asList(expected.entrySet()));
	}

	public void testMapSplitter_trimmedEntries() {
	Map<String, String> m = COMMA_SPLITTER
	.trimResults()
	.withKeyValueSeparator(":")
	.split("boy : tom , girl: tina , cat : kitty , dog: tommy ");
	ImmutableMap<String, String> expected =
	ImmutableMap.of("boy ", " tom", "girl", " tina", "cat ", " kitty", "dog", " tommy");

	assertThat(m).isEqualTo(expected);
	assertThat(asList(m.entrySet())).isEqualTo(asList(expected.entrySet()));
	}

	public void testMapSplitter_trimmedKeyValue() {
	Map<String, String> m =
	COMMA_SPLITTER.withKeyValueSeparator(Splitter.on(':').trimResults()).split(
	"boy : tom , girl: tina , cat : kitty , dog: tommy ");
	ImmutableMap<String, String> expected =
	ImmutableMap.of("boy", "tom", "girl", "tina", "cat", "kitty", "dog", "tommy");
	assertThat(m).isEqualTo(expected);
	assertThat(asList(m.entrySet())).isEqualTo(asList(expected.entrySet()));
	}

	public void testMapSplitter_notTrimmed() {
	Map<String, String> m = COMMA_SPLITTER.withKeyValueSeparator(":").split(
	" boy:tom , girl: tina , cat :kitty , dog: tommy ");
	ImmutableMap<String, String> expected =
	ImmutableMap.of(" boy", "tom ", " girl", " tina ", " cat ", "kitty ", " dog", " tommy ");
	assertThat(m).isEqualTo(expected);
	assertThat(asList(m.entrySet())).isEqualTo(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");

	assertThat(m).isEqualTo(expected);
	assertThat(asList(m.entrySet())).isEqualTo(asList(expected.entrySet()));
	}

	public void testMapSplitter_multiCharacterSeparator() {
	// 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");

	assertThat(m).isEqualTo(expected);
	assertThat(asList(m.entrySet())).isEqualTo(asList(expected.entrySet()));
	}

	@SuppressWarnings("ReturnValueIgnored") // testing for exception
	public void testMapSplitter_emptySeparator() {
	try {
	COMMA_SPLITTER.withKeyValueSeparator("");
	fail();
	} catch (IllegalArgumentException expected) {
	}
	}

	public void testMapSplitter_malformedEntry() {
	try {
	COMMA_SPLITTER.withKeyValueSeparator("=").split("a=1,b,c=2");
	fail();
	} catch (IllegalArgumentException expected) {
	}
	}

	public void testMapSplitter_orderedResults() {
	Map<String, String> m = Splitter.on(',')
	.withKeyValueSeparator(":")
	.split("boy:tom,girl:tina,cat:kitty,dog:tommy");

	assertThat(m.keySet()).iteratesAs("boy", "girl", "cat", "dog");
	assertThat(m).isEqualTo(
	ImmutableMap.of("boy", "tom", "girl", "tina", "cat", "kitty", "dog", "tommy"));

	// try in a different order
	m = Splitter.on(',')
	.withKeyValueSeparator(":")
	.split("girl:tina,boy:tom,dog:tommy,cat:kitty");

	assertThat(m.keySet()).iteratesAs("girl", "boy", "dog", "cat");
	assertThat(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");
	fail();
	} catch (IllegalArgumentException expected) {
	}
	}
	}