public void SendDataToRemoteEndPoint()
{
using (var host = new LocalDriverHelper(default(NetworkEndPoint)))
using (var stream = new DataStreamWriter(64, Allocator.Persistent))
{
host.Host();
var driver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
// Need to be connected in order to be able to send a disconnect packet.
NetworkConnection connectionId = driver.Connect(host.Address);
Assert.True(connectionId != default(NetworkConnection));
driver.ScheduleUpdate().Complete();
var local = driver.LocalEndPoint();
host.Assert_GotConnectionRequest(local, true);
NetworkConnection con;
DataStreamReader slice;
// Pump so we get the accept message back.
driver.ScheduleUpdate().Complete();
Assert.AreEqual(NetworkEvent.Type.Connect, driver.PopEvent(out con, out slice));
stream.Clear();
var data = Encoding.ASCII.GetBytes("data to send");
stream.Write(data);
driver.Send(NetworkPipeline.Null, connectionId, stream);
driver.ScheduleUpdate().Complete();
host.Assert_GotDataRequest(local, data);
driver.Dispose();
}
}
public LocalDriverHelper(NetworkEndPoint endpoint, params INetworkParameter[] networkParams)
{
if (networkParams.Length == 0)
{
m_LocalDriver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = NetworkParameterConstants.MTU
});
}
else
{
m_LocalDriver = new LocalNetworkDriver(networkParams);
}
m_LocalBitStream = new BitStream(NetworkParameterConstants.MTU, Allocator.Persistent);
if (endpoint.family == NetworkFamily.IPC && endpoint.port != 0)
{
Address = endpoint;
}
else
{
Address = IPCManager.Instance.CreateEndPoint(Utilities.Random.String(32));
}
Connection = default(NetworkConnection);
ClientConnections = new List <NetworkConnection>();
}
//private List<NetworkConnection> m_Connections;
public UnreliableServer()
{
m_Driver = new LocalNetworkDriver(new NetworkDataStreamParameter
{
size = NetworkParameterConstants.MTU
});
}
public void SendDataToRemoteEndPoint()
{
using (var host = new LocalDriverHelper(default(NetworkEndPoint)))
using (var stream = new BitStream(64, Allocator.Persistent))
{
host.Host();
var driver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
// Need to be connected in order to be able to send a disconnect packet.
NetworkConnection connectionId = driver.Connect(host.Address);
Assert.True(connectionId != default(NetworkConnection));
var local = driver.LocalEndPoint();
host.Assert_GotConnectionRequest(local, true);
// Pump so we get the accept message back.
driver.Update();
stream.Reset();
var data = Encoding.ASCII.GetBytes("data to send");
stream.Write(data);
driver.Send(connectionId, stream);
host.Assert_GotDataRequest(local, data);
driver.Dispose();
}
}
public void AcceptInJobWorks()
{
var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var clientDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
/*var clientToServer =*/ clientDriver.Connect(serverDriver.LocalEndPoint());
clientDriver.ScheduleUpdate().Complete();
var serverToClient = new NativeArray <NetworkConnection>(1, Allocator.TempJob);
var acceptJob = new AcceptJob {
driver = serverDriver, connections = serverToClient
};
Assert.IsFalse(serverToClient[0].IsCreated);
acceptJob.Schedule(serverDriver.ScheduleUpdate()).Complete();
Assert.IsTrue(serverToClient[0].IsCreated);
serverToClient.Dispose();
clientDriver.Dispose();
serverDriver.Dispose();
}
void AssertDataReceived(LocalNetworkDriver serverDriver, NativeArray <NetworkConnection> serverConnections, LocalNetworkDriver clientDriver, NetworkConnection clientToServerConnection, int assertValue, bool serverResend)
{
DataStreamReader strmReader;
clientDriver.ScheduleUpdate().Complete();
var evnt = clientToServerConnection.PopEvent(clientDriver, out strmReader);
int counter = 0;
while (evnt == NetworkEvent.Type.Empty)
{
serverDriver.ScheduleUpdate().Complete();
clientDriver.ScheduleUpdate().Complete();
evnt = clientToServerConnection.PopEvent(clientDriver, out strmReader);
if (counter++ > 1000)
{
if (!serverResend)
{
break;
}
counter = 0;
var strmWriter = new DataStreamWriter(4, Allocator.Temp);
strmWriter.Write(assertValue);
for (int i = 0; i < serverConnections.Length; ++i)
{
serverDriver.Send(NetworkPipeline.Null, serverConnections[i], strmWriter);
}
}
}
Assert.AreEqual(NetworkEvent.Type.Data, evnt);
var ctx = default(DataStreamReader.Context);
Assert.AreEqual(assertValue, strmReader.ReadInt(ref ctx));
}
public void SendInJobWorks()
{
var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var clientDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
var clientToServer = clientDriver.Connect(serverDriver.LocalEndPoint());
WaitForConnected(clientDriver, serverDriver, clientToServer);
var sendJob = new SendJob {
driver = clientDriver, connection = clientToServer
};
clientDriver.ScheduleUpdate(sendJob.Schedule()).Complete();
var serverToClient = serverDriver.Accept();
serverDriver.ScheduleUpdate().Complete();
DataStreamReader strmReader;
Assert.AreEqual(NetworkEvent.Type.Data, serverToClient.PopEvent(serverDriver, out strmReader));
var ctx = default(DataStreamReader.Context);
Assert.AreEqual(42, strmReader.ReadInt(ref ctx));
clientDriver.Dispose();
serverDriver.Dispose();
}
public void DisconnectFromARemoteEndPoint()
{
using (var host = new LocalDriverHelper(default(NetworkEndPoint)))
{
host.Host();
var driver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
// Need to be connected in order to be able to send a disconnect packet.
NetworkConnection connectionId = driver.Connect(host.Address);
Assert.True(connectionId != default(NetworkConnection));
driver.ScheduleUpdate().Complete();
var local = driver.LocalEndPoint();
host.Assert_GotConnectionRequest(local, true);
NetworkConnection con;
DataStreamReader slice;
// Pump so we get the accept message back.
driver.ScheduleUpdate().Complete();
Assert.AreEqual(NetworkEvent.Type.Connect, driver.PopEvent(out con, out slice));
driver.Disconnect(connectionId);
driver.ScheduleUpdate().Complete();
host.Assert_GotDisconnectionRequest(local);
driver.Dispose();
}
}
public void DisconnectFromARemoteEndPoint()
{
using (var host = new LocalDriverHelper(default(NetworkEndPoint)))
{
host.Host();
var driver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
// Need to be connected in order to be able to send a disconnect packet.
NetworkConnection connectionId = driver.Connect(host.Address);
Assert.True(connectionId != default(NetworkConnection));
var local = driver.LocalEndPoint();
host.Assert_GotConnectionRequest(local, true);
// Pump so we get the accept message back.
driver.Update();
driver.Disconnect(connectionId);
host.Assert_GotDisconnectionRequest(local);
driver.Dispose();
}
}
public void InitializeAndDestroyDriver()
{
var driver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
driver.Dispose();
}
public void SendReceiveInParallelJobWorks()
{
var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var clientDriver0 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
var clientDriver1 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
var serverToClient = new NativeArray <NetworkConnection>(2, Allocator.TempJob);
var strmWriter = new DataStreamWriter(4, Allocator.Temp);
strmWriter.Write(42);
var clientToServer0 = clientDriver0.Connect(serverDriver.LocalEndPoint());
var clientToServer1 = clientDriver1.Connect(serverDriver.LocalEndPoint());
WaitForConnected(clientDriver0, serverDriver, clientToServer0);
serverToClient[0] = serverDriver.Accept();
Assert.IsTrue(serverToClient[0].IsCreated);
WaitForConnected(clientDriver1, serverDriver, clientToServer1);
serverToClient[1] = serverDriver.Accept();
Assert.IsTrue(serverToClient[1].IsCreated);
clientToServer0.Send(clientDriver0, strmWriter);
clientToServer1.Send(clientDriver1, strmWriter);
strmWriter.Dispose();
clientDriver0.ScheduleUpdate().Complete();
clientDriver1.ScheduleUpdate().Complete();
var sendRecvJob = new SendReceiveParallelJob {
driver = serverDriver.ToConcurrent(), connections = serverToClient
};
var jobHandle = serverDriver.ScheduleUpdate();
jobHandle = sendRecvJob.Schedule(serverToClient.Length, 1, jobHandle);
serverDriver.ScheduleUpdate(jobHandle).Complete();
DataStreamReader strmReader;
clientDriver0.ScheduleUpdate().Complete();
Assert.AreEqual(NetworkEvent.Type.Data, clientToServer0.PopEvent(clientDriver0, out strmReader));
var ctx = default(DataStreamReader.Context);
Assert.AreEqual(43, strmReader.ReadInt(ref ctx));
clientDriver1.ScheduleUpdate().Complete();
Assert.AreEqual(NetworkEvent.Type.Data, clientToServer1.PopEvent(clientDriver1, out strmReader));
ctx = default(DataStreamReader.Context);
Assert.AreEqual(43, strmReader.ReadInt(ref ctx));
serverToClient.Dispose();
clientDriver0.Dispose();
clientDriver1.Dispose();
serverDriver.Dispose();
}
public void BindDriverToAEndPoint()
{
var driver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
driver.Bind(IPCManager.Instance.CreateEndPoint("host"));
driver.Dispose();
}
public void ScheduleUpdateWorks()
{
var driver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
var updateHandle = driver.ScheduleUpdate();
updateHandle.Complete();
driver.Dispose();
}
public void ConnectAttemptWithRetriesToARemoteEndPoint()
{
NetworkConnection connection;
NetworkEvent.Type eventType = 0;
DataStreamReader reader;
var hostAddress = IPCManager.Instance.CreateEndPoint(Utilities.Random.String(32));
// Tiny connect timeout for this test to be quicker
using (var client = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
},
new NetworkConfigParameter {
connectTimeoutMS = 1, maxConnectAttempts = 10
}))
{
client.Connect(hostAddress);
// Wait past the connect timeout so there will be unanswered connect requests
long timeout = m_timer.ElapsedMilliseconds + 2;
while (m_timer.ElapsedMilliseconds < timeout)
{
client.ScheduleUpdate().Complete();
}
using (var host = new LocalDriverHelper(hostAddress))
{
host.Host();
// Now give the next connect attempt time to happen
// TODO: Would be better to be able to see internal state here and explicitly wait until next connect attempt happens
timeout = m_timer.ElapsedMilliseconds + 10;
while (m_timer.ElapsedMilliseconds < timeout)
{
client.ScheduleUpdate().Complete();
}
host.Assert_GotConnectionRequest(client.LocalEndPoint(), true);
// Wait for the client to get the connect event back
timeout = m_timer.ElapsedMilliseconds + 2;
while (m_timer.ElapsedMilliseconds < timeout)
{
client.ScheduleUpdate().Complete();
eventType = client.PopEvent(out connection, out reader);
if (eventType != NetworkEvent.Type.Empty)
{
break;
}
}
Assert.AreEqual(NetworkEvent.Type.Connect, eventType);
}
}
}
public void IPC_Setup()
{
IPCManager.Instance.Initialize(100);
Driver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
RemoteDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
}
public void ScheduleUpdateWithMissingDependencyThrowsException()
{
var driver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
var updateHandle = driver.ScheduleUpdate();
Assert.Throws <InvalidOperationException>(() => { driver.ScheduleUpdate().Complete(); });
updateHandle.Complete();
driver.Dispose();
}
public void SendReceiveWithPipelineInParallelJobWorks()
{
var timeoutParam = new NetworkConfigParameter
{
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
disconnectTimeoutMS = 90 * 1000,
maxFrameTimeMS = 16
};
NativeArray <NetworkConnection> serverToClient;
using (var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}, timeoutParam))
using (var clientDriver0 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}, timeoutParam))
using (var clientDriver1 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}, timeoutParam))
using (serverToClient = new NativeArray <NetworkConnection>(2, Allocator.Persistent))
{
var serverPipeline = serverDriver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var client0Pipeline = clientDriver0.CreatePipeline(typeof(ReliableSequencedPipelineStage));
var client1Pipeline = clientDriver1.CreatePipeline(typeof(ReliableSequencedPipelineStage));
var strmWriter = new DataStreamWriter(4, Allocator.Temp);
strmWriter.Write(42);
var clientToServer0 = clientDriver0.Connect(serverDriver.LocalEndPoint());
var clientToServer1 = clientDriver1.Connect(serverDriver.LocalEndPoint());
WaitForConnected(clientDriver0, serverDriver, clientToServer0);
serverToClient[0] = serverDriver.Accept();
Assert.IsTrue(serverToClient[0].IsCreated);
WaitForConnected(clientDriver1, serverDriver, clientToServer1);
serverToClient[1] = serverDriver.Accept();
Assert.IsTrue(serverToClient[1].IsCreated);
clientToServer0.Send(clientDriver0, client0Pipeline, strmWriter);
clientToServer1.Send(clientDriver1, client1Pipeline, strmWriter);
clientDriver0.ScheduleUpdate().Complete();
clientDriver1.ScheduleUpdate().Complete();
var sendRecvJob = new SendReceiveWithPipelineParallelJob
{
driver = serverDriver.ToConcurrent(), connections = serverToClient, pipeline = serverPipeline
};
var jobHandle = serverDriver.ScheduleUpdate();
jobHandle = sendRecvJob.Schedule(serverToClient.Length, 1, jobHandle);
serverDriver.ScheduleUpdate(jobHandle).Complete();
AssertDataReceived(serverDriver, serverToClient, clientDriver0, clientToServer0, 43, false);
AssertDataReceived(serverDriver, serverToClient, clientDriver1, clientToServer1, 43, false);
}
}
public static unsafe void SetMinimumResendTime(int value, LocalNetworkDriver driver,
NetworkPipeline pipeline, int stageId, NetworkConnection con)
{
NativeSlice <byte> receiveBuffer = default(NativeSlice <byte>);
NativeSlice <byte> sendBuffer = default(NativeSlice <byte>);
NativeSlice <byte> sharedBuffer = default(NativeSlice <byte>);
driver.GetPipelineBuffers(pipeline, stageId, con, ref receiveBuffer, ref sendBuffer, ref sharedBuffer);
var sharedCtx = (ReliableUtility.SharedContext *)sharedBuffer.GetUnsafePtr();
sharedCtx->MinimumResendTime = value;
}
public void ListenOnDriver()
{
var driver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
// Make sure we Bind before we Listen.
driver.Bind(IPCManager.Instance.CreateEndPoint("host"));
driver.Listen();
Assert.True(driver.Listening);
driver.Dispose();
}
void WaitForConnected(LocalNetworkDriver clientDriver, LocalNetworkDriver serverDriver,
NetworkConnection clientToServer)
{
// Make sure connect message is sent
clientDriver.ScheduleUpdate().Complete();
// Make sure connection accept message is sent back
serverDriver.ScheduleUpdate().Complete();
// Handle the connection accept message
clientDriver.ScheduleUpdate().Complete();
DataStreamReader strmReader;
// Make sure the connected message was received
Assert.AreEqual(NetworkEvent.Type.Connect, clientToServer.PopEvent(clientDriver, out strmReader));
}
public void IPC_Setup()
{
IPCManager.Instance.Initialize(100);
Stream = new BitStream(64, Allocator.Persistent);
Driver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
RemoteDriver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
RemoteDriver.Bind(IPCManager.Instance.CreateEndPoint("remote_host"));
RemoteDriver.Listen();
}
public void ConnectToARemoteEndPoint()
{
using (var host = new LocalDriverHelper(default(NetworkEndPoint)))
{
host.Host();
var driver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
NetworkConnection connectionId = driver.Connect(host.Address);
Assert.True(connectionId != default(NetworkConnection));
var local = driver.LocalEndPoint();
host.Assert_GotConnectionRequest(local);
driver.Dispose();
}
}
public void SendReceiveInParallelJobWorks()
{
NativeArray <NetworkConnection> serverToClient;
using (var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}))
using (var clientDriver0 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}))
using (var clientDriver1 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}))
using (serverToClient = new NativeArray <NetworkConnection>(2, Allocator.Persistent))
{
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var strmWriter = new DataStreamWriter(4, Allocator.Temp);
strmWriter.Write(42);
var clientToServer0 = clientDriver0.Connect(serverDriver.LocalEndPoint());
var clientToServer1 = clientDriver1.Connect(serverDriver.LocalEndPoint());
WaitForConnected(clientDriver0, serverDriver, clientToServer0);
serverToClient[0] = serverDriver.Accept();
Assert.IsTrue(serverToClient[0].IsCreated);
WaitForConnected(clientDriver1, serverDriver, clientToServer1);
serverToClient[1] = serverDriver.Accept();
Assert.IsTrue(serverToClient[1].IsCreated);
clientToServer0.Send(clientDriver0, strmWriter);
clientToServer1.Send(clientDriver1, strmWriter);
clientDriver0.ScheduleUpdate().Complete();
clientDriver1.ScheduleUpdate().Complete();
var sendRecvJob = new SendReceiveParallelJob {
driver = serverDriver.ToConcurrent(), connections = serverToClient
};
var jobHandle = serverDriver.ScheduleUpdate();
jobHandle = sendRecvJob.Schedule(serverToClient.Length, 1, jobHandle);
serverDriver.ScheduleUpdate(jobHandle).Complete();
AssertDataReceived(serverDriver, serverToClient, clientDriver0, clientToServer0, 43, true);
AssertDataReceived(serverDriver, serverToClient, clientDriver1, clientToServer1, 43, true);
}
}
public void DisconnectTimeoutOnServer()
{
using (var host = new LocalDriverHelper(default(NetworkEndPoint), new NetworkConfigParameter {
disconnectTimeout = 40
}))
using (var client = new LocalNetworkDriver(new NetworkConfigParameter {
disconnectTimeout = 40
}))
{
NetworkConnection id;
NetworkEvent.Type popEvent;
BitSlice slice;
host.Host();
client.Connect(host.Address);
host.Assert_GotConnectionRequest(client.LocalEndPoint(), true);
// Eat connect event
popEvent = host.m_LocalDriver.PopEvent(out id, out slice);
Assert.AreEqual(NetworkEvent.Type.Connect, popEvent);
var stream = new BitStream(100, Allocator.Persistent);
for (int i = 0; i < 100; i++)
{
stream.Write((byte)i);
}
// Host sends stuff but gets nothing back, until disconnect timeout happens
var timeout = Timer.ElapsedMilliseconds + 100;
while (Timer.ElapsedMilliseconds < timeout)
{
host.m_LocalDriver.Send(host.ClientConnections[0], stream);
popEvent = host.m_LocalDriver.PopEvent(out id, out slice);
if (popEvent != NetworkEvent.Type.Empty)
{
break;
}
host.Update();
}
Assert.AreEqual(NetworkEvent.Type.Disconnect, popEvent);
}
}
public void DisconnectTimeoutOnServer()
{
using (var host = new LocalDriverHelper(default(NetworkEndPoint),
new NetworkConfigParameter {
disconnectTimeoutMS = 40
}))
using (var client = new LocalNetworkDriver(new NetworkConfigParameter {
disconnectTimeoutMS = 40
}))
{
NetworkConnection id;
NetworkEvent.Type popEvent = NetworkEvent.Type.Empty;
DataStreamReader reader;
host.Host();
client.Connect(host.Address);
client.ScheduleUpdate().Complete();
host.Assert_GotConnectionRequest(client.LocalEndPoint(), true);
var stream = new DataStreamWriter(100, Allocator.Persistent);
for (int i = 0; i < 100; i++)
{
stream.Write((byte)i);
}
// Host sends stuff but gets nothing back, until disconnect timeout happens
var timeout = m_timer.ElapsedMilliseconds + 100;
while (m_timer.ElapsedMilliseconds < timeout)
{
host.m_LocalDriver.Send(NetworkPipeline.Null, host.ClientConnections[0], stream);
popEvent = host.m_LocalDriver.PopEvent(out id, out reader);
if (popEvent != NetworkEvent.Type.Empty)
{
break;
}
host.Update();
}
stream.Dispose();
Assert.AreEqual(NetworkEvent.Type.Disconnect, popEvent);
}
}
public void AcceptNewConnectionsOnDriver()
{
var driver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
// Make sure we Bind before we Listen.
driver.Bind(IPCManager.Instance.CreateEndPoint("host"));
driver.Listen();
Assert.True(driver.Listening);
NetworkConnection connection;
while ((connection = driver.Accept()) != default(NetworkConnection))
{
//Assert.True(connectionId != NetworkParameterConstants.InvalidConnectionId);
}
driver.Dispose();
}
public void ReceiveInJobWorks()
{
var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var clientDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
var clientToServer = clientDriver.Connect(serverDriver.LocalEndPoint());
WaitForConnected(clientDriver, serverDriver, clientToServer);
var strmWriter = new DataStreamWriter(4, Allocator.Temp);
strmWriter.Write(42);
clientToServer.Send(clientDriver, strmWriter);
strmWriter.Dispose();
clientDriver.ScheduleUpdate().Complete();
var serverToClient = new NativeArray <NetworkConnection>(1, Allocator.TempJob);
var result = new NativeArray <int>(1, Allocator.TempJob);
var recvJob = new ReceiveJob {
driver = serverDriver, connections = serverToClient, result = result
};
Assert.AreNotEqual(42, result[0]);
var acceptJob = new AcceptJob {
driver = serverDriver, connections = serverToClient
};
recvJob.Schedule(serverDriver.ScheduleUpdate(acceptJob.Schedule())).Complete();
Assert.AreEqual(42, result[0]);
result.Dispose();
serverToClient.Dispose();
clientDriver.Dispose();
serverDriver.Dispose();
}
public void DataStremReaderIsOnlyUsableUntilUpdate()
{
var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var clientDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
var clientToServer = clientDriver.Connect(serverDriver.LocalEndPoint());
WaitForConnected(clientDriver, serverDriver, clientToServer);
var strmWriter = new DataStreamWriter(4, Allocator.Temp);
strmWriter.Write(42);
clientToServer.Send(clientDriver, strmWriter);
strmWriter.Dispose();
clientDriver.ScheduleUpdate().Complete();
var serverToClient = serverDriver.Accept();
serverDriver.ScheduleUpdate().Complete();
DataStreamReader strmReader;
Assert.AreEqual(NetworkEvent.Type.Data, serverToClient.PopEvent(serverDriver, out strmReader));
var ctx = default(DataStreamReader.Context);
Assert.AreEqual(42, strmReader.ReadInt(ref ctx));
ctx = default(DataStreamReader.Context);
Assert.AreEqual(42, strmReader.ReadInt(ref ctx));
serverDriver.ScheduleUpdate().Complete();
ctx = default(DataStreamReader.Context);
Assert.Throws <InvalidOperationException>(() => { strmReader.ReadInt(ref ctx); });
clientDriver.Dispose();
serverDriver.Dispose();
}
public void SendAndReceiveMessage()
{
using (var clientSendData = new BitStream(64, Allocator.Persistent))
{
BitSlice stream;
var serverEndpoint = IPCManager.Instance.CreateEndPoint("server");
var serverDriver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
serverDriver.Bind(serverEndpoint);
serverDriver.Listen();
var clientDriver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
clientDriver.Bind(IPCManager.Instance.CreateEndPoint("client"));
var clientToServerId = clientDriver.Connect(serverEndpoint);
serverDriver.Update();
NetworkConnection serverToClientId = serverDriver.Accept();
Assert.That(serverToClientId != default(NetworkConnection));
var eventId = serverDriver.PopEventForConnection(serverToClientId, out stream);
Assert.That(eventId == NetworkEvent.Type.Connect);
clientDriver.Update();
eventId = clientDriver.PopEventForConnection(clientToServerId, out stream);
Assert.That(eventId == NetworkEvent.Type.Connect);
int testInt = 100;
float testFloat = 555.5f;
byte[] testByteArray = Encoding.ASCII.GetBytes("Some bytes blablabla 1111111111111111111");
clientSendData.Write(testInt);
clientSendData.Write(testFloat);
clientSendData.Write(testByteArray.Length);
clientSendData.Write(testByteArray);
var sentBytes = clientDriver.Send(clientToServerId, clientSendData);
// Header size is included in the sent bytes count (4 bytes overhead)
Assert.AreEqual(clientSendData.GetBytesWritten() + 4, sentBytes);
clientDriver.Update();
serverDriver.Update();
BitSlice serverReceiveBitSlice;
eventId = serverDriver.PopEventForConnection(serverToClientId, out serverReceiveBitSlice);
Assert.True(eventId == NetworkEvent.Type.Data);
var receivedInt = serverReceiveBitSlice.ReadInt();
var receivedFloat = serverReceiveBitSlice.ReadFloat();
var byteArrayLength = serverReceiveBitSlice.ReadInt();
var receivedBytes = serverReceiveBitSlice.ReadBytesAsArray(byteArrayLength);
Assert.True(testInt == receivedInt);
Assert.That(Mathf.Approximately(testFloat, receivedFloat));
Assert.AreEqual(testByteArray, receivedBytes);
clientDriver.Dispose();
serverDriver.Dispose();
}
}
public void FillInternalBitStreamBuffer()
{
const int k_InternalBufferSize = 1000;
const int k_PacketCount = 21; // Exactly enough to fill the receive buffer + 1 too much
const int k_PacketSize = 50;
using (var host = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = k_InternalBufferSize
}))
using (var client = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
}))
using (var stream = new BitStream(64, Allocator.Persistent))
{
host.Bind(IPCManager.Instance.CreateEndPoint(Utilities.Random.String(32)));
host.Listen();
NetworkConnection connectionId = client.Connect(host.LocalEndPoint());
client.Update();
host.Update();
NetworkConnection poppedId;
BitSlice slice;
var retval = host.PopEvent(out poppedId, out slice);
Assert.AreEqual(retval, NetworkEvent.Type.Connect);
host.Accept();
client.Update();
retval = client.PopEvent(out poppedId, out slice);
Assert.AreEqual(retval, NetworkEvent.Type.Connect);
var dataBlob = new Dictionary <int, byte[]>();
for (int i = 0; i < k_PacketCount; ++i)
{
// Scramble each packet contents so you can't match reading the same data twice as success
dataBlob.Add(i, Encoding.ASCII.GetBytes(Utilities.Random.String(k_PacketSize)));
}
for (int i = 0; i < k_PacketCount; ++i)
{
stream.Reset();
stream.Write(dataBlob[i]);
client.Send(connectionId, stream);
}
// Process the pending events
client.Update();
host.Update();
for (int i = 0; i < k_PacketCount; ++i)
{
retval = host.PopEvent(out poppedId, out slice);
if (i == k_PacketCount - 1)
{
Assert.AreEqual(retval, NetworkEvent.Type.Empty);
Assert.AreEqual(slice.Length, 0);
host.Update();
retval = host.PopEvent(out poppedId, out slice);
}
Assert.AreEqual(retval, NetworkEvent.Type.Data);
Assert.AreEqual(k_PacketSize, slice.Length);
for (int j = 0; j < k_PacketSize; ++j)
{
Assert.AreEqual(dataBlob[i][j], slice.ReadByte());
}
}
}
}
