public void ServerToClientTooLargeReliableMessage() { server.Start(Port); ConnectClientBlocking(); int connectionId = ServerFirstConnectionId(); byte[] message = new byte[KcpConnection.ReliableMaxMessageSize(ReceiveWindowSize) + 1]; #if UNITY_2018_3_OR_NEWER UnityEngine.TestTools.LogAssert.Expect(UnityEngine.LogType.Error, $"Failed to send reliable message of size {message.Length} because it's larger than ReliableMaxMessageSize={KcpConnection.ReliableMaxMessageSize(ReceiveWindowSize)}"); #endif SendServerToClientBlocking(connectionId, new ArraySegment <byte>(message), KcpChannel.Reliable); Assert.That(clientReceived.Count, Is.EqualTo(0)); }
public void ClientToServerReliableMaxSizedMessage() { server.Start(Port); ConnectClientBlocking(); byte[] message = new byte[KcpConnection.ReliableMaxMessageSize(ReceiveWindowSize)]; for (int i = 0; i < message.Length; ++i) { message[i] = (byte)(i & 0xFF); } Log.Info($"Sending {message.Length} bytes = {message.Length / 1024} KB message"); SendClientToServerBlocking(new ArraySegment <byte>(message), KcpChannel.Reliable); Assert.That(serverReceived.Count, Is.EqualTo(1)); Assert.That(serverReceived[0].data.SequenceEqual(message), Is.True); Assert.That(serverReceived[0].channel, Is.EqualTo(KcpChannel.Reliable)); }
public void ServerToClientReliableMaxSizedMessage() { server.Start(Port); ConnectClientBlocking(); int connectionId = ServerFirstConnectionId(); byte[] message = new byte[KcpConnection.ReliableMaxMessageSize(ReceiveWindowSize)]; for (int i = 0; i < message.Length; ++i) { message[i] = (byte)(i & 0xFF); } SendServerToClientBlocking(connectionId, new ArraySegment <byte>(message), KcpChannel.Reliable); Assert.That(clientReceived.Count, Is.EqualTo(1)); Assert.That(clientReceived[0].data.SequenceEqual(message), Is.True); Assert.That(clientReceived[0].channel, Is.EqualTo(KcpChannel.Reliable)); }
public IEnumerator Setup() => UniTask.ToCoroutine(async() => { // each test goes in a different port // that way the transports can take some time to cleanup // without interfering with each other. port++; var transportGo = new GameObject("kcpTransport", typeof(KcpTransport)); transport = transportGo.GetComponent <KcpTransport>(); transport.Port = port; // speed this up transport.HashCashBits = 3; transport.Connected.AddListener(connection => serverConnection = (KcpConnection)connection); listenTask = transport.ListenAsync(); var uriBuilder = new UriBuilder { Host = "localhost", Scheme = "kcp", Port = port }; testUri = uriBuilder.Uri; clientConnection = (KcpConnection)await transport.ConnectAsync(uriBuilder.Uri); await UniTask.WaitUntil(() => serverConnection != null); // for our tests, lower the timeout to just 0.1s // so that the tests run quickly. serverConnection.Timeout = 500; clientConnection.Timeout = 500; data = new byte[Random.Range(10, 255)]; for (int i = 0; i < data.Length; i++) { data[i] = (byte)Random.Range(1, 255); } });
public void ClientToServerMultipleReliableMaxSizedMessagesAtOnce() { server.Start(Port); ConnectClientBlocking(); // prepare 10 different MTU sized messages. // each of them with unique content so we can guarantee arrival. List <byte[]> messages = new List <byte[]>(); for (int i = 0; i < 10; ++i) { // create message, fill with unique data (j+i & 0xff) byte[] message = new byte[KcpConnection.ReliableMaxMessageSize(ReceiveWindowSize)]; for (int j = 0; j < message.Length; ++j) { message[j] = (byte)((j + i) & 0xFF); } messages.Add(message); } // send each one without updating server or client yet foreach (byte[] message in messages) { client.Send(new ArraySegment <byte>(message), KcpChannel.Reliable); } // each max sized message needs a lot of updates for all the fragments. // for multiple we need to update a lot more than usual. for (int i = 0; i < 10; ++i) { UpdateSeveralTimes(); } // all received? Assert.That(serverReceived.Count, Is.EqualTo(messages.Count)); for (int i = 0; i < messages.Count; ++i) { Assert.That(serverReceived[i].data.SequenceEqual(messages[i]), Is.True); Assert.That(serverReceived[i].channel, Is.EqualTo(KcpChannel.Reliable)); } }