/** * Create a new single producer RingBuffer using the default wait strategy {@link BlockingWaitStrategy}. * * @param <E> Class of the event stored in the ring buffer. * @param factory used to create the events within the ring buffer. * @param bufferSize number of elements to create within the ring buffer. * @return a constructed ring buffer. * @throws IllegalArgumentException if <code>bufferSize</code> is less than 1 or not a power of 2 * @see MultiProducerSequencer */ public static <E> RingBuffer<E> createSingleProducer(EventFactory<E> factory, int bufferSize) { return createSingleProducer(factory, bufferSize, new BlockingWaitStrategy()); }
@Test public void shouldHandleResetToAndNotWrapUnnecessarilySingleProducer() throws Exception { assertHandleResetAndNotWrap(RingBuffer.createSingleProducer(StubEvent.EVENT_FACTORY, 4)); }
@Test public void shouldPublishEventsTwoArgWithBatchSizeOfOne() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorTwoArg<Object[], String, String> translator = new TwoArgEventTranslator(); ringBuffer.publishEvents(translator, 0, 1, new String[]{"Foo0", "Foo1"}, new String[]{"Bar0", "Bar1"}); ringBuffer.tryPublishEvents(translator, 0, 1, new String[]{"Foo2", "Foo3"}, new String[]{"Bar2", "Bar3"}); assertThat( ringBuffer, ringBufferWithEvents( is((Object) "Foo0Bar0-0"), is((Object) "Foo2Bar2-1"), is( nullValue()), is(nullValue()))); }
@Test public void shouldPublishEventsOneArgBatchSizeOfOne() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorOneArg<Object[], String> translator = new OneArgEventTranslator(); ringBuffer.publishEvents(translator, 0, 1, new String[]{"Foo", "Foo"}); assertTrue(ringBuffer.tryPublishEvents(translator, 0, 1, new String[]{"Foo", "Foo"})); assertThat( ringBuffer, ringBufferWithEvents( is((Object) "Foo-0"), is((Object) "Foo-1"), is(nullValue()), is( nullValue()))); }
@Test(expected = IllegalArgumentException.class) public void shouldNotPublishEventsOneArgWhenBatchExtendsPastEndOfArray() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorOneArg<Object[], String> translator = new OneArgEventTranslator(); try { ringBuffer.publishEvents(translator, 1, 3, new String[]{"Foo", "Foo"}); } finally { assertEmptyRingBuffer(ringBuffer); } }
@Test(expected = IllegalArgumentException.class) public void shouldNotTryPublishEventsOneArgWhenBatchExtendsPastEndOfArray() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorOneArg<Object[], String> translator = new OneArgEventTranslator(); try { ringBuffer.tryPublishEvents(translator, 1, 3, new String[]{"Foo", "Foo"}); } finally { assertEmptyRingBuffer(ringBuffer); } }
@Test(expected = IllegalArgumentException.class) public void shouldNotTryPublishEventsOneArgWhenBatchStartsAtIsNegative() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorOneArg<Object[], String> translator = new OneArgEventTranslator(); try { ringBuffer.tryPublishEvents(translator, -1, 2, new String[]{"Foo", "Foo"}); } finally { assertEmptyRingBuffer(ringBuffer); } }
@SuppressWarnings("unchecked") @Test(expected = IllegalArgumentException.class) public void shouldNotPublishEventsWhenBatchSizeIs0() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslator<Object[]> translator = new NoArgEventTranslator(); try { ringBuffer.publishEvents(new EventTranslator[]{translator, translator, translator, translator}, 1, 0); } finally { assertEmptyRingBuffer(ringBuffer); } }
@Test public void shouldPublishEventsTwoArgWithinBatch() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorTwoArg<Object[], String, String> translator = new TwoArgEventTranslator(); ringBuffer.publishEvents( translator, 1, 2, new String[]{"Foo0", "Foo1", "Foo2"}, new String[]{"Bar0", "Bar1", "Bar2"}); ringBuffer.tryPublishEvents( translator, 1, 2, new String[]{"Foo3", "Foo4", "Foo5"}, new String[]{"Bar3", "Bar4", "Bar5"}); assertThat(ringBuffer, ringBufferWithEvents("Foo1Bar1-0", "Foo2Bar2-1", "Foo4Bar4-2", "Foo5Bar5-3")); }
@Test public void shouldPublishEvent() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); final EventTranslator<Object[]> translator = new NoArgEventTranslator(); ringBuffer.publishEvent(translator); ringBuffer.tryPublishEvent(translator); assertThat(ringBuffer, ringBufferWithEvents(0L, 1L)); }
@Test public void shouldPublishEventThreeArg() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorThreeArg<Object[], String, String, String> translator = new ThreeArgEventTranslator(); ringBuffer.publishEvent(translator, "Foo", "Bar", "Baz"); ringBuffer.tryPublishEvent(translator, "Foo", "Bar", "Baz"); assertThat(ringBuffer, ringBufferWithEvents("FooBarBaz-0", "FooBarBaz-1")); }
@Test public void shouldPublishEventVarArg() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorVararg<Object[]> translator = new VarArgEventTranslator(); ringBuffer.publishEvent(translator, "Foo", "Bar", "Baz", "Bam"); ringBuffer.tryPublishEvent(translator, "Foo", "Bar", "Baz", "Bam"); assertThat(ringBuffer, ringBufferWithEvents("FooBarBazBam-0", "FooBarBazBam-1")); }
@Test public void shouldPublishEventsThreeArg() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorThreeArg<Object[], String, String, String> translator = new ThreeArgEventTranslator(); ringBuffer.publishEvents( translator, new String[]{"Foo", "Foo"}, new String[]{"Bar", "Bar"}, new String[]{"Baz", "Baz"}); ringBuffer.tryPublishEvents( translator, new String[]{"Foo", "Foo"}, new String[]{"Bar", "Bar"}, new String[]{"Baz", "Baz"}); assertThat(ringBuffer, ringBufferWithEvents("FooBarBaz-0", "FooBarBaz-1", "FooBarBaz-2", "FooBarBaz-3")); }
@Test public void shouldPublishEventOneArg() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorOneArg<Object[], String> translator = new OneArgEventTranslator(); ringBuffer.publishEvent(translator, "Foo"); ringBuffer.tryPublishEvent(translator, "Foo"); assertThat(ringBuffer, ringBufferWithEvents("Foo-0", "Foo-1")); }
@Test public void shouldPublishEventTwoArg() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorTwoArg<Object[], String, String> translator = new TwoArgEventTranslator(); ringBuffer.publishEvent(translator, "Foo", "Bar"); ringBuffer.tryPublishEvent(translator, "Foo", "Bar"); assertThat(ringBuffer, ringBufferWithEvents("FooBar-0", "FooBar-1")); }
@Test public void shouldPublishEventsTwoArg() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorTwoArg<Object[], String, String> translator = new TwoArgEventTranslator(); ringBuffer.publishEvents(translator, new String[]{"Foo", "Foo"}, new String[]{"Bar", "Bar"}); ringBuffer.tryPublishEvents(translator, new String[]{"Foo", "Foo"}, new String[]{"Bar", "Bar"}); assertThat(ringBuffer, ringBufferWithEvents("FooBar-0", "FooBar-1", "FooBar-2", "FooBar-3")); }
@SuppressWarnings("unchecked") @Test public void shouldPublishEventsWithinBatch() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); final EventTranslator<Object[]> eventTranslator = new NoArgEventTranslator(); final EventTranslator<Object[]>[] translators = new EventTranslator[]{eventTranslator, eventTranslator, eventTranslator}; ringBuffer.publishEvents(translators, 1, 2); assertTrue(ringBuffer.tryPublishEvents(translators, 1, 2)); assertThat(ringBuffer, ringBufferWithEvents(0L, 1L, 2L, 3L)); }
@SuppressWarnings("unchecked") @Test public void shouldPublishEvents() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); final EventTranslator<Object[]> eventTranslator = new NoArgEventTranslator(); final EventTranslator<Object[]>[] translators = new EventTranslator[]{eventTranslator, eventTranslator}; ringBuffer.publishEvents(translators); assertTrue(ringBuffer.tryPublishEvents(translators)); assertThat(ringBuffer, ringBufferWithEvents(0L, 1L, 2L, 3L)); }
@Test public void shouldPublishEventsOneArgWithinBatch() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorOneArg<Object[], String> translator = new OneArgEventTranslator(); ringBuffer.publishEvents(translator, 1, 2, new String[]{"Foo", "Foo", "Foo"}); assertTrue(ringBuffer.tryPublishEvents(translator, 1, 2, new String[]{"Foo", "Foo", "Foo"})); assertThat(ringBuffer, ringBufferWithEvents("Foo-0", "Foo-1", "Foo-2", "Foo-3")); }
@Test public void shouldPublishEventsOneArg() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorOneArg<Object[], String> translator = new OneArgEventTranslator(); ringBuffer.publishEvents(translator, new String[]{"Foo", "Foo"}); assertTrue(ringBuffer.tryPublishEvents(translator, new String[]{"Foo", "Foo"})); assertThat(ringBuffer, ringBufferWithEvents("Foo-0", "Foo-1", "Foo-2", "Foo-3")); }