public void SmartSockReceive()
{
var endPoint = new IPEndPoint(IPAddress.Loopback, 23451);
_sock.Connect(endPoint.Address, endPoint.Port);
Utils.SendConnectResponse(_bareSock, endPoint, _bufferPool);
var header = new PacketHeader();
header.SetSeqNum(1);
header.Length = (ushort)(header.HeaderLength + 4);
var ms = new MemoryStream();
header.WriteTo(ms);
ms.Write(BitConverter.GetBytes(123456789), 0, 4); // Payload
var buffer = ms.ToArray();
// Simulate send from UdpClient
_bareSock.FakeReceive(buffer, 0, buffer.Length, endPoint);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsTrue(_sock.Receive(ref receivedPacket));
Assert.AreEqual(123456789, BitConverter.ToInt32(receivedPacket.Buffer, receivedPacket.Offset));
Assert.AreEqual(7, receivedPacket.Offset); // Length + Flags + SeqNum + SessionId
Assert.AreEqual(4, receivedPacket.Length);
}
public void SequenceNumberResetAfterConnectionTimeout()
{
_sock.ConnectionTimeout = 1;
var endPoint = new IPEndPoint(IPAddress.Loopback, 23452);
Utils.SendConnectRequest(_bareSock, endPoint, _bufferPool);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsFalse(_sock.Receive(ref receivedPacket));
Assert.AreEqual(1, _cbs.OnConnectCalls.Count);
var ms = new MemoryStream();
ms.Write(BitConverter.GetBytes(123456789), 0, 4);
var buffer = ms.ToArray();
_sock.Send(endPoint, buffer, 0, buffer.Length, false);
Thread.Sleep(20);
_sock.Tick();
_sock.Send(endPoint, buffer, 0, buffer.Length, false);
// Two sends total
Assert.AreEqual(2, _bareSock.Sends.Count);
// Last Sequnce number is zero
var header = new PacketHeader();
header.Init(_bareSock.Sends[1].Buffer, _bareSock.Sends[1].Offset);
Assert.AreEqual(0, header.SeqNum);
}
public void SmartSockSendConnected()
{
var endPoint = new IPEndPoint(IPAddress.Loopback, 23452);
_sock.Connect(endPoint.Address, endPoint.Port);
Utils.SendConnectResponse(_bareSock, endPoint, _bufferPool);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsFalse(_sock.Receive(ref receivedPacket));
var ms = new MemoryStream();
ms.Write(BitConverter.GetBytes(123456789), 0, 4);
var buffer = ms.ToArray();
_sock.Send(buffer, 0, buffer.Length, false);
Assert.AreEqual(1, _cbs.OnConnectCalls.Count);
Assert.AreEqual(2, _bareSock.Sends.Count);
var header = new PacketHeader();
var packetToSend = _bareSock.LastSend;
header.Init(packetToSend.Buffer, packetToSend.Offset);
Assert.AreEqual(buffer.Length + header.HeaderLength, header.Length);
Assert.AreEqual(123456789, BitConverter.ToInt32(packetToSend.Buffer, header.HeaderLength));
Assert.IsTrue(packetToSend.PutBufferToPool, "Unreliable packets should return to pool after send");
}
public void ServerRepliesWithFilledSessionId()
{
var clientEndPoint = new IPEndPoint(IPAddress.Loopback, 54321);
Utils.SendConnectRequest(_bareSock, clientEndPoint, _bufferPool);
ushort seqNum = 1;
FakeSendPacket(0, 123456789, clientEndPoint, ref seqNum);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsTrue(_sock.Receive(ref receivedPacket));
Assert.AreEqual(1, _cbs.OnConnectCalls.Count);
Assert.AreEqual(0, _cbs.OnDisconnectCalls.Count);
// Reply from server
_sock.Send(clientEndPoint, BitConverter.GetBytes(123456789), 0, 4, false);
Assert.AreEqual(2, _bareSock.Sends.Count);
var packet = _bareSock.LastSend;
var header = new PacketHeader();
header.Init(packet.Buffer, packet.Offset);
Assert.AreNotEqual(PacketHeader.EmptySessionId, header.SessionId);
}
public void ReceivedPacketWithWrongLengthDropped()
{
var remoteEndPoint = new IPEndPoint(IPAddress.Loopback, 54321);
_sock.Connect(remoteEndPoint.Address, remoteEndPoint.Port);
Utils.SendConnectResponse(_bareSock, remoteEndPoint, _bufferPool);
var header = new PacketHeader(); // Wrong Length
header.Length = 5;
var buffer = _bufferPool.Get(header.HeaderLength);
var ms = new MemoryStream(buffer);
header.WriteTo(ms);
ms.Write(BitConverter.GetBytes(123456789), 0, 4); // Payload
// Simulate send from UdpClient
_bareSock.FakeReceive(buffer, 0, (int)ms.Length, remoteEndPoint);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsFalse(_sock.Receive(ref receivedPacket));
Assert.AreEqual(1, _cbs.OnConnectCalls.Count);
}
private static void Connect(string addr, SmartSock sock)
{
sock.Connect(IPAddress.Parse(addr), 2345);
var ep = sock.LocalEndPoint;
Console.WriteLine("{0}:{1}", ep.Address, ep.Port);
var packet = new ReceivedSmartPacket();
while (sock.State == PixocketState.Connecting)
{
sock.Tick();
if (sock.Receive(ref packet))
{
break;
}
}
var rnd = new Random(Guid.NewGuid().GetHashCode());
var count = 700 + rnd.Next(500);
byte[] initMsg = CreateMessage(count);
Console.WriteLine("Sending message with {0} numbers", count);
sock.Send(initMsg, 0, initMsg.Length, true);
}
public void ConnectResponseResent()
{
var remoteEndPoint = new IPEndPoint(IPAddress.Loopback, 54321);
var receivedPacket = new ReceivedSmartPacket();
for (int i = 1; i < 11; ++i)
{
Utils.SendConnectRequest(_bareSock, remoteEndPoint, _bufferPool);
Assert.AreEqual(PixocketState.NotConnected, _sock.State, "Server is not going to connected state");
Assert.IsFalse(_sock.Receive(ref receivedPacket));
Assert.AreEqual(PixocketState.NotConnected, _sock.State, "Server is not going to connected state");
Assert.AreEqual(i, _bareSock.Sends.Count);
var header = new PacketHeader();
var packetSent = _bareSock.LastSend;
header.Init(packetSent.Buffer, packetSent.Offset);
Assert.IsTrue((header.Flags & PacketHeader.Connect) != 0);
Assert.AreNotEqual(PacketHeader.EmptySessionId, header.SessionId);
Assert.AreEqual(1, _cbs.OnConnectCalls.Count);
Assert.AreEqual(remoteEndPoint, _cbs.OnConnectCalls[0]);
Assert.AreEqual(0, _cbs.OnDisconnectCalls.Count);
}
}
public void DisconnectedOnTimeout()
{
_sock.ConnectionTimeout = 1;
var remoteEndPoint = new IPEndPoint(IPAddress.Loopback, 54321);
_sock.Connect(remoteEndPoint.Address, remoteEndPoint.Port);
Utils.SendConnectResponse(_bareSock, remoteEndPoint, _bufferPool);
var header = new PacketHeader();
header.SetSeqNum(1);
header.Length = (ushort)(header.HeaderLength + 4);
var ms = new MemoryStream();
header.WriteTo(ms);
ms.Write(BitConverter.GetBytes(123456789), 0, 4); // Payload
var buffer = Utils.ToBuffer(ms, _bufferPool);
// Simulate send from UdpClient
_bareSock.FakeReceive(buffer.Array, buffer.Offset, buffer.Count, remoteEndPoint);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsTrue(_sock.Receive(ref receivedPacket));
Thread.Sleep(20);
_sock.Tick();
Assert.AreEqual(1, _cbs.OnConnectCalls.Count);
Assert.AreEqual(1, _cbs.OnDisconnectCalls.Count);
}
public void ThreadSmartSockReceives()
{
var endPoint = new IPEndPoint(IPAddress.Loopback, 23452);
_threadSmartSock.Connect(endPoint.Address, endPoint.Port); // NotConnected -> Connecting
Utils.SendConnectResponse(_bareSock, endPoint, _bufferPool);
WaitConnect();
var buffer = Utils.CreatePacket(1234567890);
_bareSock.FakeReceive(buffer, 0, buffer.Length, endPoint);
var receivedPacket = new ReceivedSmartPacket();
for (int i = 0; i < 1000; i++)
{
if (_threadSmartSock.Receive(ref receivedPacket))
{
break;
}
Thread.Sleep(1);
}
Assert.IsNotNull(receivedPacket.Buffer);
}
public void SendReliable()
{
var endPoint = new IPEndPoint(IPAddress.Loopback, 23452);
Utils.SendConnectRequest(_bareSock, endPoint, _bufferPool);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsFalse(_sock.Receive(ref receivedPacket));
var ms = new MemoryStream();
ms.Write(BitConverter.GetBytes(123456789), 0, 4);
var buffer = ms.ToArray();
_sock.Send(endPoint, buffer, 0, buffer.Length, true);
Assert.AreEqual(2, _bareSock.Sends.Count);
var packetToSend = _bareSock.LastSend;
var header = new PacketHeader();
header.Init(packetToSend.Buffer, packetToSend.Offset);
Assert.AreEqual(buffer.Length + header.HeaderLength, header.Length);
Assert.AreEqual(123456789, BitConverter.ToInt32(packetToSend.Buffer, header.HeaderLength));
Assert.AreEqual(0, header.SeqNum);
Assert.IsTrue(header.GetNeedAck());
Assert.IsFalse(packetToSend.PutBufferToPool, "Reliable packets should wait for Ack before going to pool");
}
private void Tick()
{
while (true)
{
if (_initReceived)
{
var ms = new MemoryStream();
ms.WriteByte(1); // Move request
ms.Write(BitConverter.GetBytes((float)_myV.X), 0, 4);
ms.Write(BitConverter.GetBytes((float)_myV.Y), 0, 4);
var buf = ms.ToArray();
_socket.Send(buf, 0, buf.Length, false);
}
_socket.Tick();
var packet = new ReceivedSmartPacket();
while (true)
{
if (_socket.Receive(ref packet))
{
OnReceive(packet.Buffer, packet.Offset, packet.Length, packet.EndPoint, packet.InOrder);
_bufferPool.Put(packet.Buffer);
}
else
{
break;
}
}
Thread.Sleep(100);
}
}
public void ReSendAfterTimeout()
{
_sock.AckTimeout = 1;
var endPoint = new IPEndPoint(IPAddress.Loopback, 23452);
Utils.SendConnectRequest(_bareSock, endPoint, _bufferPool);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsFalse(_sock.Receive(ref receivedPacket));
var ms = new MemoryStream();
ms.Write(BitConverter.GetBytes(123456789), 0, 4);
var buffer = ms.ToArray();
_sock.Send(endPoint, buffer, 0, buffer.Length, true);
Thread.Sleep(20);
_sock.Tick();
Assert.AreEqual(3, _bareSock.Sends.Count);
var packetToSend = _bareSock.LastSend;
var header = new PacketHeader();
header.Init(packetToSend.Buffer, packetToSend.Offset);
Assert.AreEqual(buffer.Length + header.HeaderLength, header.Length);
Assert.AreEqual(123456789, BitConverter.ToInt32(packetToSend.Buffer, header.HeaderLength));
Assert.AreEqual(0, header.SeqNum);
Assert.IsTrue(header.GetNeedAck());
}
public void Tick()
{
_servSock.Tick();
var packet = new ReceivedSmartPacket();
while (true)
{
if (_servSock.Receive(ref packet))
{
OnReceive(packet.Buffer, packet.Offset, packet.Length, packet.EndPoint, packet.InOrder);
_bufferPool.Put(packet.Buffer);
}
else
{
break;
}
}
var ms = new MemoryStream();
ms.Write(BitConverter.GetBytes(_clients.Count), 0, 4);
foreach (var client in _clients)
{
ms.Write(BitConverter.GetBytes(client.Value), 0, 4);
}
var sendBuffer = ms.ToArray();
Broadcast(sendBuffer, 0, sendBuffer.Length);
}
static void Main(string[] args)
{
var callbacks = new PrintingReceiver();
var bufferPool = new ByteBufferPool();
var sock = new SmartSock(bufferPool, new BareSock(bufferPool, AddressFamily.InterNetwork, new LoggerStub()), callbacks);
var address = args[0];
callbacks.Connecting = true;
Connect(address, sock);
var packet = new ReceivedSmartPacket();
while (sock.State == PixocketState.Connecting)
{
if (sock.Receive(ref packet))
{
break;
}
sock.Tick();
}
for (int i = 1; i < 11; i++)
{
Thread.Sleep(1000);
var buffer = CreateMessage(i);
sock.Send(buffer, 0, buffer.Length, false);
sock.Tick();
while (true)
{
if (sock.Receive(ref packet))
{
callbacks.OnReceive(packet.Buffer, packet.Offset, packet.Length, packet.EndPoint, packet.InOrder);
}
else
{
break;
}
}
if (!callbacks.Connected && !callbacks.Connecting)
{
callbacks.Connecting = true;
Connect(address, sock);
continue;
}
}
sock.Disconnect();
while (sock.State == PixocketState.Connected)
{
sock.Tick();
sock.Receive(ref packet);
Thread.Sleep(100);
}
}
public void SendReliableFragmented()
{
_sock.MaxPayload = 3;
Utils.SendConnectRequest(_bareSock, _remoteEndPoint, _bufferPool);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsFalse(_sock.Receive(ref receivedPacket));
var ms = new MemoryStream();
ms.Write(BitConverter.GetBytes((ushort)12345), 0, 2);
ms.Write(new byte[] { 77 }, 0, 1);
ms.Write(BitConverter.GetBytes((ushort)23456), 0, 2);
var buffer = ms.ToArray();
_sock.Send(_remoteEndPoint, buffer, 0, buffer.Length, true);
Assert.AreEqual(3, _bareSock.Sends.Count); // 2 for payload + connect response
var packetToSend = _bareSock.Sends[1];
var header = new PacketHeader();
header.Init(packetToSend.Buffer, packetToSend.Offset);
Assert.AreEqual(_sock.MaxPayload + header.HeaderLength, header.Length);
Assert.AreEqual(12345, BitConverter.ToInt16(packetToSend.Buffer, header.HeaderLength));
Assert.AreEqual(0, header.SeqNum);
Assert.IsTrue(header.GetNeedAck());
Assert.IsFalse(packetToSend.PutBufferToPool, "Reliable packets should wait for Ack before going to pool");
packetToSend = _bareSock.Sends[2];
header = new PacketHeader();
header.Init(packetToSend.Buffer, packetToSend.Offset);
Assert.AreEqual(buffer.Length - _sock.MaxPayload + header.HeaderLength, header.Length);
Assert.AreEqual(23456, BitConverter.ToInt16(packetToSend.Buffer, header.HeaderLength));
Assert.AreEqual(1, header.SeqNum);
Assert.IsTrue(header.GetNeedAck());
Assert.IsFalse(packetToSend.PutBufferToPool, "Reliable packets should wait for Ack before going to pool");
// Ack buffers
var header1 = new PacketHeader();
header1.AddAck(0);
header1.AddAck(1);
header1.SetSeqNum(1);
header1.Length = (ushort)header1.HeaderLength;
var buffer1 = _bufferPool.Get(header1.Length);
header1.WriteTo(buffer1, 0);
_bareSock.FakeReceive(buffer1, 0, header1.Length, _remoteEndPoint);
var receivedPackets = Utils.ReceiveAll(_sock);
}
protected override void Read()
{
var packet = new ReceivedSmartPacket();
while (_servSock.Receive(ref packet))
{
OnReceive(packet.Buffer, packet.Offset, packet.Length, packet.EndPoint);
_bufferPool.Put(packet.Buffer);
}
_servSock.Tick();
}
private void AssertCombinedPacketReceived()
{
// Make sure full combined packet received
var receivedPacket = new ReceivedSmartPacket();
Assert.IsTrue(_sock.Receive(ref receivedPacket));
Assert.AreEqual(12345, BitConverter.ToUInt16(receivedPacket.Buffer, receivedPacket.Offset));
Assert.AreEqual(77, receivedPacket.Buffer[receivedPacket.Offset + 2]);
Assert.AreEqual(23456, BitConverter.ToUInt16(receivedPacket.Buffer, receivedPacket.Offset + 3));
Assert.AreEqual(5, receivedPacket.Length);
}
public static ReceivedSmartPacket WaitOnReceive(SmartSock sock)
{
for (int i = 0; i < 1000; ++i)
{
var receivedPacket = new ReceivedSmartPacket();
if (sock.Receive(ref receivedPacket))
{
return(receivedPacket);
}
Thread.Sleep(1);
}
return(new ReceivedSmartPacket());
}
public void SerialDuplicatesDetected()
{
SendPacket(1);
SendPacket(1);
var receivedPackets = Utils.ReceiveAll(_sock);
Assert.AreEqual(1, receivedPackets.Count);
SendPacket(1);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsFalse(_sock.Receive(ref receivedPacket));
}
protected override void Init()
{
var smartSock = new SmartSock(_bufferPool, new ThreadSock(_bufferPool, AddressFamily.InterNetwork, new LoggerStub()), _soc);
_socket = new ThreadSafeSmartSock(smartSock);
_socket.Connect(IPAddress.Loopback, 2345);
var receivedPacket = new ReceivedSmartPacket();
while (_socket.State == PixocketState.Connecting)
{
_socket.Tick();
_socket.Receive(ref receivedPacket);
}
}
public void ServerDidNotConnectWhenClientSessionIdIsNotEmpty()
{
var clientEndPoint = new IPEndPoint(IPAddress.Loopback, 54321);
ushort seqNum = 1;
FakeSendPacket(123, 123456789, clientEndPoint, ref seqNum);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsFalse(_sock.Receive(ref receivedPacket));
Assert.AreEqual(0, _cbs.OnConnectCalls.Count);
Assert.AreEqual(0, _cbs.OnDisconnectCalls.Count);
}
public void OutOfOrderArrival()
{
SendPacket(2);
SendPacket(1);
var receivedPacket1 = new ReceivedSmartPacket();
Assert.IsTrue(_sock.Receive(ref receivedPacket1));
Assert.IsTrue(receivedPacket1.InOrder);
var receivedPacket2 = new ReceivedSmartPacket();
Assert.IsTrue(_sock.Receive(ref receivedPacket2));
Assert.IsFalse(receivedPacket2.InOrder);
}
protected override void Read()
{
_socket.Tick();
var packet = new ReceivedSmartPacket();
while (_socket.Receive(ref packet))
{
try
{
ApplyState(packet.Buffer, packet.Offset, packet.Length);
_bufferPool.Put(packet.Buffer);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
public static List <ReceivedSmartPacket> ReceiveAll(SmartSock sock)
{
var result = new List <ReceivedSmartPacket>();
for (int i = 0; i < 1000; ++i)
{
var receivedPacket = new ReceivedSmartPacket();
if (sock.Receive(ref receivedPacket))
{
result.Add(receivedPacket);
}
else
{
break;
}
}
return(result);
}
public void SendFragmented()
{
var endPoint = new IPEndPoint(IPAddress.Loopback, 23452);
_sock.Connect(endPoint.Address, endPoint.Port);
Utils.SendConnectResponse(_bareSock, endPoint, _bufferPool);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsFalse(_sock.Receive(ref receivedPacket));
_sock.MaxPayload = 3;
var ms = new MemoryStream();
ms.Write(BitConverter.GetBytes((ushort)12345), 0, 2);
ms.Write(new byte[] { 77 }, 0, 1);
ms.Write(BitConverter.GetBytes((ushort)23456), 0, 2);
var buffer = ms.ToArray();
_sock.Send(endPoint, buffer, 0, buffer.Length, false);
Assert.AreEqual(3, _bareSock.Sends.Count);
var packetToSend = _bareSock.Sends[1];
var header = new PacketHeader();
header.Init(packetToSend.Buffer, packetToSend.Offset);
Assert.AreEqual(_sock.MaxPayload + header.HeaderLength, header.Length);
Assert.AreEqual(12345, BitConverter.ToInt16(packetToSend.Buffer, header.HeaderLength));
Assert.AreEqual(0, header.SeqNum);
Assert.IsFalse(header.GetNeedAck());
Assert.IsTrue(packetToSend.PutBufferToPool, "Unreliable packets should return to pool after send");
packetToSend = _bareSock.Sends[2];
header = new PacketHeader();
header.Init(packetToSend.Buffer, packetToSend.Offset);
Assert.AreEqual(buffer.Length - _sock.MaxPayload + header.HeaderLength, header.Length);
Assert.AreEqual(23456, BitConverter.ToInt16(packetToSend.Buffer, header.HeaderLength));
Assert.AreEqual(1, header.SeqNum);
Assert.IsFalse(header.GetNeedAck());
Assert.IsTrue(packetToSend.PutBufferToPool, "Unreliable packets should return to pool after send");
}
public void InterleavedDuplicatesDetected()
{
SendPacket(1);
SendPacket(2);
var receivedPackets = Utils.ReceiveAll(_sock);
Assert.AreEqual(2, receivedPackets.Count);
SendPacket(1);
var receivedPacket1 = new ReceivedSmartPacket();
Assert.IsFalse(_sock.Receive(ref receivedPacket1));
SendPacket(2);
var receivedPacket2 = new ReceivedSmartPacket();
Assert.IsFalse(_sock.Receive(ref receivedPacket2));
}
public void DisconnectedRequestSent()
{
var remoteEndPoint = new IPEndPoint(IPAddress.Loopback, 54321);
_sock.Connect(remoteEndPoint.Address, remoteEndPoint.Port);
Utils.SendConnectResponse(_bareSock, remoteEndPoint, _bufferPool);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsFalse(_sock.Receive(ref receivedPacket));
// Now we are connected
_sock.Disconnect(remoteEndPoint);
Utils.SendDisconnectResponse(_bareSock, remoteEndPoint, _bufferPool);
Assert.IsFalse(_sock.Receive(ref receivedPacket));
// Now we are disconnected
Assert.AreEqual(1, _cbs.OnConnectCalls.Count);
Assert.AreEqual(1, _cbs.OnDisconnectCalls.Count);
Assert.AreEqual(DisconnectReason.InitiatedByPeer, _cbs.OnDisconnectCalls[0].Item2);
}
public void AcksSentWithPayload()
{
var endPoint = new IPEndPoint(IPAddress.Loopback, 23452);
Utils.SendConnectRequest(_bareSock, endPoint, _bufferPool);
var buffer1 = FakeSentPacket(234);
_bareSock.FakeReceive(buffer1, 0, buffer1.Length, endPoint);
var buffer2 = FakeSentPacket(235);
_bareSock.FakeReceive(buffer2, 0, buffer2.Length, endPoint);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsTrue(_sock.Receive(ref receivedPacket));
Assert.IsTrue(_sock.Receive(ref receivedPacket));
// Ack not sent yet, just connect response
Assert.AreEqual(1, _bareSock.Sends.Count);
var payload = BitConverter.GetBytes(987654321);
_sock.Send(endPoint, payload, 0, payload.Length, true);
// Msg with acks sent
Assert.AreEqual(2, _bareSock.Sends.Count);
// Make sure ack sent
var ackHeader = new PacketHeader();
var packet = _bareSock.LastSend;
ackHeader.Init(packet.Buffer, packet.Offset);
Assert.GreaterOrEqual(packet.Buffer.Length, ackHeader.Length);
Assert.GreaterOrEqual(packet.Buffer.Length, ackHeader.HeaderLength);
Assert.Contains(234, ackHeader.Acks);
Assert.Contains(235, ackHeader.Acks);
Assert.IsTrue(ackHeader.GetNeedAck());
Assert.IsTrue((ackHeader.Flags & PacketHeader.ContainsAck) != 0);
}
public void Connect(float x, float y)
{
var smartSock = new SmartSock(_bufferPool, new ThreadSock(_bufferPool, AddressFamily.InterNetwork, new LoggerStub()), this);
_socket = new ThreadSafeSmartSock(smartSock);
// Todo: pass address from command line
_socket.Connect(IPAddress.Loopback, 2345);
var receivedPacket = new ReceivedSmartPacket();
while (_socket.State == PixocketState.Connecting)
{
_socket.Tick();
_socket.Receive(ref receivedPacket);
}
var ms = new MemoryStream();
ms.WriteByte(0); // Init request packet
byte red = (byte)_rnd.Next(0, byte.MaxValue + 1);
byte green = (byte)_rnd.Next(0, byte.MaxValue + 1);
byte blue = (byte)_rnd.Next(0, byte.MaxValue + 1);
Brush brush = new SolidColorBrush(Color.FromArgb(255, red, green, blue));
ms.WriteByte(red);
ms.WriteByte(green);
ms.WriteByte(blue);
ms.Write(BitConverter.GetBytes(x), 0, 4);
ms.Write(BitConverter.GetBytes(y), 0, 4);
var sendBuffer = ms.ToArray();
_myV = new Vertex();
_myV.X = x;
_myV.Y = y;
_myV.C = brush;
_socket.Send(sendBuffer, 0, sendBuffer.Length, true);
}
public void ReceiveReliable()
{
var endPoint = new IPEndPoint(IPAddress.Loopback, 23452);
Utils.SendConnectRequest(_bareSock, endPoint, _bufferPool);
var buffer1 = FakeSentPacket(123);
_bareSock.FakeReceive(buffer1, 0, buffer1.Length, endPoint);
var buffer2 = FakeSentPacket(124);
_bareSock.FakeReceive(buffer2, 0, buffer2.Length, endPoint);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsTrue(_sock.Receive(ref receivedPacket));
Assert.IsTrue(_sock.Receive(ref receivedPacket));
// Ack not sent yet, just connect response
Assert.AreEqual(1, _bareSock.Sends.Count);
_sock.Tick();
// Ack sent
Assert.AreEqual(2, _bareSock.Sends.Count);
// Make sure ack sent
var ackHeader = new PacketHeader();
var packet = _bareSock.LastSend;
ackHeader.Init(packet.Buffer, packet.Offset);
Assert.GreaterOrEqual(packet.Buffer.Length, ackHeader.Length);
Assert.GreaterOrEqual(packet.Buffer.Length, ackHeader.HeaderLength);
Assert.Contains(123, ackHeader.Acks);
Assert.Contains(124, ackHeader.Acks);
Assert.IsFalse(ackHeader.GetNeedAck());
Assert.IsTrue((ackHeader.Flags & PacketHeader.ContainsAck) != 0);
Assert.IsFalse((ackHeader.Flags & PacketHeader.ContainsSeq) != 0, "No need to write SeqNum in pure Acknowledgement packet");
Assert.IsTrue(ackHeader.SessionId != PacketHeader.EmptySessionId, "Acks should already have Non-Empty SessionId");
}
