public void Buffer_get_should_return_expected_result() { var mockBuffer = new Mock<IByteBuffer>(); var subject = new ByteBufferStream(mockBuffer.Object); var result = subject.Buffer; result.Should().BeSameAs(mockBuffer.Object); }
public void Buffer_get_should_return_expected_result() { var buffer = Substitute.For<IByteBuffer>(); var subject = new ByteBufferStream(buffer); var result = subject.Buffer; result.Should().BeSameAs(buffer); }
/// <summary> /// Writes a raw BSON document. /// </summary> /// <param name="slice">The byte buffer containing the raw BSON document.</param> public virtual void WriteRawBsonDocument(IByteBuffer slice) { // overridden in BsonBinaryWriter to write the raw bytes to the stream // for all other streams, deserialize the raw bytes and serialize the resulting document instead using (var stream = new ByteBufferStream(slice, ownsByteBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, BsonBinaryReaderSettings.Defaults)) { var deserializationContext = BsonDeserializationContext.CreateRoot <BsonDocument>(bsonReader); var document = BsonDocumentSerializer.Instance.Deserialize(deserializationContext); var serializationContext = BsonSerializationContext.CreateRoot <BsonDocument>(this); BsonDocumentSerializer.Instance.Serialize(serializationContext, document); } }
private void ProcessReplyMessage(CommandState state, ResponseMessage message, IByteBuffer buffer, ConnectionId connectionId, MessageEncoderSettings encoderSettings) { state.Stopwatch.Stop(); bool disposeOfDocuments = false; var replyMessage = message as ReplyMessage<RawBsonDocument>; if (replyMessage == null) { // ReplyMessage is generic, which means that we can't use it here, so, we need to use a different one... using (var stream = new ByteBufferStream(buffer, ownsBuffer: false)) { var encoderFactory = new BinaryMessageEncoderFactory(stream, encoderSettings); replyMessage = (ReplyMessage<RawBsonDocument>)encoderFactory .GetReplyMessageEncoder(RawBsonDocumentSerializer.Instance) .ReadMessage(); disposeOfDocuments = true; } } try { if (replyMessage.CursorNotFound || replyMessage.QueryFailure || (state.ExpectedResponseType != ExpectedResponseType.Query && replyMessage.Documents.Count == 0)) { var queryFailureDocument = replyMessage.QueryFailureDocument; if (__securitySensitiveCommands.Contains(state.CommandName)) { queryFailureDocument = new BsonDocument(); } if (_failedEvent != null) { _failedEvent(new CommandFailedEvent( state.CommandName, new MongoCommandException( connectionId, string.Format("{0} command failed", state.CommandName), null, queryFailureDocument), state.OperationId, replyMessage.ResponseTo, connectionId, state.Stopwatch.Elapsed)); } } else { switch (state.ExpectedResponseType) { case ExpectedResponseType.Command: ProcessCommandReplyMessage(state, replyMessage, connectionId); break; case ExpectedResponseType.GLE: ProcessGLEReplyMessage(state, replyMessage, connectionId); break; case ExpectedResponseType.Query: ProcessQueryReplyMessage(state, replyMessage, connectionId); break; } } } finally { if (disposeOfDocuments && replyMessage.Documents != null) { replyMessage.Documents.ForEach(d => d.Dispose()); } } }
/// <summary> /// Writes a raw BSON array. /// </summary> /// <param name="slice">The byte buffer containing the raw BSON array.</param> public virtual void WriteRawBsonArray(IByteBuffer slice) { // overridden in BsonBinaryWriter to write the raw bytes to the stream // for all other streams, deserialize the raw bytes and serialize the resulting array instead using (var chunkSource = new InputBufferChunkSource(BsonChunkPool.Default)) using (var buffer = new MultiChunkBuffer(chunkSource)) using (var stream = new ByteBufferStream(buffer)) { // wrap the array in a fake document so we can deserialize it var documentLength = slice.Length + 8; buffer.EnsureCapacity(documentLength); stream.WriteInt32(documentLength); stream.WriteBsonType(BsonType.Array); stream.WriteByte((byte)'x'); stream.WriteByte(0); stream.WriteSlice(slice); stream.WriteByte(0); buffer.MakeReadOnly(); stream.Position = 0; using (var reader = new BsonBinaryReader(stream, BsonBinaryReaderSettings.Defaults)) { var deserializationContext = BsonDeserializationContext.CreateRoot(reader); reader.ReadStartDocument(); reader.ReadName("x"); var array = BsonArraySerializer.Instance.Deserialize(deserializationContext); reader.ReadEndDocument(); var serializationContext = BsonSerializationContext.CreateRoot(this); BsonArraySerializer.Instance.Serialize(serializationContext, array); } } }
/// <summary> /// Writes a raw BSON document. /// </summary> /// <param name="slice">The byte buffer containing the raw BSON document.</param> public virtual void WriteRawBsonDocument(IByteBuffer slice) { // overridden in BsonBinaryWriter to write the raw bytes to the stream // for all other streams, deserialize the raw bytes and serialize the resulting document instead using (var stream = new ByteBufferStream(slice, ownsBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, BsonBinaryReaderSettings.Defaults)) { var deserializationContext = BsonDeserializationContext.CreateRoot(bsonReader); var document = BsonDocumentSerializer.Instance.Deserialize(deserializationContext); var serializationContext = BsonSerializationContext.CreateRoot(this); BsonDocumentSerializer.Instance.Serialize(serializationContext, document); } }
/// <summary> /// Gets an enumerator that can enumerate the elements of the array. /// </summary> /// <returns>An enumerator.</returns> public override IEnumerator<BsonValue> GetEnumerator() { ThrowIfDisposed(); using (var stream = new ByteBufferStream(_slice, ownsBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { var context = BsonDeserializationContext.CreateRoot(bsonReader); bsonReader.ReadStartDocument(); while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); yield return DeserializeBsonValue(context); } bsonReader.ReadEndDocument(); } }
/// <summary> /// Materializes the RawBsonDocument into a regular BsonDocument. /// </summary> /// <param name="binaryReaderSettings">The binary reader settings.</param> /// <returns>A BsonDocument.</returns> public BsonDocument Materialize(BsonBinaryReaderSettings binaryReaderSettings) { ThrowIfDisposed(); using (var stream = new ByteBufferStream(_slice, ownsBuffer: false)) using (var reader = new BsonBinaryReader(stream, binaryReaderSettings)) { var context = BsonDeserializationContext.CreateRoot(reader); return BsonDocumentSerializer.Instance.Deserialize(context); } }
public void constructor_should_initialize_subject( [Values(false, true)] bool ownsBuffer) { var length = 123; var mockBuffer = new Mock<IByteBuffer>(); mockBuffer.SetupGet(s => s.Length).Returns(length); var subject = new ByteBufferStream(mockBuffer.Object, ownsBuffer); var reflector = new Reflector(subject); subject.Buffer.Should().BeSameAs(mockBuffer.Object); subject.Length.Should().Be(length); subject.Position.Should().Be(0); reflector._disposed.Should().BeFalse(); reflector._ownsBuffer.Should().Be(ownsBuffer); }
/// <summary> /// Tests whether the array contains a value. /// </summary> /// <param name="value">The value to test for.</param> /// <returns>True if the array contains the value.</returns> public override bool Contains(BsonValue value) { ThrowIfDisposed(); using (var stream = new ByteBufferStream(_slice, ownsBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { var context = BsonDeserializationContext.CreateRoot(bsonReader); bsonReader.ReadStartDocument(); while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); if (DeserializeBsonValue(context).Equals(value)) { return true; } } bsonReader.ReadEndDocument(); return false; } }
public ResponseMessage DecodeMessage(IByteBuffer buffer, IMessageEncoderSelector encoderSelector, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); _stopwatch.Stop(); _networkDuration = _stopwatch.Elapsed; ResponseMessage message; _stopwatch.Restart(); using (var stream = new ByteBufferStream(buffer, ownsBuffer: false)) { var encoderFactory = new BinaryMessageEncoderFactory(stream, _messageEncoderSettings); var encoder = encoderSelector.GetEncoder(encoderFactory); message = (ResponseMessage)encoder.ReadMessage(); } _stopwatch.Stop(); _deserializationDuration = _stopwatch.Elapsed; return message; }
/// <summary> /// Tests whether the document contains an element with the specified name. /// </summary> /// <param name="name">The name of the element to look for.</param> /// <returns> /// True if the document contains an element with the specified name. /// </returns> public override bool Contains(string name) { if (name == null) { throw new ArgumentNullException("name"); } ThrowIfDisposed(); using (var stream = new ByteBufferStream(_slice, ownsBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { bsonReader.ReadStartDocument(); while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { if (bsonReader.ReadName() == name) { return true; } bsonReader.SkipValue(); } bsonReader.ReadEndDocument(); return false; } }
public async Task<ResponseMessage> ReceiveMessageAsync( int responseTo, IMessageEncoderSelector encoderSelector, MessageEncoderSettings messageEncoderSettings, CancellationToken cancellationToken) { Ensure.IsNotNull(encoderSelector, nameof(encoderSelector)); ThrowIfDisposedOrNotOpen(); try { if (_receivingMessageEventHandler != null) { _receivingMessageEventHandler(new ConnectionReceivingMessageEvent(_connectionId, responseTo, EventContext.OperationId)); } ResponseMessage reply; var stopwatch = Stopwatch.StartNew(); using (var buffer = await ReceiveBufferAsync(responseTo, cancellationToken).ConfigureAwait(false)) { stopwatch.Stop(); var networkDuration = stopwatch.Elapsed; cancellationToken.ThrowIfCancellationRequested(); stopwatch.Restart(); using (var stream = new ByteBufferStream(buffer)) { var encoderFactory = new BinaryMessageEncoderFactory(stream, messageEncoderSettings); var encoder = encoderSelector.GetEncoder(encoderFactory); reply = (ResponseMessage)encoder.ReadMessage(); } stopwatch.Stop(); if (_commandEventHelper.ShouldCallAfterReceiving) { _commandEventHelper.AfterReceiving(reply, buffer, _connectionId, messageEncoderSettings); } if (_receivedMessageEventHandler != null) { _receivedMessageEventHandler(new ConnectionReceivedMessageEvent(_connectionId, responseTo, buffer.Length, networkDuration, stopwatch.Elapsed, EventContext.OperationId)); } } return reply; } catch (Exception ex) { if (_commandEventHelper.ShouldCallErrorReceiving) { _commandEventHelper.ErrorReceiving(responseTo, _connectionId, ex); } if (_failedReceivingMessageEventHandler != null) { _failedReceivingMessageEventHandler(new ConnectionReceivingMessageFailedEvent(_connectionId, responseTo, ex, EventContext.OperationId)); } throw; } }
public async Task SendMessagesAsync(IEnumerable<RequestMessage> messages, MessageEncoderSettings messageEncoderSettings, CancellationToken cancellationToken) { Ensure.IsNotNull(messages, nameof(messages)); ThrowIfDisposedOrNotOpen(); var messagesToSend = messages.ToList(); var requestIds = messagesToSend.Select(x => x.RequestId).ToList(); try { if (_sendingMessagesEventHandler != null) { _sendingMessagesEventHandler(new ConnectionSendingMessagesEvent(_connectionId, requestIds, EventContext.OperationId)); } cancellationToken.ThrowIfCancellationRequested(); var stopwatch = Stopwatch.StartNew(); var outputBufferChunkSource = new OutputBufferChunkSource(BsonChunkPool.Default); using (var buffer = new MultiChunkBuffer(outputBufferChunkSource)) { using (var stream = new ByteBufferStream(buffer, ownsBuffer: false)) { var encoderFactory = new BinaryMessageEncoderFactory(stream, messageEncoderSettings); foreach (var message in messagesToSend) { if (message.ShouldBeSent == null || message.ShouldBeSent()) { var encoder = message.GetEncoder(encoderFactory); encoder.WriteMessage(message); message.WasSent = true; } // Encoding messages includes serializing the // documents, so encoding message could be expensive // and worthy of us honoring cancellation here. cancellationToken.ThrowIfCancellationRequested(); } buffer.Length = (int)stream.Length; buffer.MakeReadOnly(); } var serializationDuration = stopwatch.Elapsed; if (_commandEventHelper.ShouldCallBeforeSending) { _commandEventHelper.BeforeSending( messages, _connectionId, buffer, messageEncoderSettings, stopwatch); } var stopwatchCheckPoint = stopwatch.Elapsed; await SendBufferAsync(buffer, cancellationToken).ConfigureAwait(false); var networkDuration = stopwatch.Elapsed - stopwatchCheckPoint; if (_commandEventHelper.ShouldCallAfterSending) { _commandEventHelper.AfterSending(messages, _connectionId); } if (_sentMessagesEventHandler != null) { _sentMessagesEventHandler(new ConnectionSentMessagesEvent(_connectionId, requestIds, buffer.Length, networkDuration, serializationDuration, EventContext.OperationId)); } } } catch (Exception ex) { if (_commandEventHelper.ShouldCallErrorSending) { _commandEventHelper.ErrorSending(messages, _connectionId, ex); } if (_failedSendingMessagesEvent != null) { _failedSendingMessagesEvent(new ConnectionSendingMessagesFailedEvent(_connectionId, requestIds, ex, EventContext.OperationId)); } throw; } }
public void PrepareToWrite_should_throw_when_stream_would_exceed_2GB() { using (var buffer = new MultiChunkBuffer(BsonChunkPool.Default)) using (var subject = new ByteBufferStream(buffer)) { var bytes = new byte[int.MaxValue / 2 + 1024]; subject.Write(bytes, 0, bytes.Length); Action action = () => subject.Write(bytes, 0, bytes.Length); // indirectly calls private PrepareToWrite method action.ShouldThrow<IOException>(); } }
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>(); } }
public void ReadSlice_should_return_expected_result(int length, byte[] bytes) { var mockBuffer = new Mock<IByteBuffer>(); mockBuffer.Setup(s => s.AccessBackingBytes(It.IsAny<int>())).Returns((int p) => { return new ArraySegment<byte>(bytes, p, bytes.Length - p); }); mockBuffer.SetupGet(s => s.IsReadOnly).Returns(true); mockBuffer.SetupGet(s => s.Length).Returns(bytes.Length); var subject = new ByteBufferStream(mockBuffer.Object); var expectedPosition = length; subject.ReadSlice(); subject.Position.Should().Be(expectedPosition); mockBuffer.Verify(b => b.GetSlice(0, bytes.Length), Times.Once); }
public void BeforeSending(IEnumerable<RequestMessage> messages, ConnectionId connectionId, IByteBuffer buffer, MessageEncoderSettings encoderSettings, Stopwatch stopwatch) { using (var stream = new ByteBufferStream(buffer, ownsBuffer: false)) { var messageQueue = new Queue<RequestMessage>(messages); while (messageQueue.Count > 0) { ProcessRequestMessages(messageQueue, connectionId, stream, encoderSettings, stopwatch); } } }
/// <summary> /// Tries to get the value of an element of this document. /// </summary> /// <param name="name">The name of the element.</param> /// <param name="value">The value of the element.</param> /// <returns> /// True if an element with that name was found. /// </returns> public override bool TryGetValue(string name, out BsonValue value) { ThrowIfDisposed(); using (var stream = new ByteBufferStream(_slice, ownsBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { var context = BsonDeserializationContext.CreateRoot(bsonReader); bsonReader.ReadStartDocument(); while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { if (bsonReader.ReadName() == name) { value = DeserializeBsonValue(context); return true; } bsonReader.SkipValue(); } bsonReader.ReadEndDocument(); value = null; return false; } }
private IEnumerable<BsonElement> MaterializeThisLevel() { var elements = new List<BsonElement>(); using (var stream = new ByteBufferStream(_slice, ownsBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { var context = BsonDeserializationContext.CreateRoot(bsonReader); bsonReader.ReadStartDocument(); BsonType bsonType; while ((bsonType = bsonReader.ReadBsonType()) != BsonType.EndOfDocument) { var name = bsonReader.ReadName(); BsonValue value; switch (bsonType) { case BsonType.Array: value = DeserializeLazyBsonArray(bsonReader); break; case BsonType.Document: value = DeserializeLazyBsonDocument(bsonReader); break; default: value = BsonValueSerializer.Instance.Deserialize(context); break; } elements.Add(new BsonElement(name, value)); } bsonReader.ReadEndDocument(); } return elements; }
public void Dispose_should_dispose_buffer_if_it_owns_it( [Values(false, true)] bool ownsBuffer) { var mockBuffer = new Mock<IByteBuffer>(); var subject = new ByteBufferStream(mockBuffer.Object, ownsBuffer: ownsBuffer); subject.Dispose(); mockBuffer.Verify(s => s.Dispose(), Times.Exactly(ownsBuffer ? 1 : 0)); }
public IByteBuffer EncodeMessages(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); var serializationStopwatch = Stopwatch.StartNew(); var outputBufferChunkSource = new OutputBufferChunkSource(BsonChunkPool.Default); var buffer = new MultiChunkBuffer(outputBufferChunkSource); using (var stream = new ByteBufferStream(buffer, ownsBuffer: false)) { var encoderFactory = new BinaryMessageEncoderFactory(stream, _messageEncoderSettings); foreach (var message in _messages) { if (message.ShouldBeSent == null || message.ShouldBeSent()) { var encoder = message.GetEncoder(encoderFactory); encoder.WriteMessage(message); message.WasSent = true; } // Encoding messages includes serializing the // documents, so encoding message could be expensive // and worthy of us honoring cancellation here. cancellationToken.ThrowIfCancellationRequested(); } buffer.Length = (int)stream.Length; buffer.MakeReadOnly(); } serializationStopwatch.Stop(); _serializationDuration = serializationStopwatch.Elapsed; return buffer; }
public void constructor_should_initialize_subject( [Values(false, true)] bool ownsBuffer) { var length = 123; var buffer = Substitute.For<IByteBuffer>(); buffer.Length.Returns(length); var subject = new ByteBufferStream(buffer, ownsBuffer); var reflector = new Reflector(subject); subject.Buffer.Should().BeSameAs(buffer); subject.Length.Should().Be(length); subject.Position.Should().Be(0); reflector._disposed.Should().BeFalse(); reflector._ownsBuffer.Should().Be(ownsBuffer); }
/// <summary> /// Gets an element of this document. /// </summary> /// <param name="index">The zero based index of the element.</param> /// <returns> /// The element. /// </returns> public override BsonElement GetElement(int index) { if (index < 0) { throw new ArgumentOutOfRangeException("index"); } ThrowIfDisposed(); using (var stream = new ByteBufferStream(_slice, ownsBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { var context = BsonDeserializationContext.CreateRoot(bsonReader); bsonReader.ReadStartDocument(); var i = 0; while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { if (i == index) { var name = bsonReader.ReadName(); var value = DeserializeBsonValue(context); return new BsonElement(name, value); } bsonReader.SkipName(); bsonReader.SkipValue(); i++; } bsonReader.ReadEndDocument(); throw new ArgumentOutOfRangeException("index"); } }
public Reflector(ByteBufferStream instance) { _instance = instance; }
// public indexers /// <summary> /// Gets or sets a value by position. /// </summary> /// <param name="index">The position.</param> /// <returns>The value.</returns> public override BsonValue this[int index] { get { if (index < 0) { throw new ArgumentOutOfRangeException("index"); } ThrowIfDisposed(); using (var stream = new ByteBufferStream(_slice, ownsBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { bsonReader.ReadStartDocument(); var i = 0; while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); if (i == index) { var context = BsonDeserializationContext.CreateRoot(bsonReader); return DeserializeBsonValue(context); } bsonReader.SkipValue(); i++; } bsonReader.ReadEndDocument(); throw new ArgumentOutOfRangeException("index"); } } set { throw new NotSupportedException("RawBsonArray instances are immutable."); } }
public void Dispose_should_dispose_buffer_if_it_owns_it( [Values(false, true)] bool ownsBuffer) { var buffer = Substitute.For<IByteBuffer>(); var subject = new ByteBufferStream(buffer, ownsBuffer: ownsBuffer); subject.Dispose(); buffer.Received(ownsBuffer ? 1 : 0).Dispose(); }
public override void CopyTo(object[] array, int arrayIndex) { ThrowIfDisposed(); using (var stream = new ByteBufferStream(_slice, ownsBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { var context = BsonDeserializationContext.CreateRoot(bsonReader); bsonReader.ReadStartDocument(); while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); array[arrayIndex++] = DeserializeBsonValue(context).RawValue; } bsonReader.ReadEndDocument(); } }
public void ReadSlice_should_return_expected_result(int length, byte[] bytes) { var buffer = Substitute.For<IByteBuffer>(); buffer.AccessBackingBytes(Arg.Any<int>()).Returns(x => { var p = (int)x[0]; return new ArraySegment<byte>(bytes, p, bytes.Length - p); }); buffer.IsReadOnly.Returns(true); buffer.Length.Returns(bytes.Length); var subject = new ByteBufferStream(buffer); var expectedPosition = length; subject.ReadSlice(); subject.Position.Should().Be(expectedPosition); subject.Buffer.Received(1).GetSlice(0, bytes.Length); }
/// <summary> /// Gets the index of a value in the array. /// </summary> /// <param name="value">The value to search for.</param> /// <param name="index">The zero based index at which to start the search.</param> /// <param name="count">The number of elements to search.</param> /// <returns>The zero based index of the value (or -1 if not found).</returns> public override int IndexOf(BsonValue value, int index, int count) { ThrowIfDisposed(); using (var stream = new ByteBufferStream(_slice, ownsBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { var context = BsonDeserializationContext.CreateRoot(bsonReader); bsonReader.ReadStartDocument(); var i = 0; while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); if (i >= index) { if (count == 0) { return -1; } if (DeserializeBsonValue(context).Equals(value)) { return i; } count--; } else { bsonReader.SkipValue(); } i++; } bsonReader.ReadEndDocument(); return -1; } }
public void Test20KDocument() { // manufacture an approximately 20K document using 200 strings each 100 characters long // it's enough to cause the document to straddle a chunk boundary var document = new BsonDocument(); var value = new string('x', 100); for (int i = 0; i < 200; i++) { var name = i.ToString(); document.Add(name, value); } // round trip tests var bson = document.ToBson(); var rehydrated = BsonSerializer.Deserialize<BsonDocument>(bson); Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson())); // test failure mode when 20 bytes are truncated from the buffer using (var byteBuffer = new MultiChunkBuffer(BsonChunkPool.Default)) using (var byteBufferStream = new ByteBufferStream(byteBuffer, ownsBuffer: true)) { using (var memoryStream = new MemoryStream(bson)) { memoryStream.CopyTo(byteBufferStream); } byteBufferStream.SetLength(byteBufferStream.Length - 20); byteBufferStream.Position = 0; using (var bsonReader = new BsonBinaryReader(byteBufferStream)) { Assert.Throws<EndOfStreamException>(() => BsonSerializer.Deserialize<BsonDocument>(bsonReader)); } } }