public void NullBufferCtorWithOffset_Throws()
{
Assert.Throws<ArgumentNullException>(() =>
{
SendPacketsElement element = new SendPacketsElement((byte[])null, 0, 0);
});
}
public void BufferCtorNegCount_ArgumentOutOfRangeException()
{
Assert.Throws<ArgumentOutOfRangeException>(() =>
{
SendPacketsElement element = new SendPacketsElement(new byte[10], 0, -1);
});
}
public void NullBufferCtorWithEndOfPacket_Throws()
{
Assert.Throws <ArgumentNullException>(() =>
{
// Elements with null Buffers are ignored on Send
SendPacketsElement element = new SendPacketsElement((byte[])null, 0, 0, true);
});
}
public void NullBufferCtorWithEndOfPacket_Throws()
{
Assert.Throws<ArgumentNullException>(() =>
{
// Elements with null Buffers are ignored on Send
SendPacketsElement element = new SendPacketsElement((byte[])null, 0, 0, true);
});
}
public void BufferMixedBuffers_ZeroCountBufferIgnored(BufferType bufferType)
{
using var e1 = CreateElementForBuffer(bufferType, 10, 4, 0);
using var e2 = CreateElementForBuffer(bufferType, 10, 4, 4);
using var e3 = CreateElementForBuffer(bufferType, 10, 0, 4);
SendPacketsElement[] elements = new SendPacketsElement[] { e1.Element, e2.Element, e3.Element };
SendPackets(elements, SocketError.Success, 8);
}
public void Enqueue(SendPacketsElement buffer)
{
if (_bytesLeft <= 0)
{
throw new InvalidOperationException(
"Too much data, check the BytesLeftToEnqueue property before enqueing too much.");
}
_bytesLeft -= buffer.Count;
_buffers.Add(buffer);
}
public void SendPacketsElement_FileMultiPart_Success(SocketImplementationType type)
{
SendPacketsElement[] elements = new SendPacketsElement[]
{
new SendPacketsElement(TestFileName, 10, 20),
new SendPacketsElement(TestFileName, 30, 10),
new SendPacketsElement(TestFileName, 0, 10),
};
SendPackets(type, elements, SocketError.Success, 40);
}
public void FileCtorEndOfBufferFalse_Success()
{
SendPacketsElement element = new SendPacketsElement("SomeFileName", 6, 4, false);
Assert.Null(element.Buffer);
Assert.Equal(6, element.Offset);
Assert.Equal(4, element.Count);
Assert.False(element.EndOfPacket);
Assert.Equal("SomeFileName", element.FilePath);
}
public void BufferCtorNormal_Success()
{
SendPacketsElement element = new SendPacketsElement(new byte[10]);
Assert.NotNull(element.Buffer);
Assert.Equal(10, element.Buffer.Length);
Assert.Equal(0, element.Offset);
Assert.Equal(10, element.Count);
Assert.False(element.EndOfPacket);
Assert.Null(element.FilePath);
}
public void BufferMixedBuffers_ZeroCountBufferIgnored()
{
SendPacketsElement[] elements = new SendPacketsElement[]
{
new SendPacketsElement(new byte[10], 4, 0), // Ignored
new SendPacketsElement(new byte[10], 4, 4),
new SendPacketsElement(new byte[10], 0, 4)
};
SendPackets(elements, SocketError.Success, 8);
}
public void FileCtorEndOfBufferTrue_Success()
{
SendPacketsElement element = new SendPacketsElement("SomeFileName", 2, 8, true);
Assert.Null(element.Buffer);
Assert.Equal(2, element.Offset);
Assert.Equal(8, element.Count);
Assert.True(element.EndOfPacket);
Assert.Equal("SomeFileName", element.FilePath);
}
/// <summary>
/// Initializes new instance of <see cref="SendPacketsElementAdapter"/>.
/// </summary>
/// <param name="element">Element to be used by the adapter.</param>
public SendPacketsElementAdapter(SendPacketsElement element)
: base(element)
{
if (element == null)
{
throw new ArgumentNullException(nameof(element));
}
_element = element;
}
public void SendPacketsElement_FileMultiPart_Success()
{
SendPacketsElement[] elements = new SendPacketsElement[]
{
new SendPacketsElement(TestFileName, 10, 20),
new SendPacketsElement(TestFileName, 30, 10),
new SendPacketsElement(TestFileName, 0, 10),
};
SendPackets(elements, SocketError.Success, 40);
}
public void BufferCtorEndOfBufferTrue_Success()
{
SendPacketsElement element = new SendPacketsElement(new byte[10], 2, 8, true);
Assert.NotNull(element.Buffer);
Assert.Equal(10, element.Buffer.Length);
Assert.Equal(2, element.Offset);
Assert.Equal(8, element.Count);
Assert.True(element.EndOfPacket);
Assert.Null(element.FilePath);
}
public void EmptyBufferCtor_Success()
{
// Elements with empty Buffers are ignored on Send
SendPacketsElement element = new SendPacketsElement(new byte[0]);
Assert.NotNull(element.Buffer);
Assert.Equal(0, element.Buffer.Length);
Assert.Equal(0, element.Offset);
Assert.Equal(0, element.Count);
Assert.False(element.EndOfPacket);
Assert.Null(element.FilePath);
}
public void BufferCtorNormal_Success()
{
SendPacketsElement element = new SendPacketsElement(new byte[10]);
Assert.NotNull(element.Buffer);
Assert.Equal(10, element.Buffer.Length);
Assert.Equal(0, element.Offset);
Assert.Equal(10, element.Count);
Assert.False(element.EndOfPacket);
Assert.Null(element.FilePath);
}
public void FileCtorWhiteSpace_Success()
{
// An exception will happen on send if this file doesn't exist
SendPacketsElement element = new SendPacketsElement(" \t ");
Assert.Null(element.Buffer);
Assert.Equal(0, element.Offset);
Assert.Equal(0, element.Count);
Assert.False(element.EndOfPacket);
Assert.Equal(" \t ", element.FilePath);
}
public void BufferCtorEndOfBufferFalse_Success()
{
SendPacketsElement element = new SendPacketsElement(new byte[10], 6, 4, false);
Assert.NotNull(element.Buffer);
Assert.Equal(10, element.Buffer.Length);
Assert.Equal(6, element.Offset);
Assert.Equal(4, element.Count);
Assert.False(element.EndOfPacket);
Assert.Null(element.FilePath);
}
public void FileCtorZeroCountLength_Success()
{
// An exception will happen on send if this file doesn't exist
SendPacketsElement element = new SendPacketsElement("SomeFileName", 0, 0); // Send whole file
Assert.Null(element.Buffer);
Assert.Equal(0, element.Offset);
Assert.Equal(0, element.Count);
Assert.False(element.EndOfPacket);
Assert.Equal("SomeFileName", element.FilePath);
}
public void EmptyBufferCtor_Success()
{
// Elements with empty Buffers are ignored on Send
SendPacketsElement element = new SendPacketsElement(new byte[0]);
Assert.NotNull(element.Buffer);
Assert.Equal(0, element.Buffer.Length);
Assert.Equal(0, element.Offset);
Assert.Equal(0, element.Count);
Assert.False(element.EndOfPacket);
Assert.Null(element.FilePath);
}
public void FileCtorEmpty_OffsetLong_Success()
{
// An exception will happen on send if this file doesn't exist
SendPacketsElement element = new SendPacketsElement(string.Empty);
Assert.Null(element.Buffer);
Assert.Equal(0, element.Offset);
Assert.Equal(0, element.Count);
Assert.Equal(0, element.OffsetLong);
Assert.False(element.EndOfPacket);
Assert.Equal(string.Empty, element.FilePath);
}
public void EmptyMemoryCtor_Success()
{
SendPacketsElement element = new SendPacketsElement(default(ReadOnlyMemory <byte>));
Assert.NotNull(element.MemoryBuffer);
Assert.Equal(0, element.MemoryBuffer.Value.Length);
Assert.Null(element.Buffer);
Assert.Equal(0, element.Offset);
Assert.Equal(element.MemoryBuffer.Value.Length, element.Count);
Assert.False(element.EndOfPacket);
Assert.Null(element.FilePath);
Assert.Null(element.FileStream);
}
public void memoryCtorEndOfPacketFalse_Success()
{
SendPacketsElement element = new SendPacketsElement(new ReadOnlyMemory <byte>(new byte[10], 6, 4), false);
Assert.NotNull(element.MemoryBuffer);
Assert.Equal(4, element.MemoryBuffer.Value.Length);
Assert.Null(element.Buffer);
Assert.Equal(0, element.Offset);
Assert.Equal(element.MemoryBuffer.Value.Length, element.Count);
Assert.False(element.EndOfPacket);
Assert.Null(element.FilePath);
Assert.Null(element.FileStream);
}
public void MemoryCtorNormal_Success()
{
SendPacketsElement element = new SendPacketsElement(new byte[10].AsMemory());
Assert.NotNull(element.MemoryBuffer);
Assert.Equal(10, element.MemoryBuffer.Value.Length);
Assert.Null(element.Buffer);
Assert.Equal(0, element.Offset);
Assert.Equal(element.MemoryBuffer.Value.Length, element.Count);
Assert.False(element.EndOfPacket);
Assert.Null(element.FilePath);
Assert.Null(element.FileStream);
}
public void FileCtorNormal_OffsetLong_FileStream_Success()
{
// An exception will happen on send if this file doesn't exist
SendPacketsElement element = new SendPacketsElement("SomeFileName"); // Send whole file
Assert.Null(element.FileStream);
Assert.Null(element.Buffer);
Assert.Null(element.MemoryBuffer);
Assert.Equal(0, element.Offset);
Assert.Equal(0, element.Count);
Assert.Equal(0, element.OffsetLong);
Assert.False(element.EndOfPacket);
Assert.Equal("SomeFileName", element.FilePath);
}
public void MemoryCtorZeroCount_Success()
{
// Elements with empty Buffers are ignored on Send
SendPacketsElement element = new SendPacketsElement(new ReadOnlyMemory <byte>(new byte[0], 0, 0));
Assert.NotNull(element.MemoryBuffer);
Assert.Equal(0, element.MemoryBuffer.Value.Length);
Assert.Null(element.Buffer);
Assert.Equal(0, element.Offset);
Assert.Equal(element.MemoryBuffer.Value.Length, element.Count);
Assert.False(element.EndOfPacket);
Assert.Null(element.FilePath);
Assert.Null(element.FileStream);
}
public void BufferCtorZeroCount_OffsetLong_FileStream_Success()
{
// Elements with empty Buffers are ignored on Send
SendPacketsElement element = new SendPacketsElement(new byte[0], 0, 0);
Assert.NotNull(element.Buffer);
Assert.Equal(0, element.Buffer.Length);
Assert.Equal(0, element.Offset);
Assert.Equal(0, element.Count);
Assert.Equal(0, element.OffsetLong);
Assert.False(element.EndOfPacket);
Assert.Null(element.FilePath);
Assert.Null(element.FileStream);
}
public void FileStreamCtorNormal_Success()
{
using (var stream = File.Create(Path.GetTempFileName(), 4096, FileOptions.DeleteOnClose | FileOptions.Asynchronous))
{
SendPacketsElement element = new SendPacketsElement(stream);
Assert.Null(element.FilePath);
Assert.Equal(element.FileStream, stream);
Assert.Null(element.Buffer);
Assert.Equal(0, element.Offset);
Assert.Equal(0, element.Count);
Assert.Equal(0, element.OffsetLong);
Assert.False(element.EndOfPacket);
}
}
private void SendPackets(SocketImplementationType type, SendPacketsElement element, TransmitFileOptions flags, int bytesExpected)
{
Assert.True(Capability.IPv6Support());
EventWaitHandle completed = new ManualResetEvent(false);
int port;
using (SocketTestServer.SocketTestServerFactory(type, _serverAddress, out port))
{
using (Socket sock = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp))
{
sock.Connect(new IPEndPoint(_serverAddress, port));
using (SocketAsyncEventArgs args = new SocketAsyncEventArgs())
{
args.Completed += OnCompleted;
args.UserToken = completed;
args.SendPacketsElements = new[] { element };
args.SendPacketsFlags = flags;
if (sock.SendPacketsAsync(args))
{
Assert.True(completed.WaitOne(TestSettings.PassingTestTimeout), "Timed out");
}
Assert.Equal(SocketError.Success, args.SocketError);
Assert.Equal(bytesExpected, args.BytesTransferred);
}
switch (flags)
{
case TransmitFileOptions.Disconnect:
// Sending data again throws with socket shut down error.
Assert.Throws <SocketException>(() => { sock.Send(new byte[1] {
01
}); });
break;
case TransmitFileOptions.ReuseSocket & TransmitFileOptions.Disconnect:
// Able to send data again with reuse socket flag set.
Assert.Equal(1, sock.Send(new byte[1] {
01
}));
break;
}
}
}
}
public void TransparentDispose()
{
var buffer = new byte[5];
var elements = new SendPacketsElement[2];
var utoken = new object();
var saea = new SocketAsyncEventArgs();
saea.SetBuffer(buffer, 0, 3);
saea.SendPacketsElements = elements;
saea.UserToken = utoken;
saea.Dispose();
Assert.AreEqual(buffer, saea.Buffer);
Assert.AreEqual(elements, saea.SendPacketsElements);
Assert.AreEqual(utoken, saea.UserToken);
}
public static Task <SocketResult> SendAsync(this Socket socket, byte[] data, IOCPBase iocpBase, UserToken userToken)
{
if (data.Length > iocpBase.BufferSize)
{
SendPacketsElement[] elements = new SendPacketsElement[1];
elements[0] = new SendPacketsElement(data, 0, data.Length, true);
return(SendDataAsync(socket, elements, iocpBase, userToken));
}
var task = userToken.CompletionSource;
Array.Copy(data, 0, userToken.ReceiveArgs.Buffer, userToken.ReceiveArgs.Offset, data.Length);
userToken.ReceiveArgs.SetBuffer(userToken.ReceiveArgs.Offset, data.Length);
if (!socket.SendAsync(userToken.ReceiveArgs))
{
SocketResult result = new SocketResult {
SocketError = userToken.ReceiveArgs.SocketError, Args = userToken.ReceiveArgs
};
iocpBase.ProcessSend(userToken.ReceiveArgs, result);
}
return(task);
}
public void FileStreamCtorEndOfBufferFalse_Success()
{
using (var stream = File.Create(Path.GetTempFileName(), 4096, FileOptions.DeleteOnClose | FileOptions.Asynchronous))
{
SendPacketsElement element = new SendPacketsElement(stream, 6, 4, false);
Assert.Null(element.FilePath);
Assert.Equal(element.FileStream, stream);
Assert.Null(element.Buffer);
Assert.Null(element.MemoryBuffer);
Assert.Equal(6, element.Offset);
Assert.Equal(4, element.Count);
Assert.Equal(6, element.OffsetLong);
Assert.False(element.EndOfPacket);
element = new SendPacketsElement(stream, 6L, 4, false);
Assert.Null(element.FilePath);
Assert.Equal(element.FileStream, stream);
Assert.Null(element.Buffer);
Assert.Null(element.MemoryBuffer);
Assert.Equal(6, element.Offset);
Assert.Equal(4, element.Count);
Assert.Equal(6, element.OffsetLong);
Assert.False(element.EndOfPacket);
element = new SendPacketsElement(stream, (long)int.MaxValue + 6, 4, false);
Assert.Null(element.FilePath);
Assert.Equal(element.FileStream, stream);
Assert.Null(element.Buffer);
Assert.Null(element.MemoryBuffer);
Assert.Throws <OverflowException>(() =>
{
var ofset = element.Offset;
});
Assert.Equal(4, element.Count);
Assert.Equal((long)int.MaxValue + 6, element.OffsetLong);
Assert.False(element.EndOfPacket);
}
}
public static SendPacketsElement[] BufferSplit(byte[] buffer, int blockSize)
{
MemoryStream ms = new MemoryStream(buffer);
List <SendPacketsElement> list = new List <SendPacketsElement>();
var size = buffer.Length;
var chunkCount = blockSize;
var bufferArray = new byte[chunkCount][];
for (var i = 0; i < chunkCount; i++)
{
bufferArray[i] = new byte[chunkCount];
for (var j = 0; j < chunkCount && i * chunkCount + j < size; j++)
{
bufferArray[i][j] = buffer[i * chunkCount + j];
}
}
foreach (byte[] array in bufferArray)
{
SendPacketsElement spe = new SendPacketsElement(array);
list.Add(spe);
}
return(list.ToArray());
}
public void FileCtorEndOfBufferFalse_OffsetLong_FileStream_Success()
{
SendPacketsElement element = new SendPacketsElement("SomeFileName", 6, 4, false);
Assert.Null(element.FileStream);
Assert.Null(element.Buffer);
Assert.Null(element.MemoryBuffer);
Assert.Equal(6, element.Offset);
Assert.Equal(4, element.Count);
Assert.Equal(6, element.OffsetLong);
Assert.False(element.EndOfPacket);
Assert.Equal("SomeFileName", element.FilePath);
element = new SendPacketsElement("SomeFileName", 6L, 4, false);
Assert.Null(element.FileStream);
Assert.Null(element.Buffer);
Assert.Null(element.MemoryBuffer);
Assert.Equal(6, element.Offset);
Assert.Equal(4, element.Count);
Assert.Equal(6, element.OffsetLong);
Assert.False(element.EndOfPacket);
Assert.Equal("SomeFileName", element.FilePath);
element = new SendPacketsElement("SomeFileName", (long)int.MaxValue + 6, 4, false);
Assert.Null(element.FileStream);
Assert.Null(element.Buffer);
Assert.Null(element.MemoryBuffer);
Assert.Throws <OverflowException>(() =>
{
var ofset = element.Offset;
});
Assert.Equal(4, element.Count);
Assert.Equal((long)int.MaxValue + 6, element.OffsetLong);
Assert.False(element.EndOfPacket);
Assert.Equal("SomeFileName", element.FilePath);
}
public void FileCtorNegCount_ArgumentOutOfRangeException()
{
Assert.Throws<ArgumentOutOfRangeException>(() =>
{
SendPacketsElement element = new SendPacketsElement("SomeFileName", 0, -1);
});
}
public void FileCtorZeroCountLength_Success()
{
// An exception will happen on send if this file doesn't exist
SendPacketsElement element = new SendPacketsElement("SomeFileName", 0, 0); // Send whole file
Assert.Null(element.Buffer);
Assert.Equal(0, element.Offset);
Assert.Equal(0, element.Count);
Assert.False(element.EndOfPacket);
Assert.Equal("SomeFileName", element.FilePath);
}
private void SendPackets(SocketImplementationType type, SendPacketsElement[] elements, SocketError expectedResut, int bytesExpected)
{
Assert.True(Capability.IPv6Support());
EventWaitHandle completed = new ManualResetEvent(false);
int port;
using (SocketTestServer.SocketTestServerFactory(type, _serverAddress, out port))
{
using (Socket sock = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp))
{
sock.Connect(new IPEndPoint(_serverAddress, port));
using (SocketAsyncEventArgs args = new SocketAsyncEventArgs())
{
args.Completed += OnCompleted;
args.UserToken = completed;
args.SendPacketsElements = elements;
if (sock.SendPacketsAsync(args))
{
Assert.True(completed.WaitOne(TestSettings.PassingTestTimeout), "Timed out");
}
Assert.Equal(expectedResut, args.SocketError);
Assert.Equal(bytesExpected, args.BytesTransferred);
}
}
}
}
private void SendPackets(SocketImplementationType type, SendPacketsElement element, SocketError expectedResut, int bytesExpected)
{
SendPackets(type, new SendPacketsElement[] { element }, expectedResut, bytesExpected);
}
public void SendPacketsElement_FileMultiPart_Success(SocketImplementationType type)
{
SendPacketsElement[] elements = new SendPacketsElement[]
{
new SendPacketsElement(TestFileName, 10, 20),
new SendPacketsElement(TestFileName, 30, 10),
new SendPacketsElement(TestFileName, 0, 10),
};
SendPackets(type, elements, SocketError.Success, 40);
}
public void SendPacketsElement_FileMultiPart_Success()
{
SendPacketsElement[] elements = new SendPacketsElement[]
{
new SendPacketsElement(TestFileName, 10, 20),
new SendPacketsElement(TestFileName, 30, 10),
new SendPacketsElement(TestFileName, 0, 10),
};
SendPackets(elements, SocketError.Success, 40);
}
public void FileCtorNull_Throws()
{
Assert.Throws<ArgumentNullException>(() =>
{
SendPacketsElement element = new SendPacketsElement((string)null);
});
}
public void FileCtorEndOfBufferTrue_Success()
{
SendPacketsElement element = new SendPacketsElement("SomeFileName", 2, 8, true);
Assert.Null(element.Buffer);
Assert.Equal(2, element.Offset);
Assert.Equal(8, element.Count);
Assert.True(element.EndOfPacket);
Assert.Equal("SomeFileName", element.FilePath);
}
public void FileCtorEndOfBufferFalse_Success()
{
SendPacketsElement element = new SendPacketsElement("SomeFileName", 6, 4, false);
Assert.Null(element.Buffer);
Assert.Equal(6, element.Offset);
Assert.Equal(4, element.Count);
Assert.False(element.EndOfPacket);
Assert.Equal("SomeFileName", element.FilePath);
}
public void BufferCtorLargeOffset_ArgumentOutOfRangeException()
{
Assert.Throws<ArgumentOutOfRangeException>(() =>
{
SendPacketsElement element = new SendPacketsElement(new byte[10], 11, 1);
});
}
public void FileCtorWhiteSpace_Success()
{
// An exception will happen on send if this file doesn't exist
SendPacketsElement element = new SendPacketsElement(" \t ");
Assert.Null(element.Buffer);
Assert.Equal(0, element.Offset);
Assert.Equal(0, element.Count);
Assert.False(element.EndOfPacket);
Assert.Equal(" \t ", element.FilePath);
}
private void SendPackets(SocketImplementationType type, SendPacketsElement element, TransmitFileOptions flags, int bytesExpected)
{
Assert.True(Capability.IPv6Support());
EventWaitHandle completed = new ManualResetEvent(false);
int port;
using (SocketTestServer.SocketTestServerFactory(type, _serverAddress, out port))
{
using (Socket sock = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp))
{
sock.Connect(new IPEndPoint(_serverAddress, port));
using (SocketAsyncEventArgs args = new SocketAsyncEventArgs())
{
args.Completed += OnCompleted;
args.UserToken = completed;
args.SendPacketsElements = new[] { element };
args.SendPacketsFlags = flags;
if (sock.SendPacketsAsync(args))
{
Assert.True(completed.WaitOne(TestSettings.PassingTestTimeout), "Timed out");
}
Assert.Equal(SocketError.Success, args.SocketError);
Assert.Equal(bytesExpected, args.BytesTransferred);
}
switch (flags)
{
case TransmitFileOptions.Disconnect:
// Sending data again throws with socket shut down error.
Assert.Throws<SocketException>(() => { sock.Send(new byte[1] { 01 }); });
break;
case TransmitFileOptions.ReuseSocket & TransmitFileOptions.Disconnect:
// Able to send data again with reuse socket flag set.
Assert.Equal(1, sock.Send(new byte[1] { 01 }));
break;
}
}
}
}
public void BufferCtorEndOfBufferFalse_Success()
{
SendPacketsElement element = new SendPacketsElement(new byte[10], 6, 4, false);
Assert.NotNull(element.Buffer);
Assert.Equal(10, element.Buffer.Length);
Assert.Equal(6, element.Offset);
Assert.Equal(4, element.Count);
Assert.False(element.EndOfPacket);
Assert.Null(element.FilePath);
}
public void BufferMixedBuffers_ZeroCountBufferIgnored(SocketImplementationType type)
{
SendPacketsElement[] elements = new SendPacketsElement[]
{
new SendPacketsElement(new byte[10], 4, 0), // Ignored
new SendPacketsElement(new byte[10], 4, 4),
new SendPacketsElement(new byte[10], 0, 4)
};
SendPackets(type, elements, SocketError.Success, 8);
}
private void SendPackets(SendPacketsElement element, int bytesExpected)
{
SendPackets(new SendPacketsElement[] { element }, SocketError.Success, bytesExpected);
}
public void BufferCtorEndOfBufferTrue_Success()
{
SendPacketsElement element = new SendPacketsElement(new byte[10], 2, 8, true);
Assert.NotNull(element.Buffer);
Assert.Equal(10, element.Buffer.Length);
Assert.Equal(2, element.Offset);
Assert.Equal(8, element.Count);
Assert.True(element.EndOfPacket);
Assert.Null(element.FilePath);
}
public ElementWithMemoryManager(SendPacketsElement element, MemoryManager <byte> memoryManager)
{
Element = element;
MemoryManager = memoryManager;
}
private void SendPackets(SendPacketsElement element, SocketError expectedResut, int bytesExpected)
{
SendPackets(new SendPacketsElement[] { element }, expectedResut, bytesExpected);
}
