public void IPC_TearDown()
{
IPCManager.Instance.Destroy();
Driver.Dispose();
RemoteDriver.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();
}
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 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 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 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 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 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 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 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();
}
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 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 Dispose()
{
m_Driver.Dispose();
}
public void Dispose()
{
m_LocalDriver.Dispose();
m_LocalBitStream.Dispose();
}
public void SendReceiveWithPipelineInParallelJobWorks()
{
var timeoutParam = new NetworkConfigParameter
{
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
disconnectTimeoutMS = 90 * 1000
};
var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}, timeoutParam);
var serverPipeline = serverDriver.CreatePipeline(typeof(UnreliableSequencedPipelineStage));
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var clientDriver0 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}, timeoutParam);
var clientDriver1 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}, timeoutParam);
var client0Pipeline = clientDriver0.CreatePipeline(typeof(UnreliableSequencedPipelineStage));
var client1Pipeline = clientDriver1.CreatePipeline(typeof(UnreliableSequencedPipelineStage));
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, 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();
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 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();
}
}