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 override void OnUpdate()
{
var packet = new TestPacket();
packet.intVal = 1;
packet.strVal = "Hello, World";
svc.Send(_connSessionId, packet);
}
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);
}
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();
}
}
