コード例 #1
0
        private static byte[] ConstructMessage(byte[] buffer)
        {
            var stream = new MemoryStream();
            var reader = new ChunkReader(new MemoryStream(buffer));

            reader.ReadNextMessages(stream);

            return(stream.ToArray());
        }
コード例 #2
0
        public void ShouldThrowWhenEndOfMessageMarkerNotPresent(byte[] input)
        {
            var reader = new ChunkReader(new MemoryStream(input));

            var targetStream = new MemoryStream();
            var ex           = Record.Exception(() => reader.ReadNextMessages(targetStream));

            ex.Should().NotBeNull();
            ex.Should().BeOfType <IOException>().Which.Message.Should().StartWith("Unexpected end of stream");
        }
コード例 #3
0
        public void ShouldReadMessageSpanningMultipleChunks(byte[] input, byte[] expectedMessageBuffers, int expectedCount)
        {
            var reader = new ChunkReader(new MemoryStream(input));

            var targetStream   = new MemoryStream();
            var count          = reader.ReadNextMessages(targetStream);
            var messageBuffers = targetStream.ToArray();

            count.Should().Be(expectedCount);
            messageBuffers.Should().Equal(expectedMessageBuffers);
        }
コード例 #4
0
        public void ShouldResetInternalBufferPositionsWhenWritableBufferIsSmallerThanSetWatermark()
        {
            var input  = GenerateMessageChunk(Constants.ChunkBufferSize - Constants.ChunkBufferResetPositionsWatermark);
            var logger = new Mock <ILogger>();
            var reader = new ChunkReader(new MemoryStream(input), logger.Object);

            var count = reader.ReadNextMessages(new MemoryStream());

            count.Should().Be(1);
            logger.Verify(l => l.Trace(It.IsRegex(CompactingArgumentRegEx), It.IsAny <object[]>()), Times.Once);
        }
コード例 #5
0
            public void ShouldThrowExceptionOnEndOfStream()
            {
                var reader       = new ChunkReader(new MemoryStream(new byte[0]));
                var targetStream = new MemoryStream();

                var exc = Record.Exception(() => reader.ReadNextMessages(targetStream));

                exc.Should().NotBeNull();
                exc.Should().BeOfType <IOException>();
                exc.Message.Should().StartWith("Unexpected end of stream");
            }
コード例 #6
0
        public void ShouldResetInternalBufferPositionsWhenAMessageOfNChunks()
        {
            var size   = 3 * Constants.MaxChunkSize;
            var input  = GenerateMessageChunk(3 * Constants.MaxChunkSize);
            var logger = new Mock <ILogger>();
            var reader = new ChunkReader(new MemoryStream(input), logger.Object);

            var count = reader.ReadNextMessages(new MemoryStream());

            count.Should().Be(1);
            logger.Verify(l => l.Trace(It.IsRegex(CompactingArgumentRegEx), It.IsAny <object[]>()), Times.AtLeast(size / Constants.ChunkBufferSize));
        }
コード例 #7
0
        public void ShouldNotResetInternalBufferPositionsWhenWritableBufferIsLargerThanSetWatermark()
        {
            var input = GenerateMessageChunk(Constants.ChunkBufferSize -
                                             (Constants.ChunkBufferResetPositionsWatermark + 10));
            var logger = LoggingHelper.GetTraceEnabledLogger();
            var reader = new ChunkReader(new MemoryStream(input), logger.Object);

            var count = reader.ReadNextMessages(new MemoryStream());

            count.Should().Be(1);
            logger.Verify(l => l.Trace(It.IsRegex(CompactingArgumentRegEx), It.IsAny <object[]>()), Times.Never);
        }
コード例 #8
0
        public static PackStreamReader CreateChunkedPackStreamReaderFromBytes(byte[] bytes, ILogger logger = null)
        {
            MemoryStream mBytesStream = new MemoryStream(bytes);
            ChunkReader  chunkReader  = new ChunkReader(mBytesStream, logger);

            MemoryStream mStream = new MemoryStream();

            chunkReader.ReadNextMessages(mStream);

            mStream.Position = 0;

            return(new PackStreamReader(mStream, BoltReader.StructHandlers));
        }
コード例 #9
0
            public void ShouldReadMessageAcrossChunks(byte[] input, byte[] correctValue)
            {
                var reader       = new ChunkReader(new MemoryStream(input));
                var targetStream = new MemoryStream();

                var count = reader.ReadNextMessages(targetStream);

                count.Should().Be(1);

                var real = targetStream.ToArray();

                real.Should().Equal(correctValue);
            }
コード例 #10
0
            public void ShouldResetInternalBufferPositionsAfterOneChunkSpanningMessageIsRead()
            {
                var size = Constants.MaxChunkSize * 3;
                var data = IOExtensions.GenerateBoltMessage(size);

                var logger = new Mock <ILogger>();
                var reader = new ChunkReader(new MemoryStream(data.ToArray()), logger.Object);

                var count = reader.ReadNextMessages(new MemoryStream());

                count.Should().Be(1);
                logger.Verify(l => l.Trace(It.IsRegex("^\\d+ bytes left in chunk buffer.*compacting\\.$"), It.IsAny <object[]>()), Times.AtLeast(size / Constants.ChunkBufferSize));
            }
コード例 #11
0
        public void ShouldResetInternalBufferPositionsWhenWritableBufferIsSmallerThanSetWatermarkWithConsecutiveMessages()
        {
            const int messageSizePerChunk = 1000;
            const int maxBytes            = Constants.ChunkBufferSize;

            var input  = GenerateMessages(messageSizePerChunk, maxBytes);
            var logger = new Mock <ILogger>();
            var reader = new ChunkReader(new MemoryStream(input), logger.Object);

            var count = reader.ReadNextMessages(new MemoryStream());

            count.Should().BeGreaterOrEqualTo(maxBytes / messageSizePerChunk);
            logger.Verify(l => l.Trace(It.IsRegex(CompactingArgumentRegEx), It.IsAny <object[]>()), Times.Once);
        }
コード例 #12
0
            public void ShouldResetInternalBufferPositionsAfterConsecutiveSmallMessagesAreRead()
            {
                var size  = 1000;
                var limit = Constants.ChunkBufferSize - Constants.ChunkBufferResetPositionsWatermark;
                var data  = IOExtensions.GenerateBoltMessages(size, limit);

                var logger = new Mock <ILogger>();
                var reader = new ChunkReader(new MemoryStream(data.ToArray()), logger.Object);

                var count = reader.ReadNextMessages(new MemoryStream());

                count.Should().BeGreaterOrEqualTo(limit / size);
                logger.Verify(l => l.Trace(It.IsRegex("^\\d+ bytes left in chunk buffer.*compacting\\.$"), It.IsAny <object[]>()), Times.Once);
            }
コード例 #13
0
        public void ShouldResetBufferStreamPosition()
        {
            var data = GenerateMessages(1000, 128 * 1024);

            var logger = new Mock <ILogger>();
            var reader = new ChunkReader(new MemoryStream(data.ToArray()), logger.Object);

            var bufferStream = new MemoryStream();

            bufferStream.Write(GenerateMessageChunk(1035));

            var bufferPosition = bufferStream.Position;

            var count = reader.ReadNextMessages(bufferStream);

            bufferStream.Position.Should().Be(bufferPosition);
        }