public DummyEventProcessor() { this(new Sequence(SingleProducerSequencer.INITIAL_CURSOR_VALUE)); }
/** * Creates an event poller for this sequence that will use the supplied data provider and * gating sequences. * * @param dataProvider The data source for users of this event poller * @param gatingSequences Sequence to be gated on. * @return A poller that will gate on this ring buffer and the supplied sequences. */ @Override public <T> EventPoller<T> newPoller(DataProvider<T> dataProvider, Sequence... gatingSequences) { return EventPoller.newInstance(dataProvider, this, new Sequence(), cursor, gatingSequences); }
@Test public void shouldWaitForWorkCompleteWhereCompleteWorkThresholdIsAhead() throws Exception { final long expectedNumberMessages = 10; final long expectedWorkSequence = 9; fillRingBuffer(expectedNumberMessages); final Sequence sequence1 = new Sequence(expectedNumberMessages); final Sequence sequence2 = new Sequence(expectedWorkSequence); final Sequence sequence3 = new Sequence(expectedNumberMessages); final SequenceBarrier sequenceBarrier = ringBuffer.newBarrier(sequence1, sequence2, sequence3); long completedWorkSequence = sequenceBarrier.waitFor(expectedWorkSequence); assertTrue(completedWorkSequence >= expectedWorkSequence); }
@Before public void setUp() throws Exception { consumerRepository = new ConsumerRepository<TestEvent>(); eventProcessor1 = new DummyEventProcessor(new Sequence()); eventProcessor2 = new DummyEventProcessor(new Sequence()); eventProcessor1.run(); eventProcessor2.run(); handler1 = new SleepingEventHandler(); handler2 = new SleepingEventHandler(); barrier1 = new DummySequenceBarrier(); barrier2 = new DummySequenceBarrier(); }
public static void assertWaitForWithDelayOf(long sleepTimeMillis, WaitStrategy waitStrategy) throws InterruptedException, BrokenBarrierException, AlertException, TimeoutException { SequenceUpdater sequenceUpdater = new SequenceUpdater(sleepTimeMillis, waitStrategy); EXECUTOR.execute(sequenceUpdater); sequenceUpdater.waitForStartup(); Sequence cursor = new Sequence(0); long sequence = waitStrategy.waitFor(0, cursor, sequenceUpdater.sequence, new DummySequenceBarrier()); assertThat(sequence, is(0L)); } }
@Test public void shouldReturnMinimumOf2Sequences() throws Exception { Sequence sequence1 = new Sequence(34); Sequence sequnece2 = new Sequence(47); Sequence group = new FixedSequenceGroup(new Sequence[]{sequence1, sequnece2}); assertThat(group.get(), is(34L)); sequence1.set(35); assertThat(group.get(), is(35L)); sequence1.set(48); assertThat(group.get(), is(47L)); } }
@Test public void shouldReportTheMinimumSequenceForGroupOfTwo() { final Sequence sequenceThree = new Sequence(3L); final Sequence sequenceSeven = new Sequence(7L); final SequenceGroup sequenceGroup = new SequenceGroup(); sequenceGroup.add(sequenceSeven); sequenceGroup.add(sequenceThree); assertEquals(sequenceThree.get(), sequenceGroup.get()); }
@Test public void shouldTryPublishEvent() throws Exception { ringBuffer.addGatingSequences(new Sequence()); for (int i = 0; i < BUFFER_SIZE; i++) { assertThat(ringBuffer.tryPublishEvent(this), is(true)); } for (int i = 0; i < BUFFER_SIZE; i++) { assertThat(Long.valueOf(ringBuffer.get(i).get()), is(Long.valueOf(i + 29L))); } assertThat(ringBuffer.tryPublishEvent(this), is(false)); }
@Test public void shouldAddWhileRunning() throws Exception { RingBuffer<TestEvent> ringBuffer = RingBuffer.createSingleProducer(TestEvent.EVENT_FACTORY, 32); final Sequence sequenceThree = new Sequence(3L); final Sequence sequenceSeven = new Sequence(7L); final SequenceGroup sequenceGroup = new SequenceGroup(); sequenceGroup.add(sequenceSeven); for (int i = 0; i < 11; i++) { ringBuffer.publish(ringBuffer.next()); } sequenceGroup.addWhileRunning(ringBuffer, sequenceThree); assertThat(sequenceThree.get(), is(10L)); } }
@Test public void shouldTimeoutWaitFor() throws Exception { final SequenceBarrier sequenceBarrier = new DummySequenceBarrier(); long theTimeout = 500; TimeoutBlockingWaitStrategy waitStrategy = new TimeoutBlockingWaitStrategy(theTimeout, TimeUnit.MILLISECONDS); Sequence cursor = new Sequence(5); Sequence dependent = cursor; long t0 = System.currentTimeMillis(); try { waitStrategy.waitFor(6, cursor, dependent, sequenceBarrier); fail("TimeoutException should have been thrown"); } catch (TimeoutException e) { } long t1 = System.currentTimeMillis(); long timeWaiting = t1 - t0; assertTrue(timeWaiting >= theTimeout); } }
@Test public void shouldSetGroupSequenceToSameValue() { final Sequence sequenceThree = new Sequence(3L); final Sequence sequenceSeven = new Sequence(7L); final SequenceGroup sequenceGroup = new SequenceGroup(); sequenceGroup.add(sequenceSeven); sequenceGroup.add(sequenceThree); final long expectedSequence = 11L; sequenceGroup.set(expectedSequence); assertEquals(expectedSequence, sequenceThree.get()); assertEquals(expectedSequence, sequenceSeven.get()); }
@Test public void shouldAddAndRemoveSequences() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 16); Sequence sequenceThree = new Sequence(-1); Sequence sequenceSeven = new Sequence(-1); ringBuffer.addGatingSequences(sequenceThree, sequenceSeven); for (int i = 0; i < 10; i++) { ringBuffer.publish(ringBuffer.next()); } sequenceThree.set(3); sequenceSeven.set(7); assertThat(ringBuffer.getMinimumGatingSequence(), is(3L)); assertTrue(ringBuffer.removeGatingSequence(sequenceThree)); assertThat(ringBuffer.getMinimumGatingSequence(), is(7L)); }
@Test public void shouldAddOneSequenceToGroup() { final Sequence sequence = new Sequence(7L); final SequenceGroup sequenceGroup = new SequenceGroup(); sequenceGroup.add(sequence); assertEquals(sequence.get(), sequenceGroup.get()); }
@Test public void shouldRemoveSequenceFromGroup() { final Sequence sequenceThree = new Sequence(3L); final Sequence sequenceSeven = new Sequence(7L); final SequenceGroup sequenceGroup = new SequenceGroup(); sequenceGroup.add(sequenceSeven); sequenceGroup.add(sequenceThree); assertEquals(sequenceThree.get(), sequenceGroup.get()); assertTrue(sequenceGroup.remove(sequenceThree)); assertEquals(sequenceSeven.get(), sequenceGroup.get()); assertEquals(1, sequenceGroup.size()); }
@SuppressWarnings("deprecation") private void assertHandleResetAndNotWrap(RingBuffer<StubEvent> rb) { Sequence sequence = new Sequence(); rb.addGatingSequences(sequence); for (int i = 0; i < 128; i++) { rb.publish(rb.next()); sequence.incrementAndGet(); } assertThat(rb.getCursor(), is(127L)); rb.resetTo(31); sequence.set(31); for (int i = 0; i < 4; i++) { rb.publish(rb.next()); } assertThat(rb.hasAvailableCapacity(1), is(false)); }
@Test public void shouldRemoveSequenceFromGroupWhereItBeenAddedMultipleTimes() { final Sequence sequenceThree = new Sequence(3L); final Sequence sequenceSeven = new Sequence(7L); final SequenceGroup sequenceGroup = new SequenceGroup(); sequenceGroup.add(sequenceThree); sequenceGroup.add(sequenceSeven); sequenceGroup.add(sequenceThree); assertEquals(sequenceThree.get(), sequenceGroup.get()); assertTrue(sequenceGroup.remove(sequenceThree)); assertEquals(sequenceSeven.get(), sequenceGroup.get()); assertEquals(1, sequenceGroup.size()); }
@Test public void shouldPreventWrapping() throws Exception { Sequence sequence = new Sequence(Sequencer.INITIAL_CURSOR_VALUE); final RingBuffer<StubEvent> ringBuffer = createMultiProducer(StubEvent.EVENT_FACTORY, 4); ringBuffer.addGatingSequences(sequence); ringBuffer.publishEvent(StubEvent.TRANSLATOR, 0, "0"); ringBuffer.publishEvent(StubEvent.TRANSLATOR, 1, "1"); ringBuffer.publishEvent(StubEvent.TRANSLATOR, 2, "2"); ringBuffer.publishEvent(StubEvent.TRANSLATOR, 3, "3"); assertFalse(ringBuffer.tryPublishEvent(StubEvent.TRANSLATOR, 3, "3")); }