public void BaseStream_should_throw_when_subject_is_disposed()
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream);
            subject.Dispose();

            Action action = () => { var _ = subject.BaseStream; };

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void BeginRead_should_throw_when_subject_is_diposed()
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream);
            var buffer = new byte[0];
            var offset = 1;
            var count = 2;
            var callback = Substitute.For<AsyncCallback>();
            var state = new object();
            subject.Dispose();

            Action action = () => subject.BeginRead(buffer, offset, count, callback, state);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void Write_should_throw_when_subject_is_disposed()
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream);
            var buffer = new byte[0];
            var offset = 1;
            var count = 2;
            subject.Dispose();

            Action action = () => subject.Write(buffer, offset, count);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void WriteAsync_should_throw_when_subject_is_disposed()
        {
            var mockStream = new Mock<Stream>();
            var subject = new BsonStreamAdapter(mockStream.Object);
            var task = new TaskCompletionSource<object>().Task;
            var buffer = new byte[0];
            var offset = 1;
            var count = 2;
            var cancellationToken = new CancellationTokenSource().Token;
            subject.Dispose();

            Action action = () => subject.WriteAsync(buffer, offset, count, cancellationToken);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void FlushAsync_should_throw_when_subject_is_disposed()
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream);
            var cancellationToken = new CancellationTokenSource().Token;
            subject.Dispose();

            Action action = () => subject.FlushAsync(cancellationToken);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void EndWrite_should_throw_when_subject_is_disposed()
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream);
            var asyncResult = Substitute.For<IAsyncResult>();
            subject.Dispose();

            Action action = () => subject.EndWrite(asyncResult);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void Dispose_should_dispose_stream_only_when_it_owns_it(
            [Values(false, true)]
            bool ownsStream)
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream, ownsStream: ownsStream);

            subject.Dispose();

            stream.Received(ownsStream ? 1 : 0).Dispose();
        }
        public void Dispose_can_be_called_multiple_times()
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream);

            subject.Dispose();
            subject.Dispose();

            var subjectReflector = new Reflector(subject);
            subjectReflector._disposed.Should().BeTrue();
        }
        public void Dispose_should_dispose_stream_only_when_it_owns_it(
            [Values(false, true)]
            bool ownsStream)
        {
            var mockStream = new Mock<Stream>();
            var subject = new BsonStreamAdapter(mockStream.Object, ownsStream: ownsStream);

            subject.Dispose();

            mockStream.Verify(s => s.Close(), Times.Exactly(ownsStream ? 1 : 0)); // Dispose is not virtual but calls virtual Close
        }
        public void Dispose_should_dispose_stream_once_when_Disposed_is_called_more_than_once()
        {
            var mockStream = new Mock<Stream>();
            var subject = new BsonStreamAdapter(mockStream.Object, ownsStream: true);

            subject.Dispose();
            subject.Dispose();

            mockStream.Verify(s => s.Close(), Times.Once); // Dispose is not virtual but calls virtual Close
        }
        public void Dispose_can_be_called_multiple_times()
        {
            var mockStream = new Mock<Stream>();
            var subject = new BsonStreamAdapter(mockStream.Object);

            subject.Dispose();
            subject.Dispose();

            var subjectReflector = new Reflector(subject);
            subjectReflector._disposed.Should().BeTrue();
        }
        public void CopyToAsync_should_throw_when_subject_is_disposed()
        {
            var mockStream = new Mock<Stream>();
            var subject = new BsonStreamAdapter(mockStream.Object);
            var mockDestination = new Mock<Stream>();
            var bufferSize = 1;
            var cancellationToken = new CancellationTokenSource().Token;
            subject.Dispose();

            Action action = () => subject.CopyToAsync(mockDestination.Object, bufferSize, cancellationToken);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void WriteTimeout_set_should_throw_when_subject_is_disposed()
        {
            var mockStream = new Mock<Stream>();
            var subject = new BsonStreamAdapter(mockStream.Object);
            subject.Dispose();

            Action action = () => { subject.WriteTimeout = 0; };

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void WriteString_should_throw_when_subject_is_disposed()
        {
            var mockStream = new Mock<Stream>();
            var subject = new BsonStreamAdapter(mockStream.Object);
            var value = "abc";
            subject.Dispose();

            Action action = () => subject.WriteString(value, Utf8Encodings.Strict);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void WriteByte_should_throw_when_subject_is_disposed()
        {
            var mockStream = new Mock<Stream>();
            var subject = new BsonStreamAdapter(mockStream.Object);
            var value = (byte)97;
            subject.Dispose();

            Action action = () => subject.WriteByte(value);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void WriteCStringBytes_should_throw_when_subject_is_disposed()
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream);
            var value = new byte[0];
            subject.Dispose();

            Action action = () => subject.WriteCStringBytes(value);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void WriteObjectId_should_throw_when_subject_is_disposed()
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream);
            subject.Dispose();

            Action action = () => subject.WriteObjectId(ObjectId.Empty);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void Dispose_should_dispose_subject()
        {
            var mockStream = new Mock<Stream>();
            var subject = new BsonStreamAdapter(mockStream.Object);

            subject.Dispose();

            var subjectReflector = new Reflector(subject);
            subjectReflector._disposed.Should().BeTrue();
        }
        public void Dispose_should_dispose_stream_once_when_Disposed_is_called_more_than_once()
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream, ownsStream: true);

            subject.Dispose();
            subject.Dispose();

            stream.Received(1).Dispose();
        }
        public void EndWrite_should_throw_when_subject_is_disposed()
        {
            var mockStream = new Mock<Stream>();
            var subject = new BsonStreamAdapter(mockStream.Object);
            var mockAsyncResult = new Mock<IAsyncResult>();
            subject.Dispose();

            Action action = () => subject.EndWrite(mockAsyncResult.Object);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void Dispose_should_dispose_subject()
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream);

            subject.Dispose();

            var subjectReflector = new Reflector(subject);
            subjectReflector._disposed.Should().BeTrue();
        }
        public void Read_should_throw_when_subject_is_disposed()
        {
            var mockStream = new Mock<Stream>();
            var subject = new BsonStreamAdapter(mockStream.Object);
            var buffer = new byte[3];
            var offset = 1;
            var count = 2;
            subject.Dispose();

            Action action = () => subject.Read(buffer, offset, count);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void ReadSlice_should_throw_when_subject_is_disposed()
        {
            var mockStream = new Mock<Stream>();
            var subject = new BsonStreamAdapter(mockStream.Object);
            subject.Dispose();

            Action action = () => subject.ReadSlice();

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void Seek_should_throw_when_subject_is_disposed()
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream);
            var offset = 1L;
            var origin = SeekOrigin.Current;
            subject.Dispose();

            Action action = () => subject.Seek(offset, origin);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void ReadAsync_should_throw_when_subject_is_disposed()
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream);
            var buffer = new byte[3];
            var offset = 1;
            var count = 2;
            var cancellationToken = new CancellationTokenSource().Token;
            subject.Dispose();

            Action action = () => subject.ReadAsync(buffer, offset, count, cancellationToken);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void SetLength_should_throw_when_subject_is_diposed()
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream);
            var length = 1L;
            subject.Dispose();

            Action action = () => subject.SetLength(length);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void ReadString_should_throw_when_subject_is_disposed()
        {
            var stream = Substitute.For<Stream>();
            var subject = new BsonStreamAdapter(stream);
            subject.Dispose();

            Action action = () => subject.ReadString(Utf8Encodings.Strict);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }
        public void BeginWrite_should_throw_when_subject_is_disposed()
        {
            var mockStream = new Mock<Stream>();
            var subject = new BsonStreamAdapter(mockStream.Object);
            var buffer = new byte[0];
            var offset = 1;
            var count = 2;
            var mockCallback = new Mock<AsyncCallback>();
            var state = new object();
            subject.Dispose();

            Action action = () => subject.BeginWrite(buffer, offset, count, mockCallback.Object, state);

            action.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be("BsonStreamAdapter");
        }