コード例 #1
0
        public void TestExceptionDisconnect()
        {
            lock (syncRoot)
            {
                var app        = MakeEnv();
                var manager    = app.Make <INetworkManager>();
                var fromClient = new byte[] { };
                using (var server = new TcpServer((data) =>
                {
                    fromClient = Arr.Merge(fromClient, data);
                }))
                {
                    var       channel = manager.Make("frame.tcp://127.0.0.1:7777");
                    Exception err     = null;
                    manager.OnClosed += (c, e) =>
                    {
                        err = e;
                    };

                    try
                    {
                        var wait  = channel.Connect();
                        var count = 0;
                        while (!wait.IsDone && count++ < 3000)
                        {
                            Thread.Sleep(1);
                        }
                        channel.Disconnect(new RuntimeException("test exception"));

                        Assert.AreEqual("CatLib.RuntimeException: test exception", err.ToString());
                    }
                    finally
                    {
                        channel.Disconnect();
                    }
                }
            }
        }
コード例 #2
0
        public void TestRelease()
        {
            lock (syncRoot)
            {
                var app        = MakeEnv();
                var manager    = app.Make <INetworkManager>();
                var fromClient = new byte[] { };
                using (var server = new TcpServer((data) =>
                {
                    fromClient = Arr.Merge(fromClient, data);
                }))
                {
                    var channel = manager.Make("frame.tcp://127.0.0.1:7777", "test");
                    channel.Connect();

                    var disconnect = false;
                    channel.OnDisconnect += (c) =>
                    {
                        disconnect = true;
                    };

                    var closed = false;
                    channel.OnClosed += (c, e) =>
                    {
                        closed = true;
                    };

                    manager.Release("test");

                    Assert.AreEqual(false, channel.Socket.Connected);
                    Assert.AreEqual(true, disconnect);
                    Assert.AreEqual(true, closed);

                    var socket = app.Make <ISocketManager>().Make("tcp://127.0.0.1:7777", "test");
                    Assert.AreNotEqual(socket, channel.Socket);
                }
            }
        }
コード例 #3
0
        public void TestChannelPackerErrorEncode()
        {
            var fromClient = new byte[] { };

            using (var server = new TcpServer((data) =>
            {
                fromClient = Arr.Merge(fromClient, data);
            }))
            {
                var socket  = MakeEnv().Make <ISocketManager>().Make("tcp://127.0.0.1", "TestChannelPackerErrorEncode");
                var channel = new NetworkChannel(socket, new PackerError(PackerError.ErrorType.Encode), "TestChannelPackerErrorEncode");

                var wait  = channel.Connect("127.0.0.1", 7777);
                var count = 0;
                while (!wait.IsDone && count++ < 3000)
                {
                    Thread.Sleep(1);
                }
                try
                {
                    var isThrow = false;
                    try
                    {
                        channel.Send(Encoding.Default.GetBytes("helloworld"));
                    }
                    catch (RuntimeException)
                    {
                        isThrow = true;
                    }
                    Assert.AreEqual(true, isThrow);
                }
                finally
                {
                    channel.Disconnect();
                }
            }
        }
コード例 #4
0
        public void TestAllEventRegister()
        {
            lock (syncRoot)
            {
                var app        = MakeEnv();
                var manager    = app.Make <INetworkManager>();
                var fromClient = new byte[] { };
                using (var server = new TcpServer((data) =>
                {
                    fromClient = Arr.Merge(fromClient, data);
                }))
                {
                    var channel = manager.Make("frame.tcp://127.0.0.1:7777");

                    Exception err = null;
                    manager.OnError += (c, e) =>
                    {
                        err = e;
                    };

                    Exception closeErr = new Exception();
                    manager.OnClosed += (c, e) =>
                    {
                        closeErr = e;
                    };

                    INetworkChannel connected = null;
                    manager.OnConnected += (c) =>
                    {
                        connected = c;
                    };

                    INetworkChannel disconnected = null;
                    manager.OnDisconnect += (c) =>
                    {
                        disconnected = c;
                    };

                    INetworkChannel sent = null;
                    manager.OnSent += (c, b) =>
                    {
                        sent = c;
                    };

                    INetworkChannel released = null;
                    manager.OnReleased += (c) =>
                    {
                        released = c;
                    };

                    try
                    {
                        var wait  = channel.Connect();
                        var count = 0;
                        while (!wait.IsDone && count++ < 3000)
                        {
                            Thread.Sleep(1);
                        }

                        channel.Send(Encoding.Default.GetBytes("helloworld"));
                    }
                    finally
                    {
                        manager.Release();
                    }

                    Assert.AreEqual(null, err);
                    Assert.AreEqual(null, closeErr);
                    Assert.AreEqual(channel, connected);
                    Assert.AreEqual(channel, disconnected);
                    Assert.AreEqual(channel, sent);
                    Assert.AreEqual(channel, released);
                }
            }
        }
コード例 #5
0
        public void HeatBeatDisconnectTests()
        {
            lock (syncRoot)
            {
                var app        = MakeEnv();
                var manager    = app.Make <INetworkManager>();
                var fromClient = new byte[] { };
                using (var server = new TcpServer((data) =>
                {
                    fromClient = Arr.Merge(fromClient, data);
                }))
                {
                    var channel = manager.Make("frame.tcp://127.0.0.1:7777");
                    channel.SetHeartBeat(500);
                    channel.Connect();

                    var disconnect = false;
                    channel.OnDisconnect += (c) =>
                    {
                        disconnect = true;
                    };

                    var closed = false;
                    channel.OnClosed += (c, e) =>
                    {
                        closed = true;
                    };

                    try
                    {
                        var missCount = 0;
                        channel.OnMissHeartBeat += (c, num) =>
                        {
                            missCount++;
                            channel.Disconnect();
                        };

                        while (missCount < 1)
                        {
                            (manager as NetworkManager).Tick(1);
                            Thread.Sleep(1);
                        }

                        while (!disconnect)
                        {
                            (manager as NetworkManager).Tick(1);
                            Thread.Sleep(1);
                        }

                        while (!closed)
                        {
                            (manager as NetworkManager).Tick(1);
                            Thread.Sleep(1);
                        }

                        Assert.AreEqual(1, missCount);
                        Assert.AreEqual(true, disconnect);
                        Assert.AreEqual(true, closed);
                    }
                    finally
                    {
                        channel.Disconnect();
                    }
                }
            }
        }