diff options
Diffstat (limited to 'guava-tests/test/com/google/common/collect/FluentIterableTest.java')
-rw-r--r-- | guava-tests/test/com/google/common/collect/FluentIterableTest.java | 728 |
1 files changed, 0 insertions, 728 deletions
diff --git a/guava-tests/test/com/google/common/collect/FluentIterableTest.java b/guava-tests/test/com/google/common/collect/FluentIterableTest.java deleted file mode 100644 index 52dc9ba..0000000 --- a/guava-tests/test/com/google/common/collect/FluentIterableTest.java +++ /dev/null @@ -1,728 +0,0 @@ -/* - * 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.collect; - -import static java.util.Arrays.asList; -import static org.truth0.Truth.ASSERT; - -import com.google.common.annotations.GwtCompatible; -import com.google.common.annotations.GwtIncompatible; -import com.google.common.base.Function; -import com.google.common.base.Functions; -import com.google.common.base.Optional; -import com.google.common.base.Predicate; -import com.google.common.base.Predicates; -import com.google.common.collect.testing.IteratorFeature; -import com.google.common.collect.testing.IteratorTester; -import com.google.common.testing.NullPointerTester; - -import junit.framework.TestCase; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.Iterator; -import java.util.List; -import java.util.Set; -import java.util.SortedSet; - -import javax.annotation.Nullable; - -/** - * Unit test for {@link FluentIterable}. - * - * @author Marcin Mikosik - */ -@GwtCompatible(emulated = true) -public class FluentIterableTest extends TestCase { - - @GwtIncompatible("NullPointerTester") - public void testNullPointerExceptions() { - NullPointerTester tester = new NullPointerTester(); - tester.testAllPublicStaticMethods(FluentIterable.class); - } - - public void testFrom() { - assertEquals(ImmutableList.of(1, 2, 3, 4), - Lists.newArrayList(FluentIterable.from(ImmutableList.of(1, 2, 3, 4)))); - } - - @SuppressWarnings("deprecation") // test of deprecated method - public void testFrom_alreadyFluentIterable() { - FluentIterable<Integer> iterable = FluentIterable.from(asList(1)); - assertSame(iterable, FluentIterable.from(iterable)); - } - - public void testSize1Collection() { - assertEquals(1, FluentIterable.from(asList("a")).size()); - } - - public void testSize2NonCollection() { - Iterable<Integer> iterable = new Iterable<Integer>() { - @Override - public Iterator<Integer> iterator() { - return asList(0, 1).iterator(); - } - }; - assertEquals(2, FluentIterable.from(iterable).size()); - } - - public void testSize_collectionDoesntIterate() { - List<Integer> nums = asList(1, 2, 3, 4, 5); - List<Integer> collection = new ArrayList<Integer>(nums) { - @Override public Iterator<Integer> iterator() { - fail("Don't iterate me!"); - return null; - } - }; - assertEquals(5, FluentIterable.from(collection).size()); - } - - public void testContains_nullSetYes() { - Iterable<String> set = Sets.newHashSet("a", null, "b"); - assertTrue(FluentIterable.from(set).contains(null)); - } - - public void testContains_nullSetNo() { - Iterable<String> set = ImmutableSortedSet.of("a", "b"); - assertFalse(FluentIterable.from(set).contains(null)); - } - - public void testContains_nullIterableYes() { - Iterable<String> iterable = iterable("a", null, "b"); - assertTrue(FluentIterable.from(iterable).contains(null)); - } - - public void testContains_nullIterableNo() { - Iterable<String> iterable = iterable("a", "b"); - assertFalse(FluentIterable.from(iterable).contains(null)); - } - - public void testContains_nonNullSetYes() { - Iterable<String> set = Sets.newHashSet("a", null, "b"); - assertTrue(FluentIterable.from(set).contains("b")); - } - - public void testContains_nonNullSetNo() { - Iterable<String> set = Sets.newHashSet("a", "b"); - assertFalse(FluentIterable.from(set).contains("c")); - } - - public void testContains_nonNullIterableYes() { - Iterable<String> set = iterable("a", null, "b"); - assertTrue(FluentIterable.from(set).contains("b")); - } - - public void testContains_nonNullIterableNo() { - Iterable<String> iterable = iterable("a", "b"); - assertFalse(FluentIterable.from(iterable).contains("c")); - } - - public void testCycle() { - FluentIterable<String> cycle = FluentIterable.from(asList("a", "b")).cycle(); - - int howManyChecked = 0; - for (String string : cycle) { - String expected = (howManyChecked % 2 == 0) ? "a" : "b"; - assertEquals(expected, string); - if (howManyChecked++ == 5) { - break; - } - } - - // We left the last iterator pointing to "b". But a new iterator should - // always point to "a". - assertEquals("a", cycle.iterator().next()); - } - - public void testCycle_removingAllElementsStopsCycle() { - FluentIterable<Integer> cycle = fluent(1, 2).cycle(); - Iterator<Integer> iterator = cycle.iterator(); - iterator.next(); - iterator.remove(); - iterator.next(); - iterator.remove(); - assertFalse(iterator.hasNext()); - assertFalse(cycle.iterator().hasNext()); - } - - /* - * Tests for partition(int size) method. - */ - - /* - * Tests for partitionWithPadding(int size) method. - */ - - public void testFilter() { - FluentIterable<String> filtered = - FluentIterable.from(asList("foo", "bar")).filter(Predicates.equalTo("foo")); - - List<String> expected = Collections.singletonList("foo"); - List<String> actual = Lists.newArrayList(filtered); - assertEquals(expected, actual); - assertCanIterateAgain(filtered); - assertEquals("[foo]", filtered.toString()); - } - - private static class TypeA {} - private interface TypeB {} - private static class HasBoth extends TypeA implements TypeB {} - - @GwtIncompatible("Iterables.filter(Iterable, Class)") - public void testFilterByType() throws Exception { - HasBoth hasBoth = new HasBoth(); - FluentIterable<TypeA> alist = - FluentIterable.from(asList(new TypeA(), new TypeA(), hasBoth, new TypeA())); - Iterable<TypeB> blist = alist.filter(TypeB.class); - ASSERT.that(blist).iteratesOverSequence(hasBoth); - } - - public void testAnyMatch() { - ArrayList<String> list = Lists.newArrayList(); - FluentIterable<String> iterable = FluentIterable.<String>from(list); - Predicate<String> predicate = Predicates.equalTo("pants"); - - assertFalse(iterable.anyMatch(predicate)); - list.add("cool"); - assertFalse(iterable.anyMatch(predicate)); - list.add("pants"); - assertTrue(iterable.anyMatch(predicate)); - } - - public void testAllMatch() { - List<String> list = Lists.newArrayList(); - FluentIterable<String> iterable = FluentIterable.<String>from(list); - Predicate<String> predicate = Predicates.equalTo("cool"); - - assertTrue(iterable.allMatch(predicate)); - list.add("cool"); - assertTrue(iterable.allMatch(predicate)); - list.add("pants"); - assertFalse(iterable.allMatch(predicate)); - } - - public void testFirstMatch() { - FluentIterable<String> iterable = FluentIterable.from(Lists.newArrayList("cool", "pants")); - assertEquals(Optional.of("cool"), iterable.firstMatch(Predicates.equalTo("cool"))); - assertEquals(Optional.of("pants"), iterable.firstMatch(Predicates.equalTo("pants"))); - assertEquals(Optional.absent(), iterable.firstMatch(Predicates.alwaysFalse())); - assertEquals(Optional.of("cool"), iterable.firstMatch(Predicates.alwaysTrue())); - } - - private static final class IntegerValueOfFunction implements Function<String, Integer> { - @Override - public Integer apply(String from) { - return Integer.valueOf(from); - } - } - - public void testTransformWith() { - List<String> input = asList("1", "2", "3"); - Iterable<Integer> iterable = - FluentIterable.from(input).transform(new IntegerValueOfFunction()); - - assertEquals(asList(1, 2, 3), Lists.newArrayList(iterable)); - assertCanIterateAgain(iterable); - assertEquals("[1, 2, 3]", iterable.toString()); - } - - public void testTransformWith_poorlyBehavedTransform() { - List<String> input = asList("1", null, "3"); - Iterable<Integer> iterable = - FluentIterable.from(input).transform(new IntegerValueOfFunction()); - - Iterator<Integer> resultIterator = iterable.iterator(); - resultIterator.next(); - - try { - resultIterator.next(); - fail("Transforming null to int should throw NumberFormatException"); - } catch (NumberFormatException expected) { - } - } - - private static final class StringValueOfFunction implements Function<Integer, String> { - @Override - public String apply(Integer from) { - return String.valueOf(from); - } - } - - public void testTransformWith_nullFriendlyTransform() { - List<Integer> input = asList(1, 2, null, 3); - Iterable<String> result = FluentIterable.from(input).transform(new StringValueOfFunction()); - - assertEquals(asList("1", "2", "null", "3"), Lists.newArrayList(result)); - } - - private static final class RepeatedStringValueOfFunction - implements Function<Integer, List<String>> { - @Override - public List<String> apply(Integer from) { - String value = String.valueOf(from); - return ImmutableList.of(value, value); - } - } - - public void testTransformAndConcat() { - List<Integer> input = asList(1, 2, 3); - Iterable<String> result = - FluentIterable.from(input).transformAndConcat(new RepeatedStringValueOfFunction()); - assertEquals(asList("1", "1", "2", "2", "3", "3"), Lists.newArrayList(result)); - } - - private static final class RepeatedStringValueOfWildcardFunction - implements Function<Integer, List<? extends String>> { - @Override - public List<String> apply(Integer from) { - String value = String.valueOf(from); - return ImmutableList.of(value, value); - } - } - - public void testTransformAndConcat_wildcardFunctionGenerics() { - List<Integer> input = asList(1, 2, 3); - FluentIterable.from(input).transformAndConcat(new RepeatedStringValueOfWildcardFunction()); - } - - public void testFirst_list() { - List<String> list = Lists.newArrayList("a", "b", "c"); - assertEquals("a", FluentIterable.from(list).first().get()); - } - - public void testFirst_null() { - List<String> list = Lists.newArrayList(null, "a", "b"); - try { - FluentIterable.from(list).first(); - fail(); - } catch (NullPointerException expected) { - } - } - - public void testFirst_emptyList() { - List<String> list = Collections.emptyList(); - assertEquals(Optional.absent(), FluentIterable.from(list).first()); - } - - public void testFirst_sortedSet() { - SortedSet<String> sortedSet = ImmutableSortedSet.of("b", "c", "a"); - assertEquals("a", FluentIterable.from(sortedSet).first().get()); - } - - public void testFirst_emptySortedSet() { - SortedSet<String> sortedSet = ImmutableSortedSet.of(); - assertEquals(Optional.absent(), FluentIterable.from(sortedSet).first()); - } - - public void testFirst_iterable() { - Set<String> set = ImmutableSet.of("a", "b", "c"); - assertEquals("a", FluentIterable.from(set).first().get()); - } - - public void testFirst_emptyIterable() { - Set<String> set = Sets.newHashSet(); - assertEquals(Optional.absent(), FluentIterable.from(set).first()); - } - - public void testLast_list() { - List<String> list = Lists.newArrayList("a", "b", "c"); - assertEquals("c", FluentIterable.from(list).last().get()); - } - - public void testLast_null() { - List<String> list = Lists.newArrayList("a", "b", null); - try { - FluentIterable.from(list).last(); - fail(); - } catch (NullPointerException expected) { - } - } - - public void testLast_emptyList() { - List<String> list = Collections.emptyList(); - assertEquals(Optional.absent(), FluentIterable.from(list).last()); - } - - public void testLast_sortedSet() { - SortedSet<String> sortedSet = ImmutableSortedSet.of("b", "c", "a"); - assertEquals("c", FluentIterable.from(sortedSet).last().get()); - } - - public void testLast_emptySortedSet() { - SortedSet<String> sortedSet = ImmutableSortedSet.of(); - assertEquals(Optional.absent(), FluentIterable.from(sortedSet).last()); - } - - public void testLast_iterable() { - Set<String> set = ImmutableSet.of("a", "b", "c"); - assertEquals("c", FluentIterable.from(set).last().get()); - } - - public void testLast_emptyIterable() { - Set<String> set = Sets.newHashSet(); - assertEquals(Optional.absent(), FluentIterable.from(set).last()); - } - - public void testSkip_simple() { - Collection<String> set = ImmutableSet.of("a", "b", "c", "d", "e"); - assertEquals(Lists.newArrayList("c", "d", "e"), - Lists.newArrayList(FluentIterable.from(set).skip(2))); - assertEquals("[c, d, e]", FluentIterable.from(set).skip(2).toString()); - } - - public void testSkip_simpleList() { - Collection<String> list = Lists.newArrayList("a", "b", "c", "d", "e"); - assertEquals(Lists.newArrayList("c", "d", "e"), - Lists.newArrayList(FluentIterable.from(list).skip(2))); - assertEquals("[c, d, e]", FluentIterable.from(list).skip(2).toString()); - } - - public void testSkip_pastEnd() { - Collection<String> set = ImmutableSet.of("a", "b"); - assertEquals(Collections.emptyList(), Lists.newArrayList(FluentIterable.from(set).skip(20))); - } - - public void testSkip_pastEndList() { - Collection<String> list = Lists.newArrayList("a", "b"); - assertEquals(Collections.emptyList(), Lists.newArrayList(FluentIterable.from(list).skip(20))); - } - - public void testSkip_skipNone() { - Collection<String> set = ImmutableSet.of("a", "b"); - assertEquals(Lists.newArrayList("a", "b"), - Lists.newArrayList(FluentIterable.from(set).skip(0))); - } - - public void testSkip_skipNoneList() { - Collection<String> list = Lists.newArrayList("a", "b"); - assertEquals(Lists.newArrayList("a", "b"), - Lists.newArrayList(FluentIterable.from(list).skip(0))); - } - - public void testSkip_iterator() throws Exception { - new IteratorTester<Integer>(5, IteratorFeature.MODIFIABLE, Lists.newArrayList(2, 3), - IteratorTester.KnownOrder.KNOWN_ORDER) { - @Override protected Iterator<Integer> newTargetIterator() { - Collection<Integer> collection = Sets.newLinkedHashSet(); - Collections.addAll(collection, 1, 2, 3); - return FluentIterable.from(collection).skip(1).iterator(); - } - }.test(); - } - - public void testSkip_iteratorList() throws Exception { - new IteratorTester<Integer>(5, IteratorFeature.MODIFIABLE, Lists.newArrayList(2, 3), - IteratorTester.KnownOrder.KNOWN_ORDER) { - @Override protected Iterator<Integer> newTargetIterator() { - return FluentIterable.from(Lists.newArrayList(1, 2, 3)).skip(1).iterator(); - } - }.test(); - } - - public void testSkip_nonStructurallyModifiedList() throws Exception { - List<String> list = Lists.newArrayList("a", "b", "c"); - FluentIterable<String> tail = FluentIterable.from(list).skip(1); - Iterator<String> tailIterator = tail.iterator(); - list.set(2, "c2"); - assertEquals("b", tailIterator.next()); - assertEquals("c2", tailIterator.next()); - assertFalse(tailIterator.hasNext()); - } - - public void testSkip_structurallyModifiedSkipSome() throws Exception { - Collection<String> set = Sets.newLinkedHashSet(); - Collections.addAll(set, "a", "b", "c"); - FluentIterable<String> tail = FluentIterable.from(set).skip(1); - set.remove("b"); - set.addAll(Lists.newArrayList("X", "Y", "Z")); - ASSERT.that(tail).iteratesOverSequence("c", "X", "Y", "Z"); - } - - public void testSkip_structurallyModifiedSkipSomeList() throws Exception { - List<String> list = Lists.newArrayList("a", "b", "c"); - FluentIterable<String> tail = FluentIterable.from(list).skip(1); - list.subList(1, 3).clear(); - list.addAll(0, Lists.newArrayList("X", "Y", "Z")); - ASSERT.that(tail).iteratesOverSequence("Y", "Z", "a"); - } - - public void testSkip_structurallyModifiedSkipAll() throws Exception { - Collection<String> set = Sets.newLinkedHashSet(); - Collections.addAll(set, "a", "b", "c"); - FluentIterable<String> tail = FluentIterable.from(set).skip(2); - set.remove("a"); - set.remove("b"); - assertFalse(tail.iterator().hasNext()); - } - - public void testSkip_structurallyModifiedSkipAllList() throws Exception { - List<String> list = Lists.newArrayList("a", "b", "c"); - FluentIterable<String> tail = FluentIterable.from(list).skip(2); - list.subList(0, 2).clear(); - ASSERT.that(tail).isEmpty(); - } - - public void testSkip_illegalArgument() { - try { - FluentIterable.from(asList("a", "b", "c")).skip(-1); - fail("Skipping negative number of elements should throw IllegalArgumentException."); - } catch (IllegalArgumentException expected) { - } - } - - public void testLimit() { - Iterable<String> iterable = Lists.newArrayList("foo", "bar", "baz"); - FluentIterable<String> limited = FluentIterable.from(iterable).limit(2); - - assertEquals(ImmutableList.of("foo", "bar"), Lists.newArrayList(limited)); - assertCanIterateAgain(limited); - assertEquals("[foo, bar]", limited.toString()); - } - - public void testLimit_illegalArgument() { - try { - FluentIterable.from(Lists.newArrayList("a", "b", "c")).limit(-1); - fail("Passing negative number to limit(...) method should throw IllegalArgumentException"); - } catch (IllegalArgumentException expected) { - } - } - - public void testIsEmpty() { - assertTrue(FluentIterable.<String>from(Collections.<String>emptyList()).isEmpty()); - assertFalse(FluentIterable.<String>from(Lists.newArrayList("foo")).isEmpty()); - } - - public void testToList() { - assertEquals(Lists.newArrayList(1, 2, 3, 4), fluent(1, 2, 3, 4).toList()); - } - - public void testToList_empty() { - assertTrue(fluent().toList().isEmpty()); - } - - public void testToSortedList_withComparator() { - assertEquals(Lists.newArrayList(4, 3, 2, 1), - fluent(4, 1, 3, 2).toSortedList(Ordering.<Integer>natural().reverse())); - } - - public void testToSortedList_withDuplicates() { - assertEquals(Lists.newArrayList(4, 3, 1, 1), - fluent(1, 4, 1, 3).toSortedList(Ordering.<Integer>natural().reverse())); - } - - public void testToSet() { - ASSERT.that(fluent(1, 2, 3, 4).toSet()).has().allOf(1, 2, 3, 4).inOrder(); - } - - public void testToSet_removeDuplicates() { - ASSERT.that(fluent(1, 2, 1, 2).toSet()).has().allOf(1, 2).inOrder(); - } - - public void testToSet_empty() { - assertTrue(fluent().toSet().isEmpty()); - } - - public void testToSortedSet() { - ASSERT.that(fluent(1, 4, 2, 3).toSortedSet(Ordering.<Integer>natural().reverse())) - .has().allOf(4, 3, 2, 1).inOrder(); - } - - public void testToSortedSet_removeDuplicates() { - ASSERT.that(fluent(1, 4, 1, 3).toSortedSet(Ordering.<Integer>natural().reverse())) - .has().allOf(4, 3, 1).inOrder(); - } - - public void testToMap() { - ASSERT.that(fluent(1, 2, 3).toMap(Functions.toStringFunction()).entrySet()) - .has().allOf( - Maps.immutableEntry(1, "1"), - Maps.immutableEntry(2, "2"), - Maps.immutableEntry(3, "3")).inOrder(); - } - - public void testToMap_nullKey() { - try { - fluent(1, null, 2).toMap(Functions.constant("foo")); - fail(); - } catch (NullPointerException expected) { - } - } - - public void testToMap_nullValue() { - try { - fluent(1, 2, 3).toMap(Functions.constant(null)); - fail(); - } catch (NullPointerException expected) { - } - } - - public void testIndex() { - ImmutableListMultimap<Integer, String> expected = - ImmutableListMultimap.<Integer, String>builder() - .putAll(3, "one", "two") - .put(5, "three") - .put(4, "four") - .build(); - ImmutableListMultimap<Integer, String> index = - FluentIterable.from(asList("one", "two", "three", "four")).index( - new Function<String, Integer>() { - @Override - public Integer apply(String input) { - return input.length(); - } - }); - assertEquals(expected, index); - } - - public void testIndex_nullKey() { - try { - fluent(1, 2, 3).index(Functions.constant(null)); - fail(); - } catch (NullPointerException expected) { - } - } - - public void testIndex_nullValue() { - try { - fluent(1, null, 2).index(Functions.constant("foo")); - fail(); - } catch (NullPointerException expected) { - } - } - - public void testUniqueIndex() { - ImmutableMap<Integer, String> expected = - ImmutableMap.of(3, "two", 5, "three", 4, "four"); - ImmutableMap<Integer, String> index = - FluentIterable.from(asList("two", "three", "four")).uniqueIndex( - new Function<String, Integer>() { - @Override - public Integer apply(String input) { - return input.length(); - } - }); - assertEquals(expected, index); - } - - public void testUniqueIndex_duplicateKey() { - try { - FluentIterable.from(asList("one", "two", "three", "four")).uniqueIndex( - new Function<String, Integer>() { - @Override - public Integer apply(String input) { - return input.length(); - } - }); - fail(); - } catch (IllegalArgumentException expected) { - } - } - - public void testUniqueIndex_nullKey() { - try { - fluent(1, 2, 3).uniqueIndex(Functions.constant(null)); - fail(); - } catch (NullPointerException expected) { - } - } - - public void testUniqueIndex_nullValue() { - try { - fluent(1, null, 2).uniqueIndex(new Function<Integer, Object>() { - @Override - public Object apply(@Nullable Integer input) { - return String.valueOf(input); - } - }); - fail(); - } catch (NullPointerException expected) { - } - } - - public void testCopyInto_List() { - ASSERT.that(fluent(1, 3, 5).copyInto(Lists.newArrayList(1, 2))) - .has().allOf(1, 2, 1, 3, 5).inOrder(); - } - - public void testCopyInto_Set() { - ASSERT.that(fluent(1, 3, 5).copyInto(Sets.newHashSet(1, 2))) - .has().allOf(1, 2, 3, 5); - } - - public void testCopyInto_SetAllDuplicates() { - ASSERT.that(fluent(1, 3, 5).copyInto(Sets.newHashSet(1, 2, 3, 5))) - .has().allOf(1, 2, 3, 5); - } - - public void testCopyInto_NonCollection() { - final ArrayList<Integer> list = Lists.newArrayList(1, 2, 3); - - final ArrayList<Integer> iterList = Lists.newArrayList(9, 8, 7); - Iterable<Integer> iterable = new Iterable<Integer>() { - @Override - public Iterator<Integer> iterator() { - return iterList.iterator(); - } - }; - - ASSERT.that(FluentIterable.from(iterable).copyInto(list)) - .has().allOf(1, 2, 3, 9, 8, 7).inOrder(); - } - - public void testGet() { - assertEquals("a", FluentIterable - .from(Lists.newArrayList("a", "b", "c")).get(0)); - assertEquals("b", FluentIterable - .from(Lists.newArrayList("a", "b", "c")).get(1)); - assertEquals("c", FluentIterable - .from(Lists.newArrayList("a", "b", "c")).get(2)); - } - - public void testGet_outOfBounds() { - try { - FluentIterable.from(Lists.newArrayList("a", "b", "c")).get(-1); - fail(); - } catch (IndexOutOfBoundsException expected) { - } - - try { - FluentIterable.from(Lists.newArrayList("a", "b", "c")).get(3); - fail(); - } catch (IndexOutOfBoundsException expected) { - } - } - - private static void assertCanIterateAgain(Iterable<?> iterable) { - for (@SuppressWarnings("unused") Object obj : iterable) { - } - } - - private static FluentIterable<Integer> fluent(Integer... elements) { - return FluentIterable.from(Lists.newArrayList(elements)); - } - - private static Iterable<String> iterable(String... elements) { - final List<String> list = asList(elements); - return new Iterable<String>() { - @Override - public Iterator<String> iterator() { - return list.iterator(); - } - }; - } -} |