@Test public void testPageSize() { BatchingVisitable<Long> visitor = ListVisitor.create(Lists.newArrayList(0L, 1L, 2L, 3L, 4L, 5L)); visitor.batchAccept(5, item -> { assertEquals("batched item had wrong size", 5, item.size()); return false; }); visitor.batchAccept(1, item -> { assertEquals("batched item had wrong size", 1, item.size()); return false; }); visitor.batchAccept(2, item -> { assertEquals("batched item had wrong size", 2, item.size()); return true; }); visitor.batchAccept(4, item -> { Preconditions.checkState(item.size() == 4, "batched item had wrong size"); return false; }); visitor.batchAccept(4, item -> { Preconditions.checkState(item.size() == 4 || item.size() == 2, "batched item had wrong size"); return true; }); visitor.batchAccept(20, item -> { assertEquals("batched item had wrong size", 6, item.size()); return true; }); }
@Test public void testLimit() { BatchingVisitable<Long> visitor = ListVisitor.create(Lists.newArrayList(0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L)); BatchingVisitableView<Long> limited = BatchingVisitableView.of(visitor).limit(3); ImmutableList<Long> copy = limited.immutableCopy();
@Test public void testGetFirstPage() { BatchingVisitable<Long> visitor = ListVisitor.create(Lists.newArrayList(0L, 1L, 2L, 3L)); TokenBackedBasicResultsPage<Long, Long> page = BatchingVisitables.getFirstPage(visitor, 0); assertEquals("page results had wrong size!", 0, page.getResults().size()); assertEquals("page.moreResultsAvailable was wrong", true, page.moreResultsAvailable()); page = BatchingVisitables.getFirstPage(visitor, 1); assertEquals("page results had wrong size!", 1, page.getResults().size()); assertEquals("page.getResults was wrong", Lists.newArrayList(0L), page.getResults()); assertEquals("page.moreResultsAvailable was wrong", true, page.moreResultsAvailable()); page = BatchingVisitables.getFirstPage(visitor, 3); assertEquals("page results had wrong size!", 3, page.getResults().size()); assertEquals("page.getResults was wrong", Lists.newArrayList(0L, 1L, 2L), page.getResults()); assertEquals("page.moreResultsAvailable was wrong", true, page.moreResultsAvailable()); page = BatchingVisitables.getFirstPage(visitor, 4); assertEquals("page results had wrong size!", 4, page.getResults().size()); assertEquals("page.getResults was wrong", Lists.newArrayList(0L, 1L, 2L, 3L), page.getResults()); assertEquals("page.moreResultsAvailable was wrong", false, page.moreResultsAvailable()); page = BatchingVisitables.getFirstPage(visitor, 7); assertEquals("page results had wrong size!", 4, page.getResults().size()); assertEquals("page.getResults was wrong", Lists.newArrayList(0L, 1L, 2L, 3L), page.getResults()); assertEquals("page.moreResultsAvailable was wrong", false, page.moreResultsAvailable()); try { BatchingVisitables.getFirstPage(visitor, -1); fail("Should not allow visiting -1 elements."); } catch (IllegalArgumentException e) { // expected } }
@Test public void testVisitWhile() { List<Long> longList = Lists.newArrayList(0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L); BatchingVisitable<Long> visitable = ListVisitor.create(longList); BatchingVisitableView<Long> view = BatchingVisitables.visitWhile( BatchingVisitableView.of(visitable), (input) -> input.longValue() < 5L); assertEquals("visitWhile visited the wrong number of elements", 5L, view.size()); assertEquals("visitWhile visited the wrong element first", 0L, view.getFirst().longValue()); assertEquals("visitWhile visited the wrong element last", 4L, view.getLast().longValue()); assertTrue("visitWhile visited the wrong elements", view.immutableCopy().containsAll(ImmutableSet.of(0L, 1L, 2L, 3L, 4L))); visitable = ListVisitor.create(Lists.reverse(longList)); view = BatchingVisitables.visitWhile( BatchingVisitableView.of(visitable), (input) -> input.longValue() >= 5L); assertEquals("visitWhile visited the wrong number of elements", 5L, view.size()); assertEquals("visitWhile visited the wrong element first", 9L, view.getFirst().longValue()); assertEquals("visitWhile visited the wrong element last", 5L, view.getLast().longValue()); assertTrue("visitWhile visited the wrong elements", view.immutableCopy().containsAll(ImmutableSet.of(5L, 6L, 7L, 8L, 9L))); }
@Test public void testBatchHints() { BatchingVisitable<Long> visitor = ListVisitor.create(Lists.newArrayList(0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L)); Function<List<Long>, List<String>> trans = (input) -> { assertEquals("batched item had wrong size", 2, input.size()); return Lists.transform(input, Functions.toStringFunction()); }; BatchingVisitableView<String> visitable = BatchingVisitableView.of(visitor).transformBatch(trans) .hintBatchSize(2); final Mutable<Boolean> hasTripped = Mutables.newMutable(); visitable.batchAccept(10000, item -> { hasTripped.set(true); assertEquals("batched item had wrong size", 8, item.size()); return false; }); assertTrue("should have been tripped!", hasTripped.get()); }
@Test public void testMinMax() { BatchingVisitable<Long> visitor = ListVisitor.create(Lists.newArrayList(0L, 1L, 2L, 3L)); assertEquals("BatchingVisitables.getMin was wrong", 0L, (long) BatchingVisitables.getMin(visitor)); assertEquals("BatchingVisitables.getMax was wrong", 3L, (long) BatchingVisitables.getMax(visitor)); BatchingVisitable<Pair<Long, Long>> pairedVisitable = ListVisitor.create(Lists.newArrayList( Pair.create(0L, 0L), Pair.create(1L, 0L), Pair.create(0L, 1L), Pair.create(1L, 1L))); Ordering<Pair<Long, Long>> ordering = Pair.compareLhSide(); assertEquals("BatchingVisitables.getMin was wrong", Pair.create(0L, 0L), BatchingVisitables.getMin(pairedVisitable, ordering, null)); assertEquals("BatchingVisitables.getMax was wrong", Pair.create(1L, 0L), BatchingVisitables.getMax(pairedVisitable, ordering, null)); }
public static <T> BatchingVisitable<T> create(List<T> list) { return new ListVisitor<>(list); }
@Test public void testBatchWrap() { BatchingVisitable<Long> visitor = ListVisitor.create(Lists.newArrayList(0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L)); final Mutable<Boolean> hasTripped = Mutables.newMutable(); AbortingVisitor<List<Object>, RuntimeException> bv = item -> { hasTripped.set(true); assertEquals("batched item had wrong size", 8, item.size()); return false; }; AbortingVisitor<List<Long>, RuntimeException> wrap = AbortingVisitors.wrapBatching(bv); BatchingVisitableView.of(visitor).batchAccept(1000, wrap); assertTrue("should have been tripped!", hasTripped.get()); }
@Test public void testBatchWrap2() { BatchingVisitable<Long> visitor = ListVisitor.create(Lists.newArrayList(0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L)); final Mutable<Boolean> hasTripped = Mutables.newMutable(); AbortingVisitor<List<? extends Long>, RuntimeException> bv = item -> { hasTripped.set(true); assertEquals("batched item had wrong size", 8, item.size()); return false; }; AbortingVisitor<List<Long>, RuntimeException> wrap = AbortingVisitors.wrapBatching(bv); BatchingVisitableView.of(visitor).batchAccept(1000, wrap); assertTrue("should have been tripped!", hasTripped.get()); }
@Test public void testAnyAndAllForNonEmptyLists() { BatchingVisitable<Long> visitor = ListVisitor.create(Lists.newArrayList(0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L)); BatchingVisitableView<Long> bv = BatchingVisitableView.of(visitor); assertTrue("any(true) should be true", bv.any(Predicates.alwaysTrue())); assertTrue("all(true) should be true", bv.all(Predicates.alwaysTrue())); assertFalse("any(false) should be false", bv.any(Predicates.alwaysFalse())); assertFalse("all(false) should be false", bv.all(Predicates.alwaysFalse())); }
@Test public void testConcat() { BatchingVisitable<Long> visitor = ListVisitor.create(Lists.newArrayList(0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L)); BatchingVisitableView<Long> limited = BatchingVisitableView.of(visitor).limit(3); BatchingVisitableView<Long> concat = BatchingVisitables.concat(limited, visitor); assertTrue("concatenated batchAccept should be true", concat.batchAccept(2, AbortingVisitors .batching(AbortingVisitors.alwaysTrue()))); }
@Test public void testEmpty() { assertTrue("empty batching visitable should be empty!", BatchingVisitables.isEmpty(BatchingVisitables.emptyBatchingVisitable())); assertEquals("empty batching visitable should be empty!", 0, BatchingVisitables.count(BatchingVisitables.emptyBatchingVisitable())); BatchingVisitable<Long> bv = ListVisitor.create(Lists.newArrayList(0L, 1L, 2L, 3L)); assertFalse("non-empty batching visitable should not be empty!", BatchingVisitables.isEmpty(bv)); assertEquals("visitable had wrong size", 4, BatchingVisitables.count(bv)); assertTrue("empty visitable should always be true, even when told to visit an always-false place", BatchingVisitables.emptyBatchingVisitable().batchAccept(1, AbortingVisitors.alwaysFalse())); }
@Test public void testUnique() { BatchingVisitable<Long> visitor = ListVisitor.create(Lists.newArrayList( 0L, 1L, 1L, 2L, 2L, 2L, 3L, 4L, 5L, 5L, 6L, 7L, 7L)); BatchingVisitableView<Long> bv = BatchingVisitableView.of(visitor); assertEquals("unexpected result for unique view", ImmutableList.of(0L, 1L, 2L, 3L), bv.unique().limit(4).immutableCopy()); }
@Test public void testSkip() { BatchingVisitable<Long> visitor = ListVisitor.create(Lists.newArrayList(0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L)); ImmutableList<Long> copy = BatchingVisitableView.of(visitor).skip(5).immutableCopy(); assertEquals("unexpected list remnants after skipping", ImmutableList.of(5L, 6L, 7L), copy); }