Avoid reading from the server twice to determine EOF.

drieseng · drieseng · commit 5408aace90b3 · 2017-07-16T20:04:58.000+02:00
When a server returns less number of bytes than the read buffer size, this *may* indicate that EOF has been reached. A subsequent (SSH_FXP_READ) server request is necessary to make sure EOF has effectively been reached.
Breaking out of the read loop avoids reading from the server twice to determine EOF: once in the read loop,
and once upon the next Read or ReadByte invocation.
diff --git a/src/Renci.SshNet.Tests/Classes/Sftp/SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadLessBytesFromServerThanCountAndEqualToBufferSize.cs b/src/Renci.SshNet.Tests/Classes/Sftp/SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadLessBytesFromServerThanCountAndEqualToBufferSize.cs
@@ -8,7 +8,7 @@
 namespace Renci.SshNet.Tests.Classes.Sftp
 {
     [TestClass]
-    public class SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadLessBytesFromServerThanCount : SftpFileStreamTestBase
+    public class SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadLessBytesFromServerThanCountAndEqualToBufferSize : SftpFileStreamTestBase
     {
         private string _path;
         private SftpFileStream _target;
@@ -35,12 +35,14 @@ protected override void SetupData()
             _readBufferSize = 20;
             _writeBufferSize = 500;
 
-            _numberOfBytesToRead = 20;
+            _numberOfBytesToRead = (int) _readBufferSize + 5; // greather than read buffer size
             _buffer = new byte[_numberOfBytesToRead];
-            _serverData1Length = _numberOfBytesToRead - 5;
+            _serverData1Length = (int) _readBufferSize; // equal to read buffer size
             _serverData1 = GenerateRandom(_serverData1Length, random);
-            _serverData2Length = _numberOfBytesToRead - _serverData1Length + 3;
+            _serverData2Length = (int) _readBufferSize; // equal to read buffer size
             _serverData2 = GenerateRandom(_serverData2Length, random);
+
+            Assert.IsTrue(_serverData1Length < _numberOfBytesToRead && _serverData1Length == _readBufferSize);
         }
 
         protected override void SetupMocks()
@@ -61,7 +63,7 @@ protected override void SetupMocks()
                 .Setup(p => p.RequestRead(_handle, 0UL, _readBufferSize))
                 .Returns(_serverData1);
             SftpSessionMock.InSequence(MockSequence)
-                .Setup(p => p.RequestRead(_handle, (ulong) _serverData1.Length, _readBufferSize))
+                .Setup(p => p.RequestRead(_handle, (ulong)_serverData1.Length, _readBufferSize))
                 .Returns(_serverData2);
         }
 
@@ -91,7 +93,7 @@ protected override void Act()
         [TestMethod]
         public void ReadShouldHaveReturnedTheNumberOfBytesRequested()
         {
-            Assert.AreEqual(_buffer.Length, _actual);
+            Assert.AreEqual(_numberOfBytesToRead, _actual);
         }
 
         [TestMethod]
@@ -104,11 +106,11 @@ public void ReadShouldHaveWrittenBytesToTheCallerSuppliedBuffer()
         }
 
         [TestMethod]
-        public void PositionShouldReturnNumberOfBytesWrittenToBuffer()
+        public void PositionShouldReturnNumberOfBytesWrittenToCallerProvidedBuffer()
         {
             SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
 
-            Assert.AreEqual(_buffer.Length, _target.Position);
+            Assert.AreEqual(_actual, _target.Position);
 
             SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));
         }
@@ -134,7 +136,7 @@ public void ReadShouldReturnAllRemaningBytesFromReadBufferWhenCountIsEqualToNumb
         public void ReadShouldReturnAllRemaningBytesFromReadBufferAndReadAgainWhenCountIsGreaterThanNumberOfRemainingBytesAndNewReadReturnsZeroBytes()
         {
             SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
-            SftpSessionMock.InSequence(MockSequence).Setup(p => p.RequestRead(_handle, (ulong) (_serverData1Length + _serverData2Length), _readBufferSize)).Returns(Array<byte>.Empty);
+            SftpSessionMock.InSequence(MockSequence).Setup(p => p.RequestRead(_handle, (ulong)(_serverData1Length + _serverData2Length), _readBufferSize)).Returns(Array<byte>.Empty);
 
             var numberOfBytesRemainingInReadBuffer = _serverData1Length + _serverData2Length - _numberOfBytesToRead;
 
@@ -147,7 +149,7 @@ public void ReadShouldReturnAllRemaningBytesFromReadBufferAndReadAgainWhenCountI
             Assert.AreEqual(0, _buffer[numberOfBytesRemainingInReadBuffer]);
 
             SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));
-            SftpSessionMock.Verify(p => p.RequestRead(_handle, (ulong) (_serverData1Length + _serverData2Length), _readBufferSize));
+            SftpSessionMock.Verify(p => p.RequestRead(_handle, (ulong)(_serverData1Length + _serverData2Length), _readBufferSize));
         }
     }
 }
diff --git a/src/Renci.SshNet.Tests/Classes/Sftp/SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadLessBytesFromServerThanCountAndLessThanBufferSize.cs b/src/Renci.SshNet.Tests/Classes/Sftp/SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadLessBytesFromServerThanCountAndLessThanBufferSize.cs
@@ -0,0 +1,148 @@
+﻿using System;
+using System.IO;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using Renci.SshNet.Common;
+using Renci.SshNet.Sftp;
+using Renci.SshNet.Tests.Common;
+
+namespace Renci.SshNet.Tests.Classes.Sftp
+{
+    [TestClass]
+    public class SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadLessBytesFromServerThanCountAndLessThanBufferSize : SftpFileStreamTestBase
+    {
+        private string _path;
+        private SftpFileStream _target;
+        private byte[] _handle;
+        private uint _bufferSize;
+        private uint _readBufferSize;
+        private uint _writeBufferSize;
+        private int _actual;
+        private byte[] _buffer;
+        private byte[] _serverData;
+        private int _serverDataLength;
+        private int _numberOfBytesToRead;
+        private byte[] _originalBuffer;
+
+        protected override void SetupData()
+        {
+            base.SetupData();
+
+            var random = new Random();
+            _path = random.Next().ToString();
+            _handle = GenerateRandom(5, random);
+            _bufferSize = (uint)random.Next(1, 1000);
+            _readBufferSize = 20;
+            _writeBufferSize = 500;
+
+            _numberOfBytesToRead = (int) _readBufferSize + 2; // greater than read buffer size
+            _originalBuffer = GenerateRandom(_numberOfBytesToRead, random);
+            _buffer = _originalBuffer.Copy();
+
+            _serverDataLength = (int) _readBufferSize - 1; // less than read buffer size
+            _serverData = GenerateRandom(_serverDataLength, random);
+
+            Assert.IsTrue(_serverDataLength < _numberOfBytesToRead && _serverDataLength < _readBufferSize);
+        }
+
+        protected override void SetupMocks()
+        {
+            SftpSessionMock.InSequence(MockSequence)
+                .Setup(p => p.RequestOpen(_path, Flags.Read, false))
+                .Returns(_handle);
+            SftpSessionMock.InSequence(MockSequence)
+                .Setup(p => p.CalculateOptimalReadLength(_bufferSize))
+                .Returns(_readBufferSize);
+            SftpSessionMock.InSequence(MockSequence)
+                .Setup(p => p.CalculateOptimalWriteLength(_bufferSize, _handle))
+                .Returns(_writeBufferSize);
+            SftpSessionMock.InSequence(MockSequence)
+                .Setup(p => p.IsOpen)
+                .Returns(true);
+            SftpSessionMock.InSequence(MockSequence)
+                .Setup(p => p.RequestRead(_handle, 0UL, _readBufferSize))
+                .Returns(_serverData);
+        }
+
+        [TestCleanup]
+        public void TearDown()
+        {
+            SftpSessionMock.InSequence(MockSequence)
+                           .Setup(p => p.RequestClose(_handle));
+        }
+
+        protected override void Arrange()
+        {
+            base.Arrange();
+
+            _target = new SftpFileStream(SftpSessionMock.Object,
+                                         _path,
+                                         FileMode.Open,
+                                         FileAccess.Read,
+                                         (int)_bufferSize);
+        }
+
+        protected override void Act()
+        {
+            _actual = _target.Read(_buffer, 0, _numberOfBytesToRead);
+        }
+
+        [TestMethod]
+        public void ReadShouldHaveReturnedTheNumberOfBytesReturnedByTheReadFromTheServer()
+        {
+            Assert.AreEqual(_serverDataLength, _actual);
+        }
+
+        [TestMethod]
+        public void ReadShouldHaveWrittenBytesToTheCallerSuppliedBufferAndRemainingBytesShouldRemainUntouched()
+        {
+            Assert.IsTrue(_serverData.IsEqualTo(_buffer.Take(_serverDataLength)));
+            Assert.IsTrue(_originalBuffer.Take(_serverDataLength, _originalBuffer.Length - _serverDataLength).IsEqualTo(_buffer.Take(_serverDataLength, _buffer.Length - _serverDataLength)));
+        }
+
+        [TestMethod]
+        public void PositionShouldReturnNumberOfBytesWrittenToCallerProvidedBuffer()
+        {
+            SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
+
+            Assert.AreEqual(_actual, _target.Position);
+
+            SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));
+        }
+
+        [TestMethod]
+        public void SubsequentReadShouldReadAgainFromCurrentPositionFromServerAndReturnZeroWhenServerReturnsZeroBytes()
+        {
+            SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
+            SftpSessionMock.InSequence(MockSequence)
+                .Setup(p => p.RequestRead(_handle, (ulong) _actual, _readBufferSize))
+                .Returns(Array<byte>.Empty);
+
+            var buffer = _originalBuffer.Copy();
+            var actual = _target.Read(buffer, 0, buffer.Length);
+
+            Assert.AreEqual(0, actual);
+            Assert.IsTrue(_originalBuffer.IsEqualTo(buffer));
+
+            SftpSessionMock.Verify(p => p.RequestRead(_handle, (ulong)_actual, _readBufferSize), Times.Once);
+            SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));
+        }
+
+        [TestMethod]
+        public void SubsequentReadShouldReadAgainFromCurrentPositionFromServerAndNotUpdatePositionWhenServerReturnsZeroBytes()
+        {
+            SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
+            SftpSessionMock.InSequence(MockSequence)
+                .Setup(p => p.RequestRead(_handle, (ulong)_actual, _readBufferSize))
+                .Returns(Array<byte>.Empty);
+            SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
+
+            _target.Read(new byte[10], 0, 10);
+
+            Assert.AreEqual(_actual, _target.Position);
+
+            SftpSessionMock.Verify(p => p.RequestRead(_handle, (ulong)_actual, _readBufferSize), Times.Once);
+            SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(3));
+        }
+    }
+}
diff --git a/src/Renci.SshNet.Tests/Classes/Sftp/SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadMoreBytesFromServerThanCount.cs b/src/Renci.SshNet.Tests/Classes/Sftp/SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadMoreBytesFromServerThanCount.cs
@@ -3,6 +3,7 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
 using Renci.SshNet.Sftp;
+using Renci.SshNet.Common;
 
 namespace Renci.SshNet.Tests.Classes.Sftp
 {
@@ -81,40 +82,58 @@ protected override void Act()
         }
 
         [TestMethod]
-        public void ReadShouldHaveReturnedTheNumberOfBytesRequested()
+        public void ReadShouldHaveReturnedTheNumberOfBytesWrittenToCallerSuppliedBuffer()
         {
             Assert.AreEqual(_numberOfBytesToRead, _actual);
         }
 
         [TestMethod]
         public void ReadShouldHaveWrittenBytesToTheCallerSuppliedBuffer()
         {
-            Assert.IsTrue(_serverData.Take(_buffer.Length).IsEqualTo(_buffer));
+            Assert.IsTrue(_serverData.Take(_actual).IsEqualTo(_buffer));
         }
 
         [TestMethod]
-        public void PositionShouldReturnNumberOfBytesWrittenToBuffer()
+        public void PositionShouldReturnNumberOfBytesWrittenToCallerProvidedBuffer()
         {
             SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
 
-            Assert.AreEqual(_buffer.Length, _target.Position);
+            Assert.AreEqual(_actual, _target.Position);
 
             SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));
         }
 
         [TestMethod]
-        public void ReadShouldReturnAllRemaningBytesFromReadBufferWhenCountIsEqualToNumberOfRemainingBytes()
+        public void SubsequentReadShouldReturnAllRemaningBytesFromReadBufferWhenCountIsEqualToNumberOfRemainingBytes()
         {
             SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
 
-            _buffer = new byte[_numberOfBytesToWriteToReadBuffer];
+            var buffer = new byte[_numberOfBytesToWriteToReadBuffer];
 
-            var actual = _target.Read(_buffer, 0, _numberOfBytesToWriteToReadBuffer);
+            var actual = _target.Read(buffer, 0, _numberOfBytesToWriteToReadBuffer);
 
             Assert.AreEqual(_numberOfBytesToWriteToReadBuffer, actual);
-            Assert.IsTrue(_serverData.Take(_numberOfBytesToRead, _numberOfBytesToWriteToReadBuffer).IsEqualTo(_buffer));
+            Assert.IsTrue(_serverData.Take(_numberOfBytesToRead, _numberOfBytesToWriteToReadBuffer).IsEqualTo(buffer));
 
             SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));
         }
+
+        [TestMethod]
+        public void SubsequentReadShouldReturnAllRemaningBytesFromReadBufferAndReadAgainWhenCountIsGreaterThanNumberOfRemainingBytesAndNewReadReturnsZeroBytes()
+        {
+            SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
+            SftpSessionMock.InSequence(MockSequence).Setup(p => p.RequestRead(_handle, (ulong)(_serverData.Length), _readBufferSize)).Returns(Array<byte>.Empty);
+
+            var buffer = new byte[_numberOfBytesToWriteToReadBuffer + 1];
+
+            var actual = _target.Read(buffer, 0, buffer.Length);
+
+            Assert.AreEqual(_numberOfBytesToWriteToReadBuffer, actual);
+            Assert.IsTrue(_serverData.Take(_numberOfBytesToRead, _numberOfBytesToWriteToReadBuffer).IsEqualTo(buffer.Take(_numberOfBytesToWriteToReadBuffer)));
+            Assert.AreEqual(0, buffer[_numberOfBytesToWriteToReadBuffer]);
+
+            SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));
+            SftpSessionMock.Verify(p => p.RequestRead(_handle, (ulong)(_serverData.Length), _readBufferSize));
+        }
     }
 }
diff --git a/src/Renci.SshNet.Tests/Common/Extensions.cs b/src/Renci.SshNet.Tests/Common/Extensions.cs
@@ -1,5 +1,6 @@
 ﻿using System.Collections.Generic;
 using Renci.SshNet.Common;
+using System;
 
 namespace Renci.SshNet.Tests.Common
 {
@@ -16,5 +17,12 @@ public static string AsString(this IList<ExceptionEventArgs> exceptionEvents)
 
             return reportedExceptions;
         }
+
+        public static byte[] Copy(this byte[] buffer)
+        {
+            var copy = new byte[buffer.Length];
+            Buffer.BlockCopy(buffer, 0, copy, 0, buffer.Length);
+            return copy;
+        }
     }
 }
diff --git a/src/Renci.SshNet.Tests/Renci.SshNet.Tests.csproj b/src/Renci.SshNet.Tests/Renci.SshNet.Tests.csproj
@@ -434,7 +434,8 @@
     <Compile Include="Classes\Sftp\SftpFileStreamTest_Dispose_Disposed.cs" />
     <Compile Include="Classes\Sftp\SftpFileStreamTest_Finalize_SessionOpen.cs" />
     <Compile Include="Classes\Sftp\SftpFileStreamTest_ReadByte_ReadMode_NoDataInWriteBufferAndNoDataInReadBuffer_LessDataThanReadBufferSizeAvailable.cs" />
-    <Compile Include="Classes\Sftp\SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadLessBytesFromServerThanCount.cs" />
+    <Compile Include="Classes\Sftp\SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadLessBytesFromServerThanCountAndLessThanBufferSize.cs" />
+    <Compile Include="Classes\Sftp\SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadLessBytesFromServerThanCountAndEqualToBufferSize.cs" />
     <Compile Include="Classes\Sftp\SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadMoreBytesFromServerThanCount.cs" />
     <Compile Include="Classes\Sftp\SftpFileStreamTest_Seek_PositionedAtBeginningOfStream_OriginBeginAndOffsetNegative.cs" />
     <Compile Include="Classes\Sftp\SftpFileStreamTest_Seek_PositionedAtBeginningOfStream_OriginBeginAndOffsetPositive.cs" />
diff --git a/src/Renci.SshNet/Sftp/SftpFileStream.cs b/src/Renci.SshNet/Sftp/SftpFileStream.cs

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@`
`8`	`8`	`namespace Renci.SshNet.Tests.Classes.Sftp`
`9`	`9`	`{`
`10`	`10`	`[TestClass]`
`11`		`- public class SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadLessBytesFromServerThanCount : SftpFileStreamTestBase`
	`11`	`+ public class SftpFileStreamTest_Read_ReadMode_NoDataInReaderBufferAndReadLessBytesFromServerThanCountAndEqualToBufferSize : SftpFileStreamTestBase`
`12`	`12`	`{`
`13`	`13`	`private string _path;`
`14`	`14`	`private SftpFileStream _target;`
`@@ -35,12 +35,14 @@ protected override void SetupData()`
`35`	`35`	`_readBufferSize = 20;`
`36`	`36`	`_writeBufferSize = 500;`
`37`	`37`
`38`		`- _numberOfBytesToRead = 20;`
	`38`	`+ _numberOfBytesToRead = (int) _readBufferSize + 5; // greather than read buffer size`
`39`	`39`	`_buffer = new byte[_numberOfBytesToRead];`
`40`		`- _serverData1Length = _numberOfBytesToRead - 5;`
	`40`	`+ _serverData1Length = (int) _readBufferSize; // equal to read buffer size`
`41`	`41`	`_serverData1 = GenerateRandom(_serverData1Length, random);`
`42`		`- _serverData2Length = _numberOfBytesToRead - _serverData1Length + 3;`
	`42`	`+ _serverData2Length = (int) _readBufferSize; // equal to read buffer size`
`43`	`43`	`_serverData2 = GenerateRandom(_serverData2Length, random);`
	`44`	`+`
	`45`	`+ Assert.IsTrue(_serverData1Length < _numberOfBytesToRead && _serverData1Length == _readBufferSize);`
`44`	`46`	`}`
`45`	`47`
`46`	`48`	`protected override void SetupMocks()`
`@@ -61,7 +63,7 @@ protected override void SetupMocks()`
`61`	`63`	`.Setup(p => p.RequestRead(_handle, 0UL, _readBufferSize))`
`62`	`64`	`.Returns(_serverData1);`
`63`	`65`	`SftpSessionMock.InSequence(MockSequence)`
`64`		`- .Setup(p => p.RequestRead(_handle, (ulong) _serverData1.Length, _readBufferSize))`
	`66`	`+ .Setup(p => p.RequestRead(_handle, (ulong)_serverData1.Length, _readBufferSize))`
`65`	`67`	`.Returns(_serverData2);`
`66`	`68`	`}`
`67`	`69`
`@@ -91,7 +93,7 @@ protected override void Act()`
`91`	`93`	`[TestMethod]`
`92`	`94`	`public void ReadShouldHaveReturnedTheNumberOfBytesRequested()`
`93`	`95`	`{`
`94`		`- Assert.AreEqual(_buffer.Length, _actual);`
	`96`	`+ Assert.AreEqual(_numberOfBytesToRead, _actual);`
`95`	`97`	`}`
`96`	`98`
`97`	`99`	`[TestMethod]`
`@@ -104,11 +106,11 @@ public void ReadShouldHaveWrittenBytesToTheCallerSuppliedBuffer()`
`104`	`106`	`}`
`105`	`107`
`106`	`108`	`[TestMethod]`
`107`		`- public void PositionShouldReturnNumberOfBytesWrittenToBuffer()`
	`109`	`+ public void PositionShouldReturnNumberOfBytesWrittenToCallerProvidedBuffer()`
`108`	`110`	`{`
`109`	`111`	`SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);`
`110`	`112`
`111`		`- Assert.AreEqual(_buffer.Length, _target.Position);`
	`113`	`+ Assert.AreEqual(_actual, _target.Position);`
`112`	`114`
`113`	`115`	`SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));`
`114`	`116`	`}`
`@@ -134,7 +136,7 @@ public void ReadShouldReturnAllRemaningBytesFromReadBufferWhenCountIsEqualToNumb`
`134`	`136`	`public void ReadShouldReturnAllRemaningBytesFromReadBufferAndReadAgainWhenCountIsGreaterThanNumberOfRemainingBytesAndNewReadReturnsZeroBytes()`
`135`	`137`	`{`
`136`	`138`	`SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);`
`137`		`- SftpSessionMock.InSequence(MockSequence).Setup(p => p.RequestRead(_handle, (ulong) (_serverData1Length + _serverData2Length), _readBufferSize)).Returns(Array<byte>.Empty);`
	`139`	`+ SftpSessionMock.InSequence(MockSequence).Setup(p => p.RequestRead(_handle, (ulong)(_serverData1Length + _serverData2Length), _readBufferSize)).Returns(Array<byte>.Empty);`
`138`	`140`
`139`	`141`	`var numberOfBytesRemainingInReadBuffer = _serverData1Length + _serverData2Length - _numberOfBytesToRead;`
`140`	`142`
`@@ -147,7 +149,7 @@ public void ReadShouldReturnAllRemaningBytesFromReadBufferAndReadAgainWhenCountI`
`147`	`149`	`Assert.AreEqual(0, _buffer[numberOfBytesRemainingInReadBuffer]);`
`148`	`150`
`149`	`151`	`SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));`
`150`		`- SftpSessionMock.Verify(p => p.RequestRead(_handle, (ulong) (_serverData1Length + _serverData2Length), _readBufferSize));`
	`152`	`+ SftpSessionMock.Verify(p => p.RequestRead(_handle, (ulong)(_serverData1Length + _serverData2Length), _readBufferSize));`
`151`	`153`	`}`
`152`	`154`	`}`
`153`	`155`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using Microsoft.VisualStudio.TestTools.UnitTesting;`
`4`	`4`	`using Moq;`
`5`	`5`	`using Renci.SshNet.Sftp;`
	`6`	`+using Renci.SshNet.Common;`
`6`	`7`
`7`	`8`	`namespace Renci.SshNet.Tests.Classes.Sftp`
`8`	`9`	`{`
`@@ -81,40 +82,58 @@ protected override void Act()`
`81`	`82`	`}`
`82`	`83`
`83`	`84`	`[TestMethod]`
`84`		`- public void ReadShouldHaveReturnedTheNumberOfBytesRequested()`
	`85`	`+ public void ReadShouldHaveReturnedTheNumberOfBytesWrittenToCallerSuppliedBuffer()`
`85`	`86`	`{`
`86`	`87`	`Assert.AreEqual(_numberOfBytesToRead, _actual);`
`87`	`88`	`}`
`88`	`89`
`89`	`90`	`[TestMethod]`
`90`	`91`	`public void ReadShouldHaveWrittenBytesToTheCallerSuppliedBuffer()`
`91`	`92`	`{`
`92`		`- Assert.IsTrue(_serverData.Take(_buffer.Length).IsEqualTo(_buffer));`
	`93`	`+ Assert.IsTrue(_serverData.Take(_actual).IsEqualTo(_buffer));`
`93`	`94`	`}`
`94`	`95`
`95`	`96`	`[TestMethod]`
`96`		`- public void PositionShouldReturnNumberOfBytesWrittenToBuffer()`
	`97`	`+ public void PositionShouldReturnNumberOfBytesWrittenToCallerProvidedBuffer()`
`97`	`98`	`{`
`98`	`99`	`SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);`
`99`	`100`
`100`		`- Assert.AreEqual(_buffer.Length, _target.Position);`
	`101`	`+ Assert.AreEqual(_actual, _target.Position);`
`101`	`102`
`102`	`103`	`SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));`
`103`	`104`	`}`
`104`	`105`
`105`	`106`	`[TestMethod]`
`106`		`- public void ReadShouldReturnAllRemaningBytesFromReadBufferWhenCountIsEqualToNumberOfRemainingBytes()`
	`107`	`+ public void SubsequentReadShouldReturnAllRemaningBytesFromReadBufferWhenCountIsEqualToNumberOfRemainingBytes()`
`107`	`108`	`{`
`108`	`109`	`SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);`
`109`	`110`
`110`		`- _buffer = new byte[_numberOfBytesToWriteToReadBuffer];`
	`111`	`+ var buffer = new byte[_numberOfBytesToWriteToReadBuffer];`
`111`	`112`
`112`		`- var actual = _target.Read(_buffer, 0, _numberOfBytesToWriteToReadBuffer);`
	`113`	`+ var actual = _target.Read(buffer, 0, _numberOfBytesToWriteToReadBuffer);`
`113`	`114`
`114`	`115`	`Assert.AreEqual(_numberOfBytesToWriteToReadBuffer, actual);`
`115`		`- Assert.IsTrue(_serverData.Take(_numberOfBytesToRead, _numberOfBytesToWriteToReadBuffer).IsEqualTo(_buffer));`
	`116`	`+ Assert.IsTrue(_serverData.Take(_numberOfBytesToRead, _numberOfBytesToWriteToReadBuffer).IsEqualTo(buffer));`
`116`	`117`
`117`	`118`	`SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));`
`118`	`119`	`}`
	`120`	`+`
	`121`	`+ [TestMethod]`
	`122`	`+ public void SubsequentReadShouldReturnAllRemaningBytesFromReadBufferAndReadAgainWhenCountIsGreaterThanNumberOfRemainingBytesAndNewReadReturnsZeroBytes()`
	`123`	`+ {`
	`124`	`+ SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);`
	`125`	`+ SftpSessionMock.InSequence(MockSequence).Setup(p => p.RequestRead(_handle, (ulong)(_serverData.Length), _readBufferSize)).Returns(Array<byte>.Empty);`
	`126`	`+`
	`127`	`+ var buffer = new byte[_numberOfBytesToWriteToReadBuffer + 1];`
	`128`	`+`
	`129`	`+ var actual = _target.Read(buffer, 0, buffer.Length);`
	`130`	`+`
	`131`	`+ Assert.AreEqual(_numberOfBytesToWriteToReadBuffer, actual);`
	`132`	`+ Assert.IsTrue(_serverData.Take(_numberOfBytesToRead, _numberOfBytesToWriteToReadBuffer).IsEqualTo(buffer.Take(_numberOfBytesToWriteToReadBuffer)));`
	`133`	`+ Assert.AreEqual(0, buffer[_numberOfBytesToWriteToReadBuffer]);`
	`134`	`+`
	`135`	`+ SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));`
	`136`	`+ SftpSessionMock.Verify(p => p.RequestRead(_handle, (ulong)(_serverData.Length), _readBufferSize));`
	`137`	`+ }`
`119`	`138`	`}`
`120`	`139`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System.Collections.Generic;`
`2`	`2`	`using Renci.SshNet.Common;`
	`3`	`+using System;`
`3`	`4`
`4`	`5`	`namespace Renci.SshNet.Tests.Common`
`5`	`6`	`{`
`@@ -16,5 +17,12 @@ public static string AsString(this IList<ExceptionEventArgs> exceptionEvents)`
`16`	`17`
`17`	`18`	`return reportedExceptions;`
`18`	`19`	`}`
	`20`	`+`
	`21`	`+ public static byte[] Copy(this byte[] buffer)`
	`22`	`+ {`
	`23`	`+ var copy = new byte[buffer.Length];`
	`24`	`+ Buffer.BlockCopy(buffer, 0, copy, 0, buffer.Length);`
	`25`	`+ return copy;`
	`26`	`+ }`
`19`	`27`	`}`
`20`	`28`	`}`