public void GetBytes()
{
var request = new SftpUnblockRequest(_protocolVersion, _requestId, _handle, _offset, _length, null);
var bytes = request.GetBytes();
var expectedBytesLength = 0;
expectedBytesLength += 4; // Length
expectedBytesLength += 1; // Type
expectedBytesLength += 4; // RequestId
expectedBytesLength += 4; // Handle length
expectedBytesLength += _handle.Length; // Handle
expectedBytesLength += 8; // Offset
expectedBytesLength += 8; // Length
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
Assert.AreEqual((uint) bytes.Length - 4, sshDataStream.ReadUInt32());
Assert.AreEqual((byte) SftpMessageTypes.Unblock, sshDataStream.ReadByte());
Assert.AreEqual(_requestId, sshDataStream.ReadUInt32());
Assert.AreEqual((uint) _handle.Length, sshDataStream.ReadUInt32());
var actualHandle = new byte[_handle.Length];
sshDataStream.Read(actualHandle, 0, actualHandle.Length);
Assert.IsTrue(_handle.SequenceEqual(actualHandle));
Assert.AreEqual(_offset, sshDataStream.ReadUInt64());
Assert.AreEqual(_length, sshDataStream.ReadUInt64());
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void GetBytes()
{
var request = new SftpFSetStatRequest(_protocolVersion, _requestId, _handle, _attributes, null);
var bytes = request.GetBytes();
var expectedBytesLength = 0;
expectedBytesLength += 4; // Length
expectedBytesLength += 1; // Type
expectedBytesLength += 4; // RequestId
expectedBytesLength += 4; // Handle length
expectedBytesLength += _handle.Length; // Handle
expectedBytesLength += _attributesBytes.Length; // Attributes
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
Assert.AreEqual((uint) bytes.Length - 4, sshDataStream.ReadUInt32());
Assert.AreEqual((byte) SftpMessageTypes.FSetStat, sshDataStream.ReadByte());
Assert.AreEqual(_requestId, sshDataStream.ReadUInt32());
Assert.AreEqual((uint) _handle.Length, sshDataStream.ReadUInt32());
var actualHandle = new byte[_handle.Length];
sshDataStream.Read(actualHandle, 0, actualHandle.Length);
Assert.IsTrue(_handle.SequenceEqual(actualHandle));
var actualAttributes = new byte[_attributesBytes.Length];
sshDataStream.Read(actualAttributes, 0, actualAttributes.Length);
Assert.IsTrue(_attributesBytes.SequenceEqual(actualAttributes));
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void GetBytes()
{
var request = new SftpRemoveRequest(_protocolVersion, _requestId, _filename, _encoding, null);
var bytes = request.GetBytes();
var expectedBytesLength = 0;
expectedBytesLength += 4; // Length
expectedBytesLength += 1; // Type
expectedBytesLength += 4; // RequestId
expectedBytesLength += 4; // Filename length
expectedBytesLength += _filenameBytes.Length; // Filename
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
Assert.AreEqual((uint) bytes.Length - 4, sshDataStream.ReadUInt32());
Assert.AreEqual((byte) SftpMessageTypes.Remove, sshDataStream.ReadByte());
Assert.AreEqual(_requestId, sshDataStream.ReadUInt32());
Assert.AreEqual((uint) _filenameBytes.Length, sshDataStream.ReadUInt32());
var actualFilename = new byte[_filenameBytes.Length];
sshDataStream.Read(actualFilename, 0, actualFilename.Length);
Assert.IsTrue(_filenameBytes.SequenceEqual(actualFilename));
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void GetBytes()
{
var request = new SftpCloseRequest(_protocolVersion, _requestId, _handle, null);
var bytes = request.GetBytes();
var expectedBytesLength = 0;
#if TUNING
expectedBytesLength += 4; // Length
#endif
expectedBytesLength += 1; // Type
expectedBytesLength += 4; // RequestId
expectedBytesLength += 4; // Handle length
expectedBytesLength += _handle.Length; // Handle
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
#if TUNING
Assert.AreEqual((uint)bytes.Length - 4, sshDataStream.ReadUInt32());
#endif
Assert.AreEqual((byte)SftpMessageTypes.Close, sshDataStream.ReadByte());
Assert.AreEqual(_requestId, sshDataStream.ReadUInt32());
Assert.AreEqual((uint)_handle.Length, sshDataStream.ReadUInt32());
var actualHandle = new byte[_handle.Length];
sshDataStream.Read(actualHandle, 0, actualHandle.Length);
Assert.IsTrue(_handle.SequenceEqual(actualHandle));
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void GetBytes()
{
var statusActionInvocations = new List<SftpStatusResponse>();
var nameActionInvocations = new List<SftpNameResponse>();
Action<SftpStatusResponse> statusAction = statusActionInvocations.Add;
var request = new SftpRmDirRequest(_protocolVersion, _requestId, _path, _encoding, null);
var bytes = request.GetBytes();
var expectedBytesLength = 0;
expectedBytesLength += 4; // Length
expectedBytesLength += 1; // Type
expectedBytesLength += 4; // RequestId
expectedBytesLength += 4; // Path length
expectedBytesLength += _pathBytes.Length; // Path
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
Assert.AreEqual((uint) bytes.Length - 4, sshDataStream.ReadUInt32());
Assert.AreEqual((byte) SftpMessageTypes.RmDir, sshDataStream.ReadByte());
Assert.AreEqual(_requestId, sshDataStream.ReadUInt32());
Assert.AreEqual((uint) _pathBytes.Length, sshDataStream.ReadUInt32());
var actualPath = new byte[_pathBytes.Length];
sshDataStream.Read(actualPath, 0, actualPath.Length);
Assert.IsTrue(_pathBytes.SequenceEqual(actualPath));
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void GetBytes()
{
var request = new SftpMkDirRequest(_protocolVersion, _requestId, _path, _encoding, null);
var bytes = request.GetBytes();
var expectedBytesLength = 0;
expectedBytesLength += 4; // Length
expectedBytesLength += 1; // Type
expectedBytesLength += 4; // RequestId
expectedBytesLength += 4; // Path length
expectedBytesLength += _pathBytes.Length; // Path
expectedBytesLength += _attributesBytes.Length; // Attributes
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
Assert.AreEqual((uint) bytes.Length - 4, sshDataStream.ReadUInt32());
Assert.AreEqual((byte) SftpMessageTypes.MkDir, sshDataStream.ReadByte());
Assert.AreEqual(_requestId, sshDataStream.ReadUInt32());
Assert.AreEqual((uint) _pathBytes.Length, sshDataStream.ReadUInt32());
var actualPath = new byte[_pathBytes.Length];
sshDataStream.Read(actualPath, 0, actualPath.Length);
Assert.IsTrue(_pathBytes.SequenceEqual(actualPath));
var actualAttributes = new byte[_attributesBytes.Length];
sshDataStream.Read(actualAttributes, 0, actualAttributes.Length);
Assert.IsTrue(_attributesBytes.SequenceEqual(actualAttributes));
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void GetBytes()
{
var target = new PseudoTerminalRequestInfo(_environmentVariable, _columns, _rows, _width, _height, _terminalModeValues);
var bytes = target.GetBytes();
var expectedBytesLength = 1; // WantReply
expectedBytesLength += 4; // EnvironmentVariable length
expectedBytesLength += _environmentVariableBytes.Length; // EnvironmentVariable
expectedBytesLength += 4; // Columns
expectedBytesLength += 4; // Rows
expectedBytesLength += 4; // PixelWidth
expectedBytesLength += 4; // PixelHeight
expectedBytesLength += 4; // Length of "encoded terminal modes"
expectedBytesLength += _terminalModeValues.Count*(1 + 4) + 1; // encoded terminal modes
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
Assert.AreEqual(1, sshDataStream.ReadByte()); // WantReply
Assert.AreEqual(_environmentVariable, sshDataStream.ReadString(Encoding.UTF8));
Assert.AreEqual(_columns, sshDataStream.ReadUInt32());
Assert.AreEqual(_rows, sshDataStream.ReadUInt32());
Assert.AreEqual(_width, sshDataStream.ReadUInt32());
Assert.AreEqual(_height, sshDataStream.ReadUInt32());
Assert.AreEqual((uint) (_terminalModeValues.Count * (1 + 4) + 1), sshDataStream.ReadUInt32());
Assert.AreEqual((int) TerminalModes.CS8, sshDataStream.ReadByte());
Assert.AreEqual(_terminalModeValues[TerminalModes.CS8], sshDataStream.ReadUInt32());
Assert.AreEqual((int) TerminalModes.ECHO, sshDataStream.ReadByte());
Assert.AreEqual(_terminalModeValues[TerminalModes.ECHO], sshDataStream.ReadUInt32());
Assert.AreEqual((int) TerminalModes.TTY_OP_END, sshDataStream.ReadByte());
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void Test_KeyExchangeDhGroupExchangeRequest_GetBytes()
{
var request = new KeyExchangeDhGroupExchangeRequest(_minimum, _preferred, _maximum);
var bytes = request.GetBytes();
var expectedBytesLength = 0;
expectedBytesLength += 1; // Type
expectedBytesLength += 4; // Minimum
expectedBytesLength += 4; // Preferred
expectedBytesLength += 4; // Maximum
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
Assert.AreEqual(KeyExchangeDhGroupExchangeRequest.MessageNumber, sshDataStream.ReadByte());
Assert.AreEqual(_minimum, sshDataStream.ReadUInt32());
Assert.AreEqual(_preferred, sshDataStream.ReadUInt32());
Assert.AreEqual(_maximum, sshDataStream.ReadUInt32());
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void GetBytes()
{
var request = new IgnoreMessage(_data);
var bytes = request.GetBytes();
var expectedBytesLength = 0;
expectedBytesLength += 1; // Type
expectedBytesLength += 4; // Data length
expectedBytesLength += _data.Length; // Data
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
Assert.AreEqual(IgnoreMessage.MessageNumber, sshDataStream.ReadByte());
Assert.AreEqual((uint) _data.Length, sshDataStream.ReadUInt32());
var actualData = new byte[_data.Length];
sshDataStream.Read(actualData, 0, actualData.Length);
Assert.IsTrue(_data.SequenceEqual(actualData));
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void GetBytes()
{
var request = new PosixRenameRequest(_protocolVersion, _requestId, _oldPath, _newPath, _encoding, null);
var bytes = request.GetBytes();
var expectedBytesLength = 0;
expectedBytesLength += 4; // Length
expectedBytesLength += 1; // Type
expectedBytesLength += 4; // RequestId
expectedBytesLength += 4; // Name length
expectedBytesLength += _nameBytes.Length; // Name
expectedBytesLength += 4; // OldPath length
expectedBytesLength += _oldPathBytes.Length; // OldPath
expectedBytesLength += 4; // NewPath length
expectedBytesLength += _newPathBytes.Length; // NewPath
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
Assert.AreEqual((uint)bytes.Length - 4, sshDataStream.ReadUInt32());
Assert.AreEqual((byte) SftpMessageTypes.Extended, sshDataStream.ReadByte());
Assert.AreEqual(_requestId, sshDataStream.ReadUInt32());
Assert.AreEqual((uint) _nameBytes.Length, sshDataStream.ReadUInt32());
var actualNameBytes = new byte[_nameBytes.Length];
sshDataStream.Read(actualNameBytes, 0, actualNameBytes.Length);
Assert.IsTrue(_nameBytes.SequenceEqual(actualNameBytes));
Assert.AreEqual((uint) _oldPathBytes.Length, sshDataStream.ReadUInt32());
var actualOldPath = new byte[_oldPathBytes.Length];
sshDataStream.Read(actualOldPath, 0, actualOldPath.Length);
Assert.IsTrue(_oldPathBytes.SequenceEqual(actualOldPath));
Assert.AreEqual((uint) _newPathBytes.Length, sshDataStream.ReadUInt32());
var actualNewPath = new byte[_newPathBytes.Length];
sshDataStream.Read(actualNewPath, 0, actualNewPath.Length);
Assert.IsTrue(_newPathBytes.SequenceEqual(actualNewPath));
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void GetBytes()
{
var localChannelNumber = (uint)_random.Next(0, int.MaxValue);
var initialWindowSize = (uint)_random.Next(0, int.MaxValue);
var maximumPacketSize = (uint)_random.Next(0, int.MaxValue);
var info = new DirectTcpipChannelInfo("host", 22, "originator", 25);
var infoBytes = info.GetBytes();
var target = new ChannelOpenMessage(localChannelNumber, initialWindowSize, maximumPacketSize, info);
var bytes = target.GetBytes();
var expectedBytesLength = 1; // Type
expectedBytesLength += 4; // ChannelType length
expectedBytesLength += target.ChannelType.Length; // ChannelType
expectedBytesLength += 4; // LocalChannelNumber
expectedBytesLength += 4; // InitialWindowSize
expectedBytesLength += 4; // MaximumPacketSize
expectedBytesLength += infoBytes.Length; // Info
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
Assert.AreEqual(ChannelOpenMessage.MessageNumber, sshDataStream.ReadByte());
var actualChannelTypeLength = sshDataStream.ReadUInt32();
Assert.AreEqual((uint) target.ChannelType.Length, actualChannelTypeLength);
var actualChannelType = new byte[actualChannelTypeLength];
sshDataStream.Read(actualChannelType, 0, (int) actualChannelTypeLength);
Assert.IsTrue(target.ChannelType.SequenceEqual(actualChannelType));
Assert.AreEqual(localChannelNumber, sshDataStream.ReadUInt32());
Assert.AreEqual(initialWindowSize, sshDataStream.ReadUInt32());
Assert.AreEqual(maximumPacketSize, sshDataStream.ReadUInt32());
var actualInfo = new byte[infoBytes.Length];
sshDataStream.Read(actualInfo, 0, actualInfo.Length);
Assert.IsTrue(infoBytes.SequenceEqual(actualInfo));
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void GetBytes()
{
var request = new SftpOpenRequest(_protocolVersion, _requestId, _filename, _encoding, _flags, null, null);
var bytes = request.GetBytes();
var expectedBytesLength = 0;
#if TUNING
expectedBytesLength += 4; // Length
#endif
expectedBytesLength += 1; // Type
expectedBytesLength += 4; // RequestId
expectedBytesLength += 4; // Filename length
expectedBytesLength += _filenameBytes.Length; // Filename
expectedBytesLength += 4; // Flags
expectedBytesLength += _attributesBytes.Length; // Attributes
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
#if TUNING
Assert.AreEqual((uint)bytes.Length - 4, sshDataStream.ReadUInt32());
#endif
Assert.AreEqual((byte)SftpMessageTypes.Open, sshDataStream.ReadByte());
Assert.AreEqual(_requestId, sshDataStream.ReadUInt32());
Assert.AreEqual((uint)_filenameBytes.Length, sshDataStream.ReadUInt32());
var actualPath = new byte[_filenameBytes.Length];
sshDataStream.Read(actualPath, 0, actualPath.Length);
Assert.IsTrue(_filenameBytes.SequenceEqual(actualPath));
Assert.AreEqual((uint) _flags, sshDataStream.ReadUInt32());
var actualAttributes = new byte[_attributesBytes.Length];
sshDataStream.Read(actualAttributes, 0, actualAttributes.Length);
Assert.IsTrue(_attributesBytes.SequenceEqual(actualAttributes));
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void GetBytes_TerminalModeValues_Empty()
{
var target = new PseudoTerminalRequestInfo(_environmentVariable,
_columns,
_rows,
_width,
_height,
new Dictionary<TerminalModes, uint>());
var bytes = target.GetBytes();
var expectedBytesLength = 1; // WantReply
expectedBytesLength += 4; // EnvironmentVariable length
expectedBytesLength += _environmentVariableBytes.Length; // EnvironmentVariable
expectedBytesLength += 4; // Columns
expectedBytesLength += 4; // Rows
expectedBytesLength += 4; // PixelWidth
expectedBytesLength += 4; // PixelHeight
expectedBytesLength += 4; // Length of "encoded terminal modes"
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
Assert.AreEqual(1, sshDataStream.ReadByte()); // WantReply
Assert.AreEqual(_environmentVariable, sshDataStream.ReadString(Encoding.UTF8));
Assert.AreEqual(_columns, sshDataStream.ReadUInt32());
Assert.AreEqual(_rows, sshDataStream.ReadUInt32());
Assert.AreEqual(_width, sshDataStream.ReadUInt32());
Assert.AreEqual(_height, sshDataStream.ReadUInt32());
Assert.AreEqual((uint) 0, sshDataStream.ReadUInt32());
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void GetBytes()
{
var request = new SftpLinkRequest(_protocolVersion, _requestId, _newLinkPath, _existingPath, true, null);
var bytes = request.GetBytes();
var expectedBytesLength = 0;
expectedBytesLength += 4; // Length
expectedBytesLength += 1; // Type
expectedBytesLength += 4; // RequestId
expectedBytesLength += 4; // NewLinkPath length
expectedBytesLength += _newLinkPathBytes.Length; // NewLinkPath
expectedBytesLength += 4; // ExistingPath length
expectedBytesLength += _existingPathBytes.Length; // ExistingPath
expectedBytesLength += 1; // IsSymLink
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
Assert.AreEqual((uint) bytes.Length - 4, sshDataStream.ReadUInt32());
Assert.AreEqual((byte) SftpMessageTypes.Link, sshDataStream.ReadByte());
Assert.AreEqual(_requestId, sshDataStream.ReadUInt32());
Assert.AreEqual((uint) _newLinkPathBytes.Length, sshDataStream.ReadUInt32());
var actualNewLinkPath = new byte[_newLinkPathBytes.Length];
sshDataStream.Read(actualNewLinkPath, 0, actualNewLinkPath.Length);
Assert.IsTrue(_newLinkPathBytes.SequenceEqual(actualNewLinkPath));
Assert.AreEqual((uint) _existingPathBytes.Length, sshDataStream.ReadUInt32());
var actualExistingPath = new byte[_existingPathBytes.Length];
sshDataStream.Read(actualExistingPath, 0, actualExistingPath.Length);
Assert.IsTrue(_existingPathBytes.SequenceEqual(actualExistingPath));
Assert.AreEqual(1, sshDataStream.ReadByte());
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void GetBytes()
{
var random = new Random();
var localChannelNumber = (uint) random.Next(0, int.MaxValue);
var data = new byte[random.Next(10, 20)];
random.NextBytes(data);
var offset = random.Next(2, 4);
var size = random.Next(5, 9);
var target = new ChannelDataMessage(localChannelNumber, data, offset, size);
var bytes = target.GetBytes();
var expectedBytesLength = 1; // Type
expectedBytesLength += 4; // LocalChannelNumber
expectedBytesLength += 4; // Data length
expectedBytesLength += size; // Data
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
Assert.AreEqual(ChannelDataMessage.MessageNumber, sshDataStream.ReadByte());
Assert.AreEqual(localChannelNumber, sshDataStream.ReadUInt32());
Assert.AreEqual((uint) size, sshDataStream.ReadUInt32());
var actualData = new byte[size];
sshDataStream.Read(actualData, 0, size);
Assert.IsTrue(actualData.SequenceEqual(data.Take(offset, size)));
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void GetBytes()
{
var request = new SftpLStatRequest(_protocolVersion, _requestId, _path, _encoding, null, null);
var bytes = request.GetBytes();
var expectedBytesLength = 0;
#if TUNING
expectedBytesLength += 4; // Length
#endif
expectedBytesLength += 1; // Type
expectedBytesLength += 4; // RequestId
expectedBytesLength += 4; // Pah length
expectedBytesLength += _pathBytes.Length; // Path
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
#if TUNING
Assert.AreEqual((uint)bytes.Length - 4, sshDataStream.ReadUInt32());
#endif
Assert.AreEqual((byte)SftpMessageTypes.LStat, sshDataStream.ReadByte());
Assert.AreEqual(_requestId, sshDataStream.ReadUInt32());
Assert.AreEqual((uint) _pathBytes.Length, sshDataStream.ReadUInt32());
var actualPath = new byte[_pathBytes.Length];
sshDataStream.Read(actualPath, 0, actualPath.Length);
Assert.IsTrue(_pathBytes.SequenceEqual(actualPath));
Assert.IsTrue(sshDataStream.IsEndOfData);
}
internal static SftpFileAttributes FromBytes(SshDataStream stream)
{
var flag = stream.ReadUInt32();
long size = -1;
var userId = -1;
var groupId = -1;
uint permissions = 0;
var accessTime = DateTime.MinValue;
var modifyTime = DateTime.MinValue;
IDictionary<string, string> extensions = null;
if ((flag & 0x00000001) == 0x00000001) // SSH_FILEXFER_ATTR_SIZE
{
size = (long) stream.ReadUInt64();
}
if ((flag & 0x00000002) == 0x00000002) // SSH_FILEXFER_ATTR_UIDGID
{
userId = (int) stream.ReadUInt32();
groupId = (int) stream.ReadUInt32();
}
if ((flag & 0x00000004) == 0x00000004) // SSH_FILEXFER_ATTR_PERMISSIONS
{
permissions = stream.ReadUInt32();
}
if ((flag & 0x00000008) == 0x00000008) // SSH_FILEXFER_ATTR_ACMODTIME
{
var time = stream.ReadUInt32();
accessTime = DateTime.FromFileTime((time + 11644473600) * 10000000);
time = stream.ReadUInt32();
modifyTime = DateTime.FromFileTime((time + 11644473600) * 10000000);
}
if ((flag & 0x80000000) == 0x80000000) // SSH_FILEXFER_ATTR_EXTENDED
{
var extendedCount = (int) stream.ReadUInt32();
extensions = new Dictionary<string, string>(extendedCount);
for (var i = 0; i < extendedCount; i++)
{
var extensionName = stream.ReadString(SshData.Utf8);
var extensionData = stream.ReadString(SshData.Utf8);
extensions.Add(extensionName, extensionData);
}
}
return new SftpFileAttributes(accessTime, modifyTime, size, userId, groupId, permissions, extensions);
}
public void GetBytes()
{
#if TUNING
var request = new SftpWriteRequest(_protocolVersion, _requestId, _handle, _offset, _data, _length, null);
#else
var request = new SftpWriteRequest(_protocolVersion, _requestId, _handle, _offset, _data, null);
#endif
var bytes = request.GetBytes();
var expectedBytesLength = 0;
#if TUNING
expectedBytesLength += 4; // Length
#endif
expectedBytesLength += 1; // Type
expectedBytesLength += 4; // RequestId
expectedBytesLength += 4; // Handle length
expectedBytesLength += _handle.Length; // Handle
expectedBytesLength += 8; // Offset
expectedBytesLength += 4; // Data length
expectedBytesLength += _length; // Data
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
#if TUNING
Assert.AreEqual((uint) bytes.Length - 4, sshDataStream.ReadUInt32());
#endif
Assert.AreEqual((byte) SftpMessageTypes.Write, sshDataStream.ReadByte());
Assert.AreEqual(_requestId, sshDataStream.ReadUInt32());
Assert.AreEqual((uint) _handle.Length, sshDataStream.ReadUInt32());
var actualHandle = new byte[_handle.Length];
sshDataStream.Read(actualHandle, 0, actualHandle.Length);
Assert.IsTrue(_handle.SequenceEqual(actualHandle));
Assert.AreEqual(_offset, sshDataStream.ReadUInt64());
Assert.AreEqual((uint) _length, sshDataStream.ReadUInt32());
var actualData = new byte[_length];
sshDataStream.Read(actualData, 0, actualData.Length);
Assert.IsTrue(_data.Take(_length).SequenceEqual(actualData));
Assert.IsTrue(sshDataStream.IsEndOfData);
}
