Пример #1
0
        public void LiteSocket_Udp_Sync()
        {
            // Test the synchronous UDP socket methods.

            var reflector = new NetReflector(port);
            var buffer    = new byte[256];
            var cb        = 0;

            try
            {
                using (var sock = LiteSocket.CreateUdp(8192, 8192))
                {
                    // Connect and send/receive 1024 packets.

                    Fill(buffer, 0);
                    sock.Connect(new NetworkBinding("dev.lilltek.com", port), buffer);

                    for (int i = 0; i < 1024; i++)
                    {
                        Fill(buffer, 0);
                        cb = sock.Receive(buffer, 0, 256);

                        Assert.AreEqual(256, cb);
                        for (int j = 0; j < 256; j++)
                        {
                            if (buffer[j] != (byte)i)
                            {
                                Assert.Fail("Bad data");
                            }
                        }

                        Fill(buffer, i + 1);
                        sock.Send(buffer, 0, 256);
                    }
                }
            }
            finally
            {
                reflector.Stop();
            }
        }
Пример #2
0
        public void LiteSocket_Udp_BasicIP()
        {
            // Send/receive [TestPacketCount] UDP packets from a local reflector using an IP address.

            var reflector = new NetReflector(port);
            var connected = false;
            var exception = (Exception)null;
            var sendState = new UdpSendState();
            var recvState = new UdpRecvState();

            try
            {
                using (var sock = LiteSocket.CreateUdp(8192, 8192))
                {
                    sendState.Sock = sock;
                    recvState.Sock = sock;

                    var sendBuf = new byte[256];

                    Fill(sendBuf, 0);

                    sock.BeginConnect(new NetworkBinding(IPAddress.Loopback, port), sendBuf,
                                      ar =>
                    {
                        try
                        {
                            sock.EndConnect(ar);
                            connected = true;

                            sock.BeginReceive(recvState.Buffer, 0, recvState.Buffer.Length, new AsyncCallback(OnUdpBasicRecv), recvState);

                            sendBuf = new byte[256];

                            Fill(sendBuf, 1);
                            sock.BeginSend(sendBuf, 0, sendBuf.Length, new AsyncCallback(OnUdpBasicSent), sendState);
                        }
                        catch (Exception e)
                        {
                            exception = e;
                        }
                    },
                                      null);

                    Helper.WaitFor(() => (connected && recvState.Count == TestPacketCount + 1) || exception != null || sendState.Exception != null || recvState.Exception != null, waitTime);

                    if (exception != null)
                    {
                        throw exception;
                    }

                    if (sendState.Exception != null)
                    {
                        throw sendState.Exception;
                    }

                    if (recvState.Exception != null)
                    {
                        throw recvState.Exception;
                    }

                    Assert.AreEqual(TestPacketCount + 1, recvState.Count);

                    for (int i = 0; i < recvState.Packets.Count; i++)
                    {
                        var p = new byte[256];

                        Fill(p, i);
                        CollectionAssert.AreEqual(p, recvState.Packets[i]);
                    }
                }
            }
            finally
            {
                reflector.Stop();
            }
        }