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()); }
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)); }
@SuppressWarnings("deprecation") // test of deprecated method public void testFrom_alreadyFluentIterable() { FluentIterable<Integer> iterable = FluentIterable.from(asList(1)); assertSame(iterable, FluentIterable.from(iterable)); }
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 testContains_nonNullIterableNo() { Iterable<String> iterable = iterable("a", "b"); assertFalse(FluentIterable.from(iterable).contains("c")); }
public void testUniqueIndex_nullValue() { try { ImmutableMap<Object, Integer> unused = 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 testFromArray() { assertEquals( ImmutableList.of("1", "2", "3", "4"), Lists.newArrayList(FluentIterable.from(new Object[] {"1", "2", "3", "4"}))); }
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 testContains_nullIterableYes() { Iterable<String> iterable = iterable("a", null, "b"); assertTrue(FluentIterable.from(iterable).contains(null)); }
public void testToSet() { assertThat(fluent(1, 2, 3, 4).toSet()).containsExactly(1, 2, 3, 4).inOrder(); }
public void testContains_nonNullSetNo() { Iterable<String> set = Sets.newHashSet("a", "b"); assertFalse(FluentIterable.from(set).contains("c")); }
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 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()); }
public void testContains_nullSetYes() { Iterable<String> set = Sets.newHashSet("a", null, "b"); assertTrue(FluentIterable.from(set).contains(null)); }
public void testJoin() { assertEquals("2,1,3,4", fluent(2, 1, 3, 4).join(Joiner.on(","))); }
public void testFrom() { assertEquals( ImmutableList.of(1, 2, 3, 4), Lists.newArrayList(FluentIterable.from(ImmutableList.of(1, 2, 3, 4)))); }
public void testLimit_illegalArgument() { try { FluentIterable<String> unused = FluentIterable.from(Lists.newArrayList("a", "b", "c")).limit(-1); fail("Passing negative number to limit(...) method should throw IllegalArgumentException"); } catch (IllegalArgumentException expected) { } }
public void testContains_nullIterableNo() { Iterable<String> iterable = iterable("a", "b"); assertFalse(FluentIterable.from(iterable).contains(null)); }