public void WriteSlice_should_have_expected_effect(
[Values(0, 1, 2, 16)]
int length,
[Values(1, 2, 3)]
int numberOfChunks)
{
numberOfChunks = length == 0 ? 1 : length < numberOfChunks ? length : numberOfChunks;
using (var memoryStream = new MemoryStream())
using (var stream = new BsonStreamAdapter(memoryStream))
{
IByteBuffer slice;
var bytes = Enumerable.Range(0, length).Select(n => (byte)n).ToArray();
if (numberOfChunks == 1)
{
slice = new ByteArrayBuffer(bytes, isReadOnly: true);
}
else
{
var chunkSize = length / numberOfChunks;
var chunks = Enumerable.Range(0, numberOfChunks)
.Select(i => bytes.Skip(i * chunkSize).Take(i < numberOfChunks - 1 ? chunkSize : int.MaxValue).ToArray())
.Select(b => new ByteArrayChunk(b));
slice = new MultiChunkBuffer(chunks);
}
stream.WriteSlice(slice);
memoryStream.ToArray().Should().Equal(bytes);
}
}
// private static methods
private byte[] CombineCommandMessageSectionsIntoSingleDocument(Stream stream)
{
using (var inputStream = new BsonStreamAdapter(stream, ownsStream: false))
using (var memoryStream = new MemoryStream())
using (var outputStream = new BsonStreamAdapter(memoryStream, ownsStream: false))
{
var messageStartPosition = inputStream.Position;
var messageLength = inputStream.ReadInt32();
var messageEndPosition = messageStartPosition + messageLength;
var requestId = inputStream.ReadInt32();
var responseTo = inputStream.ReadInt32();
var opcode = inputStream.ReadInt32();
var flags = (OpMsgFlags)inputStream.ReadInt32();
if (flags.HasFlag(OpMsgFlags.ChecksumPresent))
{
messageEndPosition -= 4; // ignore checksum
}
CopyType0Section(inputStream, outputStream);
outputStream.Position -= 1;
while (inputStream.Position < messageEndPosition)
{
CopyType1Section(inputStream, outputStream);
}
outputStream.WriteByte(0);
outputStream.BackpatchSize(0);
return(memoryStream.ToArray());
}
}
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 ReadBsonType_should_throw_when_value_is_invalid(int n)
{
var bytes = new byte[] { (byte)n };
using (var memoryStream = new MemoryStream(bytes))
using (var stream = new BsonStreamAdapter(memoryStream))
{
Action action = () => stream.ReadBsonType();
action.ShouldThrow <FormatException>();
}
}
public void ReadBsonType_should_return_expected_result(int n, BsonType expectedResult)
{
var bytes = new byte[] { (byte)n };
using (var memoryStream = new MemoryStream(bytes))
using (var stream = new BsonStreamAdapter(memoryStream))
{
var result = stream.ReadBsonType();
result.Should().Be(expectedResult);
}
}
public void WriteBytes_should_optimize_count_of_one()
{
using (var baseStream = Substitute.For <Stream>())
using (var stream = new BsonStreamAdapter(baseStream))
{
var buffer = new byte[] { 1 };
stream.WriteBytes(buffer, 0, 1);
baseStream.Received(1).WriteByte(1);
}
}
private byte[] CreateHeaderBytes(int messageLength, int requestId, int responseTo, int flags)
{
using (var memoryStream = new MemoryStream())
using (var stream = new BsonStreamAdapter(memoryStream))
{
stream.WriteInt32(messageLength);
stream.WriteInt32(requestId);
stream.WriteInt32(responseTo);
stream.WriteInt32((int)Opcode.OpMsg);
stream.WriteInt32(flags);
return(memoryStream.ToArray());
}
}
public void ReadBsonType_should_throw_when_value_is_invalid(int n)
{
var bytes = new byte[] { (byte)n };
using (var memoryStream = new MemoryStream(bytes))
using (var stream = new BsonStreamAdapter(memoryStream))
{
Action action = () => stream.ReadBsonType();
var hexBsonType = string.Format("{0:x2}", n);
var expectedMessage = $"Detected unknown BSON type \"\\x{hexBsonType}\". Are you using the latest driver version?";
action.ShouldThrow <FormatException>().WithMessage(expectedMessage);
}
}
public void WriteBytes_should_optimize_count_of_one()
{
var mockBaseStream = new Mock <Stream>();
using (var baseStream = mockBaseStream.Object)
using (var stream = new BsonStreamAdapter(baseStream))
{
var buffer = new byte[] { 1 };
stream.WriteBytes(buffer, 0, 1);
mockBaseStream.Verify(s => s.WriteByte(1), Times.Once);
}
}
public void WriteBsonType_should_have_expected_effect(
BsonType value,
byte expectedByte)
{
using (var memoryStream = new MemoryStream())
using (var stream = new BsonStreamAdapter(memoryStream))
{
var expectedBytes = new byte[] { expectedByte };
stream.WriteBsonType(value);
memoryStream.ToArray().Should().Equal(expectedBytes);
}
}
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 WriteBytes_should_have_expected_effect(
int length,
int offset,
int count)
{
using (var memoryStream = new MemoryStream())
using (var stream = new BsonStreamAdapter(memoryStream))
{
var buffer = Enumerable.Range(0, length).Select(n => (byte)n).ToArray();
stream.WriteBytes(buffer, offset, count);
memoryStream.ToArray().Should().Equal(buffer.Skip(offset).Take(count));
}
}
public void WriteSlice_should_have_expected_effect(
[Values(0, 1, 2, 16)]
int length)
{
using (var memoryStream = new MemoryStream())
using (var stream = new BsonStreamAdapter(memoryStream))
{
var bytes = Enumerable.Range(0, length).Select(n => (byte)n).ToArray();
var slice = new ByteArrayBuffer(bytes, isReadOnly: true);
stream.WriteSlice(slice);
memoryStream.ToArray().Should().Equal(bytes);
}
}
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);
}
}
private void Assert(BsonTrie <int> trie, string name)
{
var subject = new TrieNameDecoder <int>(trie);
using (var memoryStream = new MemoryStream())
using (var bsonStream = new BsonStreamAdapter(memoryStream))
{
bsonStream.WriteCString(name);
bsonStream.WriteInt32(20);
bsonStream.Position = 0;
var result = subject.Decode(bsonStream, Utf8Encodings.Strict);
result.Should().Be(name);
}
}
// private methods
private void Assert(string name, TrieNameDecoder <int> subject, bool found, int value)
{
using (var memoryStream = new MemoryStream())
using (var bsonStream = new BsonStreamAdapter(memoryStream))
{
bsonStream.WriteCString(name);
bsonStream.WriteInt32(20);
bsonStream.Position = 0;
var result = subject.Decode(bsonStream, Utf8Encodings.Strict);
result.Should().Be(name);
subject.Found.Should().Be(found);
subject.Value.Should().Be(value);
}
}
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);
}
}
private byte[] CreateType1SectionBytes(Type1CommandMessageSection <BsonDocument> section)
{
using (var memoryStream = new MemoryStream())
using (var stream = new BsonStreamAdapter(memoryStream))
using (var writer = new BsonBinaryWriter(stream))
{
stream.WriteByte(1);
var payloadStartPosition = stream.Position;
stream.WriteInt32(0); // size
stream.WriteCString(section.Identifier);
var context = BsonSerializationContext.CreateRoot(writer);
var batch = section.Documents;
for (var i = 0; i < batch.Count; i++)
{
var document = batch.Items[batch.Offset + i];
BsonDocumentSerializer.Instance.Serialize(context, document);
}
stream.BackpatchSize(payloadStartPosition);
return(memoryStream.ToArray());
}
}
public void BackpatchSize_should_backpatch_the_size(
[Values(0, 1, 5)]
int startPosition)
{
var bytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var length = bytes.Length - startPosition;
var expectedBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Array.Copy(BitConverter.GetBytes(length), 0, expectedBytes, startPosition, 4);
using (var memoryStream = new MemoryStream())
using (var stream = new BsonStreamAdapter(memoryStream))
{
stream.WriteBytes(bytes, 0, bytes.Length);
var position = stream.Position;
stream.BackpatchSize(startPosition);
memoryStream.ToArray().Should().Equal(expectedBytes);
stream.Position.Should().Be(position);
}
}