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_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_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_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_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);
            }
        }
        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);
            }
        }
        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);
            }
        }