Beispiel #1
0
        public async Task Secure()
        {
            var state = 0;
            var block = new AutoResetEvent(false);

            var raw         = File.ReadAllBytes("localhost.pfx");
            var certificate = new X509Certificate2(raw, "test");

            using (var server = new FeatherTcpServer <BinaryMessage>()) {
                server.OnMessageReceived += (endPoint, message) => {
                    if (state == 0)
                    {
                        Assert.Equal(TestPayload1, message.Export().ToArray());
                        state++;
                    }
                    else if (state == 1)
                    {
                        Assert.Equal(TestPayload2, message.Export().ToArray());
                        state++;
                        block.Set();
                    }
                    else
                    {
                        throw new Exception();
                    }
                };
                server.ListenSecure(13008, certificate);

                using (var client = new FeatherTcpClient <BinaryMessage>()) {
                    await client.ConnectSecureAsync("localhost", 13008, "localhost", (object sender, X509Certificate cert, X509Chain chain, SslPolicyErrors sslPolicyErrors) => {
                        return(true); // Ignore that it's a self-signed cert
                    });

                    await client.SendAsync(TestMessage1);

                    await client.SendAsync(TestMessage2);

                    block.WaitOne(1000);
                }
            }

            Assert.Equal(2, state);
        }
Beispiel #2
0
        public async void SendAsync()
        {
            using (var socket = new Socket(SocketType.Stream, ProtocolType.Tcp)) {
                socket.NoDelay = true;
                socket.Bind(new IPEndPoint(IPAddress.Loopback, 12001));
                socket.Listen(1);

                using (var client = new FeatherTcpClient <BinaryMessage>()) {
                    client.Connect("127.0.0.1", 12001);

                    var socketa = socket.Accept();
                    await client.SendAsync(TestMessage1);

                    await client.SendAsync(TestMessage2);

                    Thread.Sleep(10);

                    var buffer = new byte[TestWire1.Length];
                    var pos    = 0;
                    while (pos < buffer.Length)
                    {
                        var len = socketa.Receive(buffer, pos, TestWire1.Length - pos, SocketFlags.None);
                        pos += len;
                    }
                    Assert.Equal(TestWire1, buffer);

                    buffer = new byte[TestWire2.Length];
                    pos    = 0;
                    while (pos < buffer.Length)
                    {
                        var len = socketa.Receive(buffer, pos, TestWire2.Length - pos, SocketFlags.None);
                        pos += len;
                    }
                    Assert.Equal(TestWire2, buffer);
                }
            }
        }
Beispiel #3
0
        public async Task Dispose()
        {
            using (var socket = new Socket(SocketType.Stream, ProtocolType.Tcp)) {
                socket.NoDelay = true;
                socket.Bind(new IPEndPoint(IPAddress.Loopback, 12006));
                socket.Listen(1);

                var client = new FeatherTcpClient <BinaryMessage>();
                client.Connect("127.0.0.1", 12006);
                Assert.False(client.IsDisposed);
                client.Dispose();
                Assert.True(client.IsDisposed);

                Assert.Throws <ObjectDisposedException>(() => {
                    client.Send(TestMessage1);
                });

                await Assert.ThrowsAsync <ObjectDisposedException>(async() => {
                    await client.SendAsync(TestMessage1);
                });
            }
        }