private void fill() { while (emit()) { } }
@Test public void testAddAllEmitInHandler() { context.runOnContext(v1 -> { buffer = new InboundBuffer<>(context, 4L); List<Integer> emitted = new ArrayList<>(); buffer.handler(elt -> { switch (elt) { case 0: emit(); } emitted.add(elt); }); assertTrue(emit(3)); assertEquals(Arrays.asList(0, 1, 2, 3), emitted); testComplete(); }); await(); }
@Test public void testFlowingAdd() { context.runOnContext(v -> { buffer = new InboundBuffer<>(context); AtomicInteger events = new AtomicInteger(); buffer.handler(elt -> { checkContext(); events.getAndIncrement(); }); assertTrue(emit()); assertEquals(1, events.get()); assertTrue(emit()); assertEquals(2, events.get()); testComplete(); }); await(); }
@Test public void testAddAllWhenDelivering() { context.runOnContext(v1 -> { buffer = new InboundBuffer<>(context, 4L); List<Integer> emitted = new ArrayList<>(); buffer.handler(elt -> { emitted.add(elt); if (elt == 2) { buffer.write(Arrays.asList(4, 5)); // Check that we haven't re-entered the handler assertEquals(Arrays.asList(0, 1, 2), emitted); } }); emit(4); assertEquals(Arrays.asList(0, 1, 2, 3, 4, 5), emitted); testComplete(); }); await(); }
@Test public void testEmitInElementHandler() { context.runOnContext(v1 -> { buffer = new InboundBuffer<>(context, 4L); AtomicInteger events = new AtomicInteger(); AtomicBoolean receiving = new AtomicBoolean(); buffer.handler(s -> { checkContext(); assertFalse(receiving.getAndSet(true)); events.incrementAndGet(); if (s == 0) { fill(); } receiving.set(false); }); assertTrue(emit()); assertEquals(6, sequence.get()); assertEquals(6, events.get()); testComplete(); }); await(); }
@Test public void testDrainAfter() { context.runOnContext(v1 -> { buffer = new InboundBuffer<>(context, 4L); AtomicInteger events = new AtomicInteger(); AtomicBoolean receiving = new AtomicBoolean(); buffer.handler(s -> { checkContext(); assertFalse(receiving.getAndSet(true)); events.incrementAndGet(); if (s == 0) { fill(); } receiving.set(false); }); assertTrue(emit()); assertEquals(6, sequence.get()); assertEquals(6, events.get()); testComplete(); }); await(); }
@Test public void testBilto1() { context.runOnContext(v1 -> { buffer = new InboundBuffer<>(context, 4L); AtomicInteger drained = new AtomicInteger(); AtomicInteger expectedDrained = new AtomicInteger(); buffer.drainHandler(v2 -> { switch (drained.getAndIncrement()) { case 0: // Check that emitting again will not drain again expectedDrained.set(1); assertTrue(emit()); context.runOnContext(v -> { assertEquals(1, drained.get()); testComplete(); }); break; } }); buffer.handler(val -> { if (val == 0) { // This will set writable to false fill(); } assertEquals(expectedDrained.get(), drained.get()); }); assertTrue(emit()); }); await(); }
@Test public void testEmptyHandler() { context.runOnContext(v1 -> { buffer = new InboundBuffer<>(context, 4L); AtomicInteger emptyCount = new AtomicInteger(); AtomicInteger itemCount = new AtomicInteger(); buffer.handler(item -> itemCount.incrementAndGet()); buffer.emptyHandler(v2 -> { assertEquals(0, emptyCount.getAndIncrement()); testComplete(); }); assertTrue(emit()); assertEquals(1, itemCount.get()); buffer.pause(); assertTrue(emit()); assertTrue(emit()); assertTrue(emit()); assertEquals(1, itemCount.get()); assertFalse(buffer.isEmpty()); for (int i = 0;i < 3;i++) { assertEquals(0, emptyCount.get()); buffer.fetch(1); } }); await(); }
assertEquals(0, reads.get()); assertEquals(0, events.get()); assertTrue(emit()); assertEquals(0, reads.get()); waitUntilEquals(1, events::get); assertTrue(emit()); assertEquals(0, reads.get()); assertEquals(1, events.get()); assertTrue(emit()); assertEquals(0, reads.get()); assertEquals(1, events.get()); assertFalse(emit()); assertEquals(0, reads.get()); assertEquals(1, events.get());
@Test public void testBufferSignalingFullImmediately() { context.runOnContext(v1 -> { buffer = new InboundBuffer<>(context, 0L); List<Integer> emitted = new ArrayList<>(); buffer.drainHandler(v -> { assertEquals(Arrays.asList(0, 1), emitted); testComplete(); }); buffer.handler(emitted::add); assertTrue(emit()); assertEquals(Collections.singletonList(0), emitted); buffer.pause(); assertFalse(emit()); buffer.resume(); }); await(); } }
@Test public void testAddAllWhenFlowing() { context.runOnContext(v1 -> { buffer = new InboundBuffer<>(context, 4L); AtomicInteger emitted = new AtomicInteger(); AtomicInteger emptied = new AtomicInteger(); AtomicInteger drained = new AtomicInteger(); buffer.handler(item -> emitted.incrementAndGet()); buffer.emptyHandler(v2 -> emptied.incrementAndGet()); buffer.drainHandler(v2 -> drained.incrementAndGet()); assertTrue(emit(4)); context.runOnContext(v -> { waitUntilEquals(0, drained::get); waitUntilEquals(0, emptied::get); waitUntilEquals(4, emitted::get); testComplete(); }); }); await(); }
if (drained.compareAndSet(false, true)) { emit(); } else { assertEquals(11, events.get());
@Test public void testFlowing() { context.runOnContext(v -> { buffer = new InboundBuffer<>(context); AtomicInteger events = new AtomicInteger(); buffer.handler(elt -> { checkContext(); assertEquals(0, (int)elt); assertEquals(0, events.getAndIncrement()); testComplete(); }); assertTrue(emit()); }); await(); }
}); buffer.pause(); assertFalse(emit(5)); buffer.fetch(1); complete();
@Test public void testPauseWhenFull() { context.runOnContext(v1 -> { buffer = new InboundBuffer<>(context, 4L); AtomicInteger events = new AtomicInteger(); AtomicInteger reads = new AtomicInteger(); buffer.drainHandler(v2 -> { checkContext(); assertEquals(0, reads.getAndIncrement()); }); buffer.handler(s -> { checkContext(); assertEquals(0, reads.get()); assertEquals(0, events.getAndIncrement()); testComplete(); }); buffer.pause(); for (int i = 0; i < 5;i++) { assertEquals(i < 4, emit()); } buffer.fetch(1); }); await(); }
@Test public void testPauseInElementHandler() { context.runOnContext(v1 -> { buffer = new InboundBuffer<>(context, 4L); AtomicInteger events = new AtomicInteger(); buffer.handler(s -> { events.incrementAndGet(); if (s == 0) { fill(); buffer.pause(); } }); assertFalse(emit()); assertEquals(1, events.get()); assertEquals(5, buffer.size()); testComplete(); }); await(); }
@Test public void testTake() { context.runOnContext(v -> { buffer = new InboundBuffer<>(context); AtomicInteger events = new AtomicInteger(); buffer.handler(elt -> { checkContext(); assertEquals(0, (int)elt); assertEquals(0, events.getAndIncrement()); testComplete(); }); buffer.pause(); buffer.fetch(1); assertTrue(emit()); }); await(); }
@Test public void testFlowingRefill() { context.runOnContext(v1 -> { buffer = new InboundBuffer<>(context, 4L); AtomicInteger events = new AtomicInteger(); buffer.handler(s -> { checkContext(); events.getAndIncrement(); }); buffer.drainHandler(v2 -> { checkContext(); assertEquals(8, events.get()); testComplete(); }); buffer.pause(); for (int i = 0;i < 8;i++) { assertEquals("Expected " + i + " to be bilto", i < 4, emit()); } buffer.resume(); }); await(); }