public void ReadBytes_with_count_should_throw_when_at_end_of_stream()
        {
            using (var memoryStream = new MemoryStream())
                using (var stream = new BsonStreamAdapter(memoryStream))
                {
                    Action action = () => stream.ReadBytes(1);

                    action.ShouldThrow <EndOfStreamException>();
                }
        }
        public void ReadBytes_with_buffer_should_optimize_count_of_one()
        {
            using (var baseStream = Substitute.For <Stream>())
                using (var stream = new BsonStreamAdapter(baseStream))
                {
                    baseStream.ReadByte().Returns(1);
                    var buffer = new byte[1];

                    stream.ReadBytes(buffer, 0, 1);

                    buffer.Should().Equal(new byte[] { 1 });
                    baseStream.Received(1).ReadByte();
                }
        }
        public void ReadBytes_with_count_should_return_expected_result(
            [Values(0, 1, 2, 16)]
            int length)
        {
            var bytes = Enumerable.Range(0, length).Select(n => (byte)n).ToArray();

            using (var memoryStream = new MemoryStream(bytes))
                using (var stream = new BsonStreamAdapter(memoryStream))
                {
                    var result = stream.ReadBytes(length);

                    result.Should().Equal(bytes);
                    stream.Position.Should().Be(length);
                }
        }
        public void ReadBytes_with_buffer_should_throw_when_at_end_of_stream(
            [Values(0, 1, 2, 16)]
            int length)
        {
            var bytes = Enumerable.Range(0, length).Select(n => (byte)n).ToArray();

            using (var memoryStream = new MemoryStream(bytes))
                using (var stream = new BsonStreamAdapter(memoryStream))
                {
                    var buffer = new byte[length + 1];

                    Action action = () => stream.ReadBytes(buffer, 0, length + 1);

                    action.ShouldThrow <EndOfStreamException>();
                }
        }
        public void ReadBytes_with_buffer_should_handle_partial_reads()
        {
            using (var baseStream = Substitute.For <BsonStream>())
                using (var stream = new BsonStreamAdapter(baseStream))
                {
                    var buffer = new byte[3];
                    baseStream.Read(Arg.Any <byte[]>(), 0, 3).Returns(x => { var b = (byte[])x[0]; b[0] = 1; return(1); });
                    baseStream.Read(Arg.Any <byte[]>(), 1, 2).Returns(x => { var b = (byte[])x[0]; b[1] = 2; b[2] = 3; return(2); });

                    stream.ReadBytes(buffer, 0, 3);

                    buffer.Should().Equal(new byte[] { 1, 2, 3 });
                    baseStream.Received(1).Read(buffer, 0, 3);
                    baseStream.Received(1).Read(buffer, 1, 2);
                }
        }
Esempio n. 6
0
        public void ReadBytes_with_buffer_should_optimize_count_of_one()
        {
            var mockBaseStream = new Mock <BsonStream>();

            mockBaseStream.Setup(s => s.ReadByte()).Returns(1);

            using (var baseStream = mockBaseStream.Object)
                using (var stream = new BsonStreamAdapter(baseStream))
                {
                    var buffer = new byte[1];

                    stream.ReadBytes(buffer, 0, 1);

                    buffer.Should().Equal(new byte[] { 1 });
                    mockBaseStream.Verify(s => s.ReadByte(), Times.Once);
                }
        }
Esempio n. 7
0
        public void ReadBytes_with_buffer_should_handle_partial_reads()
        {
            var mockBaseStream = new Mock <BsonStream>();
            var buffer         = new byte[3];

            mockBaseStream.Setup(s => s.Read(It.IsAny <byte[]>(), 0, 3)).Returns((byte[] b, int o, int c) => { b[0] = 1; return(1); });
            mockBaseStream.Setup(s => s.Read(It.IsAny <byte[]>(), 1, 2)).Returns((byte[] b, int o, int c) => { b[1] = 2; b[2] = 3; return(2); });

            using (var baseStream = mockBaseStream.Object)
                using (var stream = new BsonStreamAdapter(baseStream))
                {
                    stream.ReadBytes(buffer, 0, 3);

                    buffer.Should().Equal(new byte[] { 1, 2, 3 });
                    mockBaseStream.Verify(s => s.Read(buffer, 0, 3), Times.Once);
                    mockBaseStream.Verify(s => s.Read(buffer, 1, 2), Times.Once);
                }
        }