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"); }