public void AccessBackingBytes_should_adjust_count()
{
var bytes = new byte[4];
var buffer = new ByteArrayBuffer(bytes, isReadOnly: true);
var subject = new ByteBufferSlice(buffer, 1, 2);
var result = subject.AccessBackingBytes(0);
result.Count.Should().Be(2); // not 3
}
public void TestAccessBackingBytes()
{
var backingBytes = new byte[100];
using (var buffer = new ByteArrayBuffer(backingBytes, 10, 80, false))
{
var segment = buffer.AccessBackingBytes(20);
Assert.AreSame(backingBytes, segment.Array);
Assert.AreEqual(30, segment.Offset);
Assert.AreEqual(60, segment.Count);
}
}
public void TestWriteByte()
{
var backingBytes = new byte[100];
using (var buffer = new ByteArrayBuffer(backingBytes, 10, 80, false))
{
Assert.AreEqual(0, backingBytes[30]);
Assert.AreEqual(0, backingBytes[31]);
buffer.WriteByte(20, 1);
Assert.AreEqual(1, backingBytes[30]);
Assert.AreEqual(0, backingBytes[31]);
}
}
public void TestWriteBackingBytes()
{
var backingBytes = new byte[100];
using (var buffer = new ByteArrayBuffer(backingBytes, 0, 0, false))
{
var segment = buffer.WriteBackingBytes(10);
Assert.AreSame(backingBytes, segment.Array);
Assert.AreEqual(0, segment.Offset);
Assert.AreEqual(10, segment.Count);
buffer.Position += 1;
Assert.AreEqual(1, buffer.Position);
Assert.AreEqual(1, buffer.Length);
}
}
public void TestWriteByte()
{
var backingBytes = new byte[100];
using (var buffer = new ByteArrayBuffer(backingBytes, 0, 0, false))
{
Assert.AreEqual(0, backingBytes[0]);
Assert.AreEqual(0, backingBytes[1]);
buffer.WriteByte(1);
Assert.AreEqual(1, backingBytes[0]);
Assert.AreEqual(0, backingBytes[1]);
Assert.AreEqual(1, buffer.Position);
Assert.AreEqual(1, buffer.Length);
}
}
public void TestWriteTo()
{
var backingBytes = new byte[100];
using (var buffer = new ByteArrayBuffer(backingBytes, 10, 80, false))
{
buffer.WriteBytes(0, new[] { (byte)1, (byte)2 }, 0, 2);
buffer.Length = 2;
using (var memoryStream = new MemoryStream())
{
buffer.WriteTo(memoryStream);
Assert.AreEqual(2, memoryStream.Length);
}
}
}
public void TestWriteBytes()
{
var bytes = new[] { (byte)1, (byte)2 };
var backingBytes = new byte[100];
using (var buffer = new ByteArrayBuffer(backingBytes, 10, 80, false))
{
Assert.AreEqual(0, backingBytes[30]);
Assert.AreEqual(0, backingBytes[31]);
Assert.AreEqual(0, backingBytes[32]);
buffer.WriteBytes(20, bytes, 0, bytes.Length);
Assert.AreEqual(1, backingBytes[30]);
Assert.AreEqual(2, backingBytes[31]);
Assert.AreEqual(0, backingBytes[32]);
}
}
public void TestWriteBytesFromByteBuffer()
{
var bytes = new[] { (byte)1, (byte)2 };
var source = new ByteArrayBuffer(bytes, 0, bytes.Length, true);
var backingBytes = new byte[100];
using (var buffer = new ByteArrayBuffer(backingBytes, 0, 0, false))
{
Assert.AreEqual(0, backingBytes[0]);
Assert.AreEqual(0, backingBytes[1]);
Assert.AreEqual(0, backingBytes[2]);
buffer.WriteBytes(source);
Assert.AreEqual(1, backingBytes[0]);
Assert.AreEqual(2, backingBytes[1]);
Assert.AreEqual(0, backingBytes[2]);
Assert.AreEqual(2, buffer.Position);
Assert.AreEqual(2, buffer.Length);
}
}
public void constructor_should_initialize_subject()
{
var buffer = new ByteArrayBuffer(new byte[3], isReadOnly: true);
var subject = new ByteBufferSlice(buffer, 1, 2);
var reflector = new Reflector(subject);
subject.Buffer.Should().BeSameAs(buffer);
reflector._disposed.Should().BeFalse();
reflector._offset.Should().Be(1);
reflector._length.Should().Be(2);
}
public Reflector(ByteArrayBuffer instance)
{
_instance = instance;
}
public void constructor_with_bytes_should_initialize_subject(
[Values(false, true)]
bool isReadOnly)
{
var bytes = new byte[1];
var subject = new ByteArrayBuffer(bytes, isReadOnly);
var reflector = new Reflector(subject);
subject.IsReadOnly.Should().Be(isReadOnly);
subject.Length.Should().Be(bytes.Length);
reflector._bytes.Should().BeSameAs(bytes);
reflector._disposed.Should().BeFalse();
}
public async Task WriteBytesAsync_should_have_expected_effect_for_offset(int offset, byte[] expectedBytes)
{
var stream = new MemoryStream();
var source = new ByteArrayBuffer(new byte[] { 1, 2, 3 });
await stream.WriteBytesAsync(source, offset, 1, CancellationToken.None);
stream.ToArray().Should().Equal(expectedBytes);
}
public void constructor_should_throw_when_offset_is_out_of_range(
[Values(-1, 2)]
int offset)
{
var buffer = new ByteArrayBuffer(new byte[1], isReadOnly: true);
Action action = () => new ByteBufferSlice(buffer, offset, 0);
action.ShouldThrow<ArgumentOutOfRangeException>().And.ParamName.Should().Be("offset");
}
/// <inheritdoc/>
public IByteBuffer GetSlice(int position, int length)
{
ThrowIfDisposed();
if (position < 0 || position > _length)
{
throw new ArgumentOutOfRangeException("position");
}
if (length < 0 || position + length > _length)
{
throw new ArgumentOutOfRangeException("length");
}
EnsureIsReadOnly();
var forkedBuffer = new ByteArrayBuffer(_bytes, _length, isReadOnly: true);
return new ByteBufferSlice(forkedBuffer, position, length);
}
public async Task ReadBytesAsync_with_byte_buffer_should_have_expected_effect_for_partial_reads(int testCase, int[] partition)
{
var bytes = new byte[] { 1, 2, 3 };
var mockStream = new Mock<Stream>();
var destination = new ByteArrayBuffer(new byte[3], 3);
var n = 0;
var position = 0;
mockStream.Setup(s => s.ReadAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
.Returns((byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
{
var length = partition[n++];
Buffer.BlockCopy(bytes, position, buffer, offset, length);
position += length;
return Task.FromResult(length);
});
await mockStream.Object.ReadBytesAsync(destination, 0, 3, CancellationToken.None);
destination.AccessBackingBytes(0).Array.Should().Equal(bytes);
}
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 constructor_should_throw_when_buffer_is_not_readonly()
{
var buffer = new ByteArrayBuffer(new byte[1], isReadOnly: false);
Action action = () => new ByteBufferSlice(buffer, 0, 0);
action.ShouldThrow<ArgumentException>().And.ParamName.Should().Be("buffer");
}
public void constructor_should_throw_when_length_is_out_of_range(int size, int offset, int length)
{
var buffer = new ByteArrayBuffer(new byte[size], isReadOnly: true);
Action action = () => new ByteBufferSlice(buffer, offset, length);
action.ShouldThrow<ArgumentOutOfRangeException>().And.ParamName.Should().Be("length");
}
// helper methods
public ByteBufferSlice CreateSubject(int size = 3, int offset = 1, int length = 2)
{
var buffer = new ByteArrayBuffer(new byte[size], isReadOnly: true);
return new ByteBufferSlice(buffer, offset, length);
}
public void ThrowIfEndOfStream_should_throw_when_position_plus_length_exceeds_2GB()
{
using (var buffer = new ByteArrayBuffer(new byte[1024]))
using (var subject = new ByteBufferStream(buffer))
{
subject.Position = 1024;
subject.WriteInt32(int.MaxValue - 128);
subject.Position = 1024;
Action action = () => subject.ReadSlice(); // indirectly calls private ThrowIfEndOfStream method
action.ShouldThrow<EndOfStreamException>();
}
}
private IByteBuffer RemoveOverflow(BsonBuffer buffer)
{
var lastRequestLength = buffer.Position - _lastRequestPosition;
buffer.Position = _lastRequestPosition;
var lastArrayItem = buffer.ReadBytes(lastRequestLength);
if ((BsonType)lastArrayItem[0] != BsonType.Document)
{
throw new MongoInternalException("Expected overflow item to be a BsonDocument.");
}
var sliceOffset = Array.IndexOf<byte>(lastArrayItem, 0) + 1; // skip over type and array index
var overflow = new ByteArrayBuffer(lastArrayItem, sliceOffset, lastArrayItem.Length - sliceOffset, true);
buffer.Position = _lastRequestPosition;
buffer.Length = _lastRequestPosition;
_batchCount--;
_batchLength = buffer.Position - _batchStartPosition;
return overflow;
}
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);
}
}
public async Task ReadBytesAsync_with_byte_buffer_should_have_expected_effect_for_offset(int offset, byte[] expectedBytes)
{
var bytes = new byte[] { 1 };
var stream = new MemoryStream(bytes);
var destination = new ByteArrayBuffer(new byte[3]);
await stream.ReadBytesAsync(destination, offset, 1, CancellationToken.None);
destination.AccessBackingBytes(0).Array.Should().Equal(expectedBytes);
}
/// <summary>
/// Reads a raw BSON array.
/// </summary>
/// <returns>The raw BSON array.</returns>
public virtual IByteBuffer ReadRawBsonArray()
{
// overridden in BsonBinaryReader to read the raw bytes from the stream
// for all other streams, deserialize the array and reserialize it using a BsonBinaryWriter to get the raw bytes
var deserializationContext = BsonDeserializationContext.CreateRoot(this);
var array = BsonArraySerializer.Instance.Deserialize(deserializationContext);
using (var memoryStream = new MemoryStream())
using (var bsonWriter = new BsonBinaryWriter(memoryStream, BsonBinaryWriterSettings.Defaults))
{
var serializationContext = BsonSerializationContext.CreateRoot(bsonWriter);
bsonWriter.WriteStartDocument();
var startPosition = memoryStream.Position + 3; // just past BsonType, "x" and null byte
bsonWriter.WriteName("x");
BsonArraySerializer.Instance.Serialize(serializationContext, array);
var endPosition = memoryStream.Position;
bsonWriter.WriteEndDocument();
byte[] memoryStreamBuffer;
#if NETSTANDARD1_5 || NETSTANDARD1_6
memoryStreamBuffer = memoryStream.ToArray();
#else
memoryStreamBuffer = memoryStream.GetBuffer();
#endif
var buffer = new ByteArrayBuffer(memoryStreamBuffer, (int)memoryStream.Length, isReadOnly: true);
return new ByteBufferSlice(buffer, (int)startPosition, (int)(endPosition - startPosition));
}
}
public async Task ReadBytesAsync_with_byte_buffer_should_have_expected_effect_for_partial_reads(int testCase, int[] partition)
{
var bytes = new byte[] { 1, 2, 3 };
var stream = Substitute.For<Stream>();
var destination = new ByteArrayBuffer(new byte[3], 3);
var n = 0;
var p = 0;
stream.ReadAsync(Arg.Any<byte[]>(), Arg.Any<int>(), Arg.Any<int>(), Arg.Any<CancellationToken>()).Returns(x =>
{
var l = partition[n++];
var b = (byte[])x[0];
var o = (int)x[1];
Buffer.BlockCopy(bytes, p, b, o, l);
p += l;
return Task.FromResult(l);
});
await stream.ReadBytesAsync(destination, 0, 3, CancellationToken.None);
destination.AccessBackingBytes(0).Array.Should().Equal(bytes);
}
