@Test public void testConsistentCloseOrder() { final AtomicInteger closed1 = new AtomicInteger(); final AtomicInteger closed2 = new AtomicInteger(); final AtomicInteger counter = new AtomicInteger(); Sequence<Integer> sequence = Sequences .simple(Arrays.asList(1, 2, 3)) .withBaggage(() -> closed1.set(counter.incrementAndGet())) .withBaggage(() -> closed2.set(counter.incrementAndGet())); // Run sequence via accumulate sequence.toList(); Assert.assertEquals(1, closed1.get()); Assert.assertEquals(2, closed2.get()); // Ensure sequence runs via Yielder, because LimitedSequence extends YieldingSequenceBase Sequence<Integer> yieldingSequence = sequence.limit(1); yieldingSequence.toList(); Assert.assertEquals(3, closed1.get()); Assert.assertEquals(4, closed2.get()); } }
@Test public void testSanity() throws Exception { final AtomicInteger closedCounter = new AtomicInteger(0); Closeable closeable = () -> closedCounter.incrementAndGet(); final List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5); SequenceTestHelper.testAll(Sequences.simple(nums).withBaggage(closeable), nums); Assert.assertEquals(3, closedCounter.get()); closedCounter.set(0); SequenceTestHelper.testClosed(closedCounter, new UnsupportedSequence().withBaggage(closeable)); }
@Test public void testEffectExecutedIfWrappedSequenceThrowsExceptionFromClose() { Sequence<Integer> baseSeq = Sequences.simple(Arrays.asList(1, 2, 3)); Sequence<Integer> throwingSeq = baseSeq.withBaggage(() -> { throw new RuntimeException(); }); final AtomicBoolean effectExecuted = new AtomicBoolean(); Sequence<Integer> seqWithEffect = throwingSeq.withEffect(() -> effectExecuted.set(true), Execs.directExecutor()); try { seqWithEffect.toList(); Assert.fail("expected RuntimeException"); } catch (RuntimeException e) { // expected Assert.assertTrue(effectExecuted.get()); } } }
).withBaggage(bufferHolder);
Sequences.simple(pairs).withBaggage(closeable), Ordering.natural().onResultOf(p -> p.lhs), (lhs, rhs) -> {
).withBaggage(bufferHolder);