public void DelegatingStream_Length()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            long length = mockStream.Length;

            // Assert 
            mockInnerStream.Verify(s => s.Length, Times.Once());
        }
        public void DelegatingStream_Position()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            long position = mockStream.Position;

            // Assert 
            mockInnerStream.Verify(s => s.Position, Times.Once());
        }
        public void DelegatingStream_CanWrite()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            bool canWrite = mockStream.CanWrite;

            // Assert 
            mockInnerStream.Verify(s => s.CanWrite, Times.Once());
        }
        public void DelegatingStream_ReadTimeout()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            int readTimeout = mockStream.ReadTimeout;

            // Assert 
            mockInnerStream.Verify(s => s.ReadTimeout, Times.Once());
        }
        public void DelegatingStream_WriteByte()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            byte data = new byte();

            // Act
            mockStream.WriteByte(data);

            // Assert 
            mockInnerStream.Verify(s => s.WriteByte(data), Times.Once());
        }
        public void DelegatingStream_BeginWrite()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            byte[] buffer = new byte[2];
            int offset = 1;
            int count = 1;
            AsyncCallback callback = new AsyncCallback((asyncResult) => { });
            object state = new object();

            // Act
            mockStream.BeginWrite(buffer, offset, count, callback, state);

            // Assert 
            mockInnerStream.Verify(s => s.BeginWrite(buffer, offset, count, callback, state), Times.Once());
        }
        public void DelegatingStream_EndWrite()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            Mock<IAsyncResult> mockIAsyncResult = new Mock<IAsyncResult>();

            // Act
            mockStream.EndWrite(mockIAsyncResult.Object);

            // Assert 
            mockInnerStream.Verify(s => s.EndWrite(mockIAsyncResult.Object), Times.Once());
        }
        public void DelegatingStream_Write()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            byte[] buffer = new byte[2];
            int offset = 1;
            int count = 1;

            // Act
            mockStream.Write(buffer, offset, count);

            // Assert 
            mockInnerStream.Verify(s => s.Write(buffer, offset, count), Times.Once());
        }
        public void DelegatingStream_SetLength()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            mockStream.SetLength(10L);

            // Assert 
            mockInnerStream.Verify(s => s.SetLength(10L), Times.Once());
        }
        public void DelegatingStream_Seek()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            long offset = 1;
            SeekOrigin origin = SeekOrigin.End;

            // Act
            long seek = mockStream.Seek(offset, origin);

            // Assert 
            mockInnerStream.Verify(s => s.Seek(offset, origin), Times.Once());
        }
        public void DelegatingStream_Close()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>() { CallBase = true };
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            mockStream.Close();

            // Assert 
            mockInnerStream.Protected().Verify("Dispose", Times.Once(), true);
            mockInnerStream.Verify(s => s.Close(), Times.Once());
        }
        public void DelegatingStream_ReadAsyc()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            byte[] buffer = new byte[2];
            int offset = 1;
            int count = 1;

            // Act
            mockStream.ReadAsync(buffer, offset, count, CancellationToken.None);

            // Assert 
            mockInnerStream.Verify(s => s.ReadAsync(buffer, offset, count, CancellationToken.None), Times.Once());
        }