Exemple #1
0
        public void Should_Not_Publish_Events_Two_Arg_When_Batch_Extends_Past_End_Of_Array()
        {
            var ringBuffer = RingBuffer <object[]> .CreateSingleProducer(new ArrayFactory(1), 4);

            var translator = new TwoArgEventTranslator();

            Assert.Throws <ArgumentException>(() => ringBuffer.PublishEvents(translator, 1, 3, new[] { "Foo", "Foo" }, new[] { "Foo", "Foo" }));
            AssertEmptyRingBuffer(ringBuffer);
        }
Exemple #2
0
        public void Should_Not_Try_Publish_Events_Two_Arg_When_Batch_Starts_At_Is_Negative()
        {
            var ringBuffer = RingBuffer <object[]> .CreateSingleProducer(new ArrayFactory(1), 4);

            var translator = new TwoArgEventTranslator();

            Assert.Throws <ArgumentException>(() => ringBuffer.TryPublishEvents(translator, -1, 1, new[] { "Foo", "Foo" }, new[] { "Foo", "Foo" }));
            AssertEmptyRingBuffer(ringBuffer);
        }
Exemple #3
0
        public void Should_Publish_Events_Two_Arg_With_Batch_Size_Of_One()
        {
            var ringBuffer = RingBuffer <object[]> .CreateSingleProducer(new ArrayFactory(1), 4);

            var translator = new TwoArgEventTranslator();

            ringBuffer.PublishEvents(translator, 0, 1, new[] { "Foo0", "Foo1" }, new[] { "Bar0", "Bar1" });
            ringBuffer.TryPublishEvents(translator, 0, 1, new[] { "Foo2", "Foo3" }, new[] { "Bar2", "Bar3" });
        }
Exemple #4
0
        public void ShouldPublishEventTwoArg()
        {
            var ringBuffer = RingBuffer <object[]> .CreateSingleProducer(() => new object[1], 4);

            IEventTranslatorTwoArg <object[], string, string> translator = new TwoArgEventTranslator();

            ringBuffer.PublishEvent(translator, "Foo", "Bar");
            ringBuffer.TryPublishEvent(translator, "Foo", "Bar");

            Assert.That(ringBuffer, IsRingBufferWithEvents("FooBar-0", "FooBar-1"));
        }
Exemple #5
0
        public void ShouldPublishEventsTwoArgWithBatchSizeOfOne()
        {
            var ringBuffer = RingBuffer <object[]> .CreateSingleProducer(() => new object[1], 4);

            IEventTranslatorTwoArg <object[], string, string> translator = new TwoArgEventTranslator();

            ringBuffer.PublishEvents(translator, 0, 1, new[] { "Foo0", "Foo1" }, new[] { "Bar0", "Bar1" });
            ringBuffer.TryPublishEvents(translator, 0, 1, new[] { "Foo2", "Foo3" }, new[] { "Bar2", "Bar3" });

            Assert.That(ringBuffer, IsRingBufferWithEvents("Foo0Bar0-0", "Foo2Bar2-1", null, null));
        }
Exemple #6
0
        public void ShouldPublishEventsTwoArgWithinBatch()
        {
            var ringBuffer = RingBuffer <object[]> .CreateSingleProducer(() => new object[1], 4);

            IEventTranslatorTwoArg <object[], string, string> translator = new TwoArgEventTranslator();

            ringBuffer.PublishEvents(
                translator, 1, 2, new[] { "Foo0", "Foo1", "Foo2" }, new[] { "Bar0", "Bar1", "Bar2" });
            ringBuffer.TryPublishEvents(
                translator, 1, 2, new[] { "Foo3", "Foo4", "Foo5" }, new[] { "Bar3", "Bar4", "Bar5" });

            Assert.That(ringBuffer, IsRingBufferWithEvents("Foo1Bar1-0", "Foo2Bar2-1", "Foo4Bar4-2", "Foo5Bar5-3"));
        }
Exemple #7
0
        public void Should_Not_Publish_Events_Two_Arg_If_Batch_Size_Is_Bigger_Than_RingBuffer()
        {
            var ringBuffer = RingBuffer <object[]> .CreateSingleProducer(new ArrayFactory(1), 4);

            var translator = new TwoArgEventTranslator();

            Assert.Throws <ArgumentException>(() => ringBuffer.TryPublishEvents(
                                                  translator,
                                                  new[] { "Foo", "Foo", "Foo", "Foo", "Foo" },
                                                  new[] { "Bar", "Bar", "Bar", "Bar", "Bar" }));

            AssertEmptyRingBuffer(ringBuffer);
        }
Exemple #8
0
        public void ShouldNotTryPublishEventsTwoArgWhenBatchStartsAtIsNegative()
        {
            var ringBuffer = RingBuffer <object[]> .CreateSingleProducer(() => new object[1], 4);

            IEventTranslatorTwoArg <object[], string, string> translator = new TwoArgEventTranslator();

            try
            {
                Assert.Throws <ArgumentException>(() => ringBuffer.TryPublishEvents(translator, -1, 2, new[] { "Foo", "Foo" }, new[] { "Bar", "Bar" }));
            }
            finally
            {
                AssertEmptyRingBuffer(ringBuffer);
            }
        }
Exemple #9
0
        public void ShouldNotPublishEventsTwoArgWhenBatchExtendsPastEndOfArray()
        {
            var ringBuffer = RingBuffer <object[]> .CreateSingleProducer(() => new object[1], 4);

            IEventTranslatorTwoArg <object[], string, string> translator = new TwoArgEventTranslator();

            try
            {
                Assert.Throws <ArgumentException>(() => ringBuffer.PublishEvents(translator, 1, 3, new[] { "Foo", "Foo" }, new[] { "Bar", "Bar" }));
            }
            finally
            {
                AssertEmptyRingBuffer(ringBuffer);
            }
        }
Exemple #10
0
        public void Should_Publish_Event_Two_Arg()
        {
            var ringBuffer = RingBuffer <object[]> .CreateSingleProducer(new ArrayFactory(1), 4);

            var translator = new TwoArgEventTranslator();

            ringBuffer.PublishEvent(translator, "Arg0", "Arg1");
            ringBuffer.TryPublishEvent(translator, "Arg0", "Arg1");

            var matcher = new RingBufferEventMatcher(ringBuffer);

            Assert.True(matcher.RingBufferWithEvents(new object[1] {
                "Arg0Arg1-0"
            }, new object[1] {
                "Arg0Arg1-1"
            }));
        }
Exemple #11
0
        public void ShouldNotPublishEventsITwoArgIfBatchSizeIsBiggerThanRingBuffer()
        {
            var ringBuffer = RingBuffer <object[]> .CreateSingleProducer(() => new object[1], 4);

            IEventTranslatorTwoArg <object[], string, string> translator = new TwoArgEventTranslator();

            try
            {
                Assert.Throws <ArgumentException>(() => ringBuffer.TryPublishEvents(
                                                      translator,
                                                      new[] { "Foo", "Foo", "Foo", "Foo", "Foo" },
                                                      new[] { "Bar", "Bar", "Bar", "Bar", "Bar" }));
                ;
            }
            finally
            {
                AssertEmptyRingBuffer(ringBuffer);
            }
        }
Exemple #12
0
        public void Should_Publish_Events_Two_Arg()
        {
            var ringBuffer = RingBuffer <object[]> .CreateSingleProducer(new ArrayFactory(1), 4);

            var translator = new TwoArgEventTranslator();

            ringBuffer.PublishEvents(translator, new[] { "Foo", "Hoo" }, new[] { "Bar", "Car" });
            Assert.True(ringBuffer.TryPublishEvents(translator, new[] { "Foo", "Hoo" }, new[] { "Bar", "Car" }));

            var matcher = new RingBufferEventMatcher(ringBuffer);

            Assert.True(matcher.RingBufferWithEvents(new object[1] {
                "FooBar-0"
            }, new object[1] {
                "HooCar-1"
            }, new object[1] {
                "FooBar-2"
            }, new object[1] {
                "HooCar-3"
            }));
        }
Exemple #13
0
        public void Should_Publish_Events_Two_Arg_Within_Batch()
        {
            var ringBuffer = RingBuffer <object[]> .CreateSingleProducer(new ArrayFactory(1), 4);

            var translator = new TwoArgEventTranslator();

            ringBuffer.PublishEvents(
                translator, 1, 2, new[] { "Foo0", "Foo1", "Foo2" }, new[] { "Bar0", "Bar1", "Bar2" });
            ringBuffer.TryPublishEvents(
                translator, 1, 2, new[] { "Foo3", "Foo4", "Foo5" }, new[] { "Bar3", "Bar4", "Bar5" });

            var matcher = new RingBufferEventMatcher(ringBuffer);

            Assert.True(matcher.RingBufferWithEvents(new object[1] {
                "Foo1Bar1-0"
            }, new object[1] {
                "Foo2Bar2-1"
            }, new object[1] {
                "Foo4Bar4-2"
            }, new object[1] {
                "Foo5Bar5-3"
            }));
        }