public async Task connect_throw_timeout() { Queue <TestPacket> packets = new(); packets.Enqueue(TestPacket.Outgoing("101600044d5154540402001e000a434b4d71747454657374")); PacketReplayer packetReplayer = new(packets); IMqtt3Client client = MqttClient.Factory.CreateMQTT3Client(TestConfigs.DefaultTestConfig(packetReplayer), (IActivityMonitor m, DisposableApplicationMessage msg) => { msg.Dispose(); return(new ValueTask()); }); Task <ConnectResult> connectTask = client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials("CKMqttTest", true)); connectTask.IsCompleted.Should().BeFalse(); await packetReplayer.LastWorkTask !; packetReplayer.TestDelayHandler.IncrementTime(TimeSpan.FromMilliseconds(4999)); await Task.WhenAny(connectTask, Task.Delay(50)); connectTask.IsCompleted.Should().BeFalse(); packetReplayer.TestDelayHandler.IncrementTime(TimeSpan.FromMilliseconds(2)); (await connectTask).ConnectError.Should().Be(ConnectError.Timeout); packetReplayer.LastWorkTask !.IsCompletedSuccessfully.Should().BeTrue(); }
public void SynchronousData() { // Create the endpoints NodeEndpointInProc.EndpointPair endpoints = NodeEndpointInProc.CreateInProcEndpoints( NodeEndpointInProc.EndpointMode.Synchronous, _host); // Connect the endpoints endpoints.ManagerEndpoint.Listen(_host); endpoints.NodeEndpoint.Connect(_host); // Create our test packets INodePacket managerPacket = new TestPacket(); INodePacket nodePacket = new TestPacket(); // Send data from the manager. We expect to receive it from the node endpoint, and it should // be on the same thread. endpoints.ManagerEndpoint.SendData(managerPacket); Assert.Equal(_host.DataReceivedContext.packet, managerPacket); Assert.Equal(_host.DataReceivedContext.thread.ManagedThreadId, Thread.CurrentThread.ManagedThreadId); // Send data from the node. We expect to receive it from the manager endpoint, and it should // be on the same thread. endpoints.NodeEndpoint.SendData(nodePacket); Assert.Equal(_host.DataReceivedContext.packet, nodePacket); Assert.Equal(_host.DataReceivedContext.thread.ManagedThreadId, Thread.CurrentThread.ManagedThreadId); }
public void AsynchronousData() { // Create the endpoints NodeEndpointInProc.EndpointPair endpoints = NodeEndpointInProc.CreateInProcEndpoints( NodeEndpointInProc.EndpointMode.Asynchronous, _host); // Connect the endpoints endpoints.ManagerEndpoint.Listen(_host); endpoints.NodeEndpoint.Connect(_host); // Create our test packets INodePacket managerPacket = new TestPacket(); INodePacket nodePacket = new TestPacket(); // Send data from the manager. We expect to receive it from the node endpoint, and it should // be on the same thread. endpoints.ManagerEndpoint.SendData(managerPacket); if (!_host.DataReceivedEvent.WaitOne(1000, false)) { Assert.Fail("Data not received before timeout expired."); } Assert.IsTrue(_host.DataReceivedContext.packet == managerPacket); Assert.IsTrue(_host.DataReceivedContext.thread.ManagedThreadId != Thread.CurrentThread.ManagedThreadId); // Send data from the node. We expect to receive it from the manager endpoint, and it should // be on the same thread. endpoints.NodeEndpoint.SendData(nodePacket); if (!_host.DataReceivedEvent.WaitOne(1000, false)) { Assert.Fail("Data not received before timeout expired."); } Assert.IsTrue(_host.DataReceivedContext.packet == nodePacket); Assert.IsTrue(_host.DataReceivedContext.thread.ManagedThreadId != Thread.CurrentThread.ManagedThreadId); }
void sssstest() { Debug.Log("调用了"); SolaEngine engine = SolaEngine.getInstance(); TestPacket packet = new TestPacket(); // packet.testInt = 123; // packet.testString = "客户端发送到服务端"; // packet.testIntList = new int[3]; // packet.testIntList [0] = 10; // packet.testIntList [1] = 20; // packet.testIntList [2] = 310; // // packet.testStringList = new string[3]; // packet.testStringList [0] = "ddd"; // packet.testStringList [1] = "20"; // packet.testStringList [2] = "310"; // // packet.testBool = true; // packet.end = new TestPacket_end (); engine.send(OpCode.TEST_OPCODE, packet); }
public async Task connect_with_clean_session_but_connack_session_present_is_not_zero_should_fail() { Queue <TestPacket> packets = new(); TestPacket connectPacket = TestPacket.Outgoing("101600044d5154540402001e000a434b4d71747454657374"); for (byte i = 1; i != 0; i++) //Ok there we loop over all non zero bytes. { packets.Enqueue(connectPacket); packets.Enqueue(TestPacket.Incoming("2002" + BitConverter.ToString(new byte[] { i }) + "00")); } PacketReplayer pcktReplayer = new(packets); IMqtt3Client client = MqttClient.Factory.CreateMQTT3Client(TestConfigs.DefaultTestConfig(pcktReplayer), (IActivityMonitor m, DisposableApplicationMessage msg) => { msg.Dispose(); return(new ValueTask()); }); ConnectResult res = await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true )); res.ConnectError.Should().Be(ConnectError.ProtocolError_SessionNotFlushed); for (byte i = 2; i != 0; i++) { res = await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true )); res.ConnectError.Should().Be(ConnectError.ProtocolError_InvalidConnackState); } pcktReplayer.LastWorkTask !.IsCompletedSuccessfully.Should().BeTrue(); }
public async Task connect_with_clean_session_but_connack_return_code_is_invalid_should_throw() { Queue <TestPacket> packets = new(); TestPacket connectPacket = TestPacket.Outgoing("101600044d5154540402001e000a434b4d71747454657374"); const int startSkipCount = 6; // These packets are valid, so we skip them. for (byte i = startSkipCount; i != 0; i++) //Ok there we loop over all non zero bytes. { packets.Enqueue(connectPacket); packets.Enqueue(TestPacket.Incoming("200200" + BitConverter.ToString(new byte[] { i }))); } PacketReplayer packetReplayer = new(packets); IMqtt3Client client = MqttClient.Factory.CreateMQTT3Client(TestConfigs.DefaultTestConfig(packetReplayer), (IActivityMonitor m, DisposableApplicationMessage msg) => { msg.Dispose(); return(new ValueTask()); }); for (byte i = startSkipCount; i != 0; i++) { ConnectResult res = await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true )); res.ConnectError.Should().Be(ConnectError.ProtocolError_UnknownReturnCode); } packetReplayer.LastWorkTask !.IsCompletedSuccessfully.Should().BeTrue(); }
public virtual void Client_SendToServer_DataSentEventInvoked() { var client = Clients.First(); var ctx = CreateContext(); Server.StartServer(ctx); client.Connect(ctx); Wait(() => { Server.UpdateServer(); client.UpdateClient(); return(client.IsConnected); }, 250); string data = Guid.NewGuid().ToString(); TestPacket packet = CreateTestPacket(data); DataBuffer buffer = new DataBuffer(); packet.WriteTo(buffer); bool received = false; client.DataSent += (s, e) => { received = true; Assert.IsTrue(e.ByteCount > 0); }; client.SendMessage(buffer); Assert.IsTrue(received); }
public async Task connect_while_being_connected_should_throw_friendly_exception() { Queue <TestPacket> packets = new(); packets.Enqueue(TestPacket.Outgoing("101600044d5154540402001e000a434b4d71747454657374")); packets.Enqueue(TestPacket.Incoming("20020000")); PacketReplayer packetReplayer = new(packets); IMqtt3Client client = MqttClient.Factory.CreateMQTT3Client(TestConfigs.DefaultTestConfig(packetReplayer), (IActivityMonitor m, DisposableApplicationMessage msg) => { msg.Dispose(); return(new ValueTask()); }); await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true )); try { await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true )); Assert.Fail(); } catch (Exception e) { e.Should().BeOfType <InvalidOperationException>(); e.Message.Should().Be("This client is already connected."); } packetReplayer.LastWorkTask !.IsCompletedSuccessfully.Should().BeTrue(); }
public void DistributedService_RouterServer_SendToAllShards_ExcludingMany_PacketsReceived() { var routerShardSvc = Router.ShardController.Context.Services.Get <TestDistributedService>(); var routerUserSvc = Router.UserController.Context.Services.Get <TestDistributedService>(); var user = Users.First(); var shard = Shards.First(); var usvc = user.Context.Services.Get <TestDistributedService>(); var ssvc = shard.Context.Services.Get <TestDistributedService>(); var pck = new TestPacket(); int recv = 0; foreach (var sh in Shards) { sh.Context.Services.Get <TestDistributedService>().ShardChannel.Receive += (s, e) => { recv++; }; } Router.UpdateServer(); foreach (var sh in Shards) { sh.UpdateClient(); } foreach (var us in Users) { us.UpdateClient(); } usvc.ShardChannel.Send(pck, Shards.Select(i => i.Model).Skip(3)); Assert.AreEqual(recv, Shards.Count - 3); }
public override void handle(int opcode, SimpleJson.JsonObject json) { Debug.Log("TestHandler handle"); TestPacket s = new TestPacket(); s.antiSerialization(json); Debug.Log("success"); }
public override void OnUpdate() { var packet = new TestPacket(); packet.intVal = 1; packet.strVal = "Hello, World"; svc.Send(_connSessionId, packet); }
private void OnSocketData(Events.Event eventObj) { SocketEvent socketEvent = (SocketEvent)eventObj; TestPacket packet = (TestPacket)socketEvent.SocketPacket; Debug.Log(packet.Text); IntegrationTest.Pass(gameObject); }
public virtual void Server_SendToOneClient_ClientReceivesData() { var ctx = CreateContext(); Server.StartServer(ctx); foreach (var client in Clients) { client.Connect(ctx); } Wait(() => { Server.UpdateServer(); foreach (var client in Clients) { client.UpdateClient(); } return(Clients.All(c => c.IsConnected)); }, 250); string data = Guid.NewGuid().ToString(); TestPacket packet = CreateTestPacket(data); DataBuffer buffer = new DataBuffer(); packet.WriteTo(buffer); int received = 0; foreach (var cl in Clients) { cl.DataReceived += (s, a) => { var inc = a.Data; Assert.IsNotNull(inc); TestPacket result = new TestPacket(); result.ReadFrom(inc); Assert.AreEqual(result.Data, data); received++; } } ; Server.SendMessage(Server.GetClientKeys().First(), buffer); Wait(() => { Server.UpdateServer(); foreach (var client in Clients) { client.UpdateClient(); } return(received == 1); }, 250); Assert.AreEqual(received, 1); }
private static byte[] StructureToByteArray(TestPacket localTestPacket) { byte[] bb = new byte[Marshal.SizeOf(localTestPacket)]; GCHandle gch = GCHandle.Alloc(bb, GCHandleType.Pinned); Marshal.StructureToPtr(localTestPacket, gch.AddrOfPinnedObject(), false); gch.Free(); return(bb); }
public ISocketPacket[] Unpack(byte[] buffer, int bytesRead) { MemoryStream stream = new MemoryStream(); BinaryReader reader = new BinaryReader(stream); int data = reader.Read(); TestPacket packet = new TestPacket(data.ToString()); return(new ISocketPacket[] { packet }); }
private async Task ExecuteWrite(Transporter transporter, TestPacket testPacket) { while (!testPacket.WriteComplete) { await transporter.Write(testPacket, cancellationTokenSource.Token); await Task.Yield(); } }
public void Shard_SendToOneUser_UserReceivedMessage() { var shard = Shards.First(); var user = Users.First(); var pck = new TestPacket(); shard.Passthrough.Send(pck, user.User.Model); Assert.IsTrue(UsersReceived.Contains(user)); Assert.IsTrue(UsersReceived.Count == 1); }
public void User_SendToOneShard_ShardReceivedMessage() { var shard = Shards.First(); var user = Users.First(); var pck = new TestPacket(); user.Passthrough.Send(pck, shard.Shard.Model); Assert.IsTrue(ShardsReceived.Contains(shard)); Assert.IsTrue(ShardsReceived.Count == 1); }
public void User_SendToManyShards_ShardsReceivedMessages() { var user = Users.First(); var shardModels = Shards.Select(i => i.Shard.Model); var pck = new TestPacket(); user.Passthrough.Send(pck, shardModels); Assert.IsTrue(ShardsReceived.Count == Shards.Count); foreach (var shard in Shards) { Assert.IsTrue(ShardsReceived.Contains(shard)); } }
public void Shard_SendToManyUsers_UsersReceivedMessages() { var shard = Shards.First(); var userModels = Users.Select(i => i.User.Model); var pck = new TestPacket(); shard.Passthrough.Send(pck, userModels); Assert.IsTrue(UsersReceived.Count == Users.Count); foreach (var user in Users) { Assert.IsTrue(UsersReceived.Contains(user)); } }
public async Task simple_publish_qos0_works() { (PacketReplayer packetReplayer, IMqtt3Client client) = await Scenario.ConnectedClient(new List <TestPacket>() { TestPacket.Outgoing("3018000a7465737420746f70696374657374207061796c6f6164") }); await await client.PublishAsync(TestHelper.Monitor, new ApplicationMessage( "test topic", Encoding.UTF8.GetBytes("test payload"), QualityOfService.AtMostOnce, false ) ); packetReplayer.LastWorkTask !.IsCompletedSuccessfully.Should().BeTrue(); }
private void _onBtnClicked(GameObject gameObject) { _clickCount++; string roleId = roleIdEdit.text.Trim(); SolaEngine engine = SolaEngine.getInstance(); if (false) { TestPacket tp2 = new TestPacket(); tp2.aa = _clickCount; tp2.bb = roleId; TestInfoPacket tp3 = new TestInfoPacket(); tp3.cc = _clickCount + 1; tp3.dd = roleId + "dd"; tp2.cc = tp3; string[] ss = new string[2]; ss [0] = "asdasd"; ss [1] = "1111111asdasd"; tp3.ddd = ss; TestInfoPacket[] tp4 = new TestInfoPacket[2]; TestInfoPacket ssss = new TestInfoPacket(); ssss.dd = "ssss"; tp4 [0] = ssss; tp2.ee = tp4; TestInfoPacket sssss = new TestInfoPacket(); sssss.ddd = ss; tp4 [1] = sssss; engine.send(OpCode.TEST_OPCODE, tp2.toData()); return; } if (roleId == "") { Debug.Log("请输入账号"); return; } _roleMgr.sign(roleId); string sceneName = ScenesName.MAIN; engine.enterScene(sceneName); Application.LoadLevel(sceneName); }
public void DistributedService_UserClient_SendToShard_ReceivesPacket() { var userSvc = Users.First().Context.Services.Get <TestDistributedService>(); var shardSvc = Shards.First().Context.Services.Get <TestDistributedService>(); var pck = new TestPacket(); bool recv = false; shardSvc.ShardChannel.Receive += (s, e) => { recv = true; }; userSvc.ShardChannel.Send(pck, Shards.First().Model); Assert.IsTrue(recv); }
public void DistributedService_ShardClient_SendToShard_PacketReceived() { var shardSvc1 = Shards.First().Context.Services.Get <TestDistributedService>(); var shardSvc2 = Shards.Skip(1).First().Context.Services.Get <TestDistributedService>(); var pck = new TestPacket(); bool recv = false; shardSvc2.ShardChannel.Receive += (s, e) => { recv = true; }; shardSvc1.ShardChannel.Send(pck, Shards.Skip(1).First().Model); Assert.IsTrue(recv); }
private void RequestSamplePacket(string name, string base64text) { try { var url = "http://14.32.173.60:17761"; var packet = new TestPacket() { __pbDat = base64text, __pbName = name }; var packetJson = Newtonsoft.Json.JsonConvert.SerializeObject(packet); } catch { } }
public virtual void Server_SendToClient_ClientReceivesData() { var client = Clients.First(); var ctx = CreateContext(); Server.StartServer(ctx); client.Connect(ctx); Wait(() => { Server.UpdateServer(); client.UpdateClient(); return(client.IsConnected); }, 250); string data = Guid.NewGuid().ToString(); TestPacket packet = CreateTestPacket(data); DataBuffer buffer = new DataBuffer(); packet.WriteTo(buffer); DataBuffer inc = null; client.DataReceived += (s, a) => { inc = a.Data; }; foreach (var key in Server.GetClientKeys()) { Server.SendMessage(key, buffer); } Wait(() => { Server.UpdateServer(); client.UpdateClient(); return(inc != null); }, 250); Assert.IsNotNull(inc); TestPacket result = new TestPacket(); result.ReadFrom(inc); Assert.AreEqual(result.Data, data); }
public async Task simple_connection_works() { PacketReplayer pcktReplayer = new(new Queue <TestPacket>(new List <TestPacket>() { TestPacket.Outgoing("101600044d5154540402001e000a434b4d71747454657374"), TestPacket.Incoming("20020000") })); IMqtt3Client client = MqttClient.Factory.CreateMQTT3Client(TestConfigs.DefaultTestConfig(pcktReplayer), (IActivityMonitor m, DisposableApplicationMessage msg) => { msg.Dispose(); return(new ValueTask()); }); await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true )); pcktReplayer.LastWorkTask !.IsCompletedSuccessfully.Should().BeTrue(); }
public void DistributedService_UserClient_SendToAllShards_ExcludingMany_ReceivesPackets() { var userSvc = Users.First().Context.Services.Get <TestDistributedService>(); var pck = new TestPacket(); int recv = 0; foreach (var sh in Shards) { sh.Context.Services.Get <TestDistributedService>().ShardChannel.Receive += (s, e) => { recv += 1; } } ; userSvc.ShardChannel.Send(pck, Shards.Select(i => i.Model).Skip(3)); Assert.AreEqual(Shards.Count - 3, recv); }
public async Task simple_publish_qos2_works() { (PacketReplayer packetReplayer, IMqtt3Client client) = await Scenario.ConnectedClient(new List <TestPacket>() { TestPacket.Outgoing("341a000a7465737420746f706963000174657374207061796c6f6164"), TestPacket.Incoming("50020001"), TestPacket.Outgoing("62020001"), TestPacket.Incoming("70020001") }); await await client.PublishAsync(TestHelper.Monitor, new ApplicationMessage( "test topic", Encoding.UTF8.GetBytes("test payload"), QualityOfService.ExactlyOnce, false ) ); await Task.WhenAny(Task.Delay(500), packetReplayer.LastWorkTask); packetReplayer.LastWorkTask !.IsCompletedSuccessfully.Should().BeTrue(); }
public void DistributedService_ShardClient_SendToAllShards_ExcludingOne_PacketsReceived() { var shardSvc1 = Shards.First().Context.Services.Get <TestDistributedService>(); var shardSvc2 = Shards.Skip(1).First().Context.Services.Get <TestDistributedService>(); var pck = new TestPacket(); int recv = 0; foreach (var sh in Shards) { sh.Context.Services.Get <TestDistributedService>().ShardChannel.Receive += (s, e) => { recv += 1; } } ; shardSvc1.ShardChannel.Send(pck, Shards.Select(i => i.Model).Skip(1)); Assert.AreEqual(Shards.Count - 1, recv); }
private void _SendRecvTest() { Console.WriteLine("Send/Recv test:"); using (Service svc = new Service("SendRecvTest")) { svc.Start(); IPEndPoint ep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 7788); int listenSessionId = svc.Listen(ep); Console.WriteLine("Listened on [{0}], sessionId: {1}", ep, listenSessionId); int connSessionId = svc.Connect(ep); Console.WriteLine("Connected to {0}, sessionId: {1}", ep, connSessionId); // Test Send TestPacket data = new TestPacket(); data.intVal = 10086; data.strVal = "Hello World"; svc.Send(connSessionId, data); // Test Multicast TestMulticastPacket multicastData = new TestMulticastPacket(); multicastData.intVal = 10010; multicastData.strVal = "Multicast data"; List<int> multicastSessionIds = new List<int>(); multicastSessionIds.Add(connSessionId); svc.Multicast(multicastSessionIds, multicastData); // Test Broadcast TestBroadcastPacket broadcastData = new TestBroadcastPacket(); broadcastData.intVal = 8888; broadcastData.strVal = "Broadcast data"; svc.Broadcast(broadcastData); // Test unhandled packet svc.Send(connSessionId, new UnHandledPacket()); // Test coder not found MemoryStream unhandledStream = new MemoryStream(); unhandledStream.Write(new byte[30], 0, 30); svc.Send(connSessionId, 10086, unhandledStream); Console.WriteLine("Press any key to exit Send/Recv test..."); Console.ReadKey(); } }
public void SynchronousData() { // Create the endpoints NodeEndpointInProc.EndpointPair endpoints = NodeEndpointInProc.CreateInProcEndpoints( NodeEndpointInProc.EndpointMode.Synchronous, _host); // Connect the endpoints endpoints.ManagerEndpoint.Listen(_host); endpoints.NodeEndpoint.Connect(_host); // Create our test packets INodePacket managerPacket = new TestPacket(); INodePacket nodePacket = new TestPacket(); // Send data from the manager. We expect to receive it from the node endpoint, and it should // be on the same thread. endpoints.ManagerEndpoint.SendData(managerPacket); Assert.IsTrue(_host.DataReceivedContext.packet == managerPacket); Assert.IsTrue(_host.DataReceivedContext.thread.ManagedThreadId == Thread.CurrentThread.ManagedThreadId); // Send data from the node. We expect to receive it from the manager endpoint, and it should // be on the same thread. endpoints.NodeEndpoint.SendData(nodePacket); Assert.IsTrue(_host.DataReceivedContext.packet == nodePacket); Assert.IsTrue(_host.DataReceivedContext.thread.ManagedThreadId == Thread.CurrentThread.ManagedThreadId); }
public void OnTestPacket(Session session, TestPacket packet) { }
private void _PreHandleTest() { Console.WriteLine("PreHandle test:"); using (Service svc = new Service("PreHandleTest")) { svc.Start(); IPEndPoint ep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 7788); Console.WriteLine("Listened on {0}", ep); int connSessionId = svc.Connect(ep); Console.WriteLine("Connected to {0}, sessionId: {1}", ep, connSessionId); TestPacket data = new TestPacket(); data.intVal = 10086; data.strVal = "Hello World"; svc.Send(connSessionId, data); Console.WriteLine("Press any key to exit PreHandle test..."); Console.ReadKey(); } }