public IEnumerator UpdateStagesInvocation()
{
Guid updateStagesTestId = NetworkManagerHelper.AddGameNetworkObject("UpdateStagesTest");
var rpcPipelineTestComponent = NetworkManagerHelper.AddComponentToObject <NetworkUpdateStagesComponent>(updateStagesTestId);
NetworkManagerHelper.SpawnNetworkObject(updateStagesTestId);
var testsAreComplete = rpcPipelineTestComponent.IsTestComplete();
var exceededMaximumStageIterations = rpcPipelineTestComponent.ExceededMaxIterations();
// Start testing
rpcPipelineTestComponent.EnableTesting = true;
Debug.Log("Running TestNetworkUpdateStages: ");
// Wait for the RPC pipeline test to complete or if we exceeded the maximum iterations bail
while (!testsAreComplete && !exceededMaximumStageIterations)
{
yield return(new WaitForSeconds(0.003f));
testsAreComplete = rpcPipelineTestComponent.IsTestComplete();
Assert.IsFalse(rpcPipelineTestComponent.ExceededMaxIterations());
}
var testsAreValidated = rpcPipelineTestComponent.ValidateUpdateStages();
// Stop testing
rpcPipelineTestComponent.EnableTesting = false;
Debug.Log($"Exiting status => {nameof(testsAreComplete)}: {testsAreComplete} - {nameof(testsAreValidated)}: {testsAreValidated} -{nameof(exceededMaximumStageIterations)}: {exceededMaximumStageIterations}");
Assert.IsTrue(testsAreComplete && testsAreValidated);
// Disable this so it isn't running any longer.
rpcPipelineTestComponent.gameObject.SetActive(false);
}
public IEnumerator BufferDataValidation()
{
Guid gameObjectId = NetworkManagerHelper.AddGameNetworkObject("GrowingBufferObject");
var growingRpcBufferSizeComponent = NetworkManagerHelper.AddComponentToObject <BufferDataValidationComponent>(gameObjectId);
NetworkManagerHelper.SpawnNetworkObject(gameObjectId);
// Start Testing
growingRpcBufferSizeComponent.EnableTesting = true;
var testsAreComplete = growingRpcBufferSizeComponent.IsTestComplete();
// Wait for the RPC pipeline test to complete or if we exceeded the maximum iterations bail
while (!testsAreComplete)
{
yield return(new WaitForSeconds(0.003f));
testsAreComplete = growingRpcBufferSizeComponent.IsTestComplete();
}
// Stop Testing
growingRpcBufferSizeComponent.EnableTesting = false;
// Just disable this once we are done.
growingRpcBufferSizeComponent.gameObject.SetActive(false);
Assert.IsTrue(testsAreComplete);
}
public void NetworkConfigInvalidNetworkPrefabTest()
{
var testPrefabObjectName = "NetworkPrefabHandlerTestObject";
Guid baseObjectID = NetworkManagerHelper.AddGameNetworkObject(testPrefabObjectName);
NetworkObject baseObject = NetworkManagerHelper.InstantiatedNetworkObjects[baseObjectID];
// Add null entry
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(null);
// Add a NetworkPrefab with no prefab
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new Configuration.NetworkPrefab());
var validNetworkPrefab = new Configuration.NetworkPrefab();
validNetworkPrefab.Prefab = baseObject.gameObject;
//Add a valid prefab
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(validNetworkPrefab);
var exceptionOccurred = false;
try
{
NetworkManagerHelper.NetworkManagerObject.StartHost();
}
catch
{
exceptionOccurred = true;
}
Assert.False(exceptionOccurred);
}
public IEnumerator TestAllNetworkVariableTypes()
{
Guid gameObjectId = NetworkManagerHelper.AddGameNetworkObject("NetworkVariableTestComponent");
var networkVariableTestComponent = NetworkManagerHelper.AddComponentToObject <NetworkVariableTestComponent>(gameObjectId);
NetworkManagerHelper.SpawnNetworkObject(gameObjectId);
// Start Testing
networkVariableTestComponent.EnableTesting = true;
var testsAreComplete = networkVariableTestComponent.IsTestComplete();
// Wait for the NetworkVariable tests to complete
while (!testsAreComplete)
{
yield return(new WaitForSeconds(0.003f));
testsAreComplete = networkVariableTestComponent.IsTestComplete();
}
// Stop Testing
networkVariableTestComponent.EnableTesting = false;
Assert.IsTrue(networkVariableTestComponent.DidAllValuesChange());
// Disable this once we are done.
networkVariableTestComponent.gameObject.SetActive(false);
Assert.IsTrue(testsAreComplete);
}
private void SendBufferServerRpc(byte[] buffer)
{
TestFailed = !NetworkManagerHelper.BuffersMatch(0, buffer.Length, buffer, m_SendBuffer.ToArray());
if (!TestFailed)
{
Debug.Log($"Tested buffer size of {m_SendBuffer.Count} -- OK");
}
if (m_CurrentBufferSize == MaximumBufferSize)
{
m_CurrentBufferSize++;
}
else
{
//Increasse buffer size
m_CurrentBufferSize = m_CurrentBufferSize << 1;
}
m_WaitForValidation = false;
}
public void Setup()
{
// Create, instantiate, and host
Assert.IsTrue(NetworkManagerHelper.StartNetworkManager(out _));
}
public void TearDown()
{
// Stop, shutdown, and destroy
NetworkManagerHelper.ShutdownNetworkManager();
}
public void RpcQueueContainerClass()
{
// Create a testing rpcQueueContainer that doesn't get added to the network update loop so we don't try to send or process during the test
var rpcQueueContainer = new RpcQueueContainer(NetworkManagerHelper.NetworkManagerObject, 0, true);
// Make sure we set testing mode so we don't try to invoke RPCs
rpcQueueContainer.SetTestingState(true);
var maxRpcEntries = 8;
var messageChunkSize = 2048;
var preCalculatedBufferValues = new List <byte>(messageChunkSize);
for (int i = 0; i < messageChunkSize; i++)
{
preCalculatedBufferValues.AddRange(BitConverter.GetBytes(UnityEngine.Random.Range(0, ulong.MaxValue)));
}
var indexOffset = 0;
ulong senderNetworkId = 1;
// Create fictitious list of clients to send to
ulong[] psuedoClients = new ulong[] { 0 };
var randomGeneratedDataArray = preCalculatedBufferValues.ToArray();
var maximumOffsetValue = preCalculatedBufferValues.Count;
// Testing outbound side of the RpcQueueContainer
for (int i = 0; i < maxRpcEntries; i++)
{
// Increment our offset into our randomly generated data for next entry;
indexOffset = (i * messageChunkSize) % maximumOffsetValue;
var writer = rpcQueueContainer.BeginAddQueueItemToFrame(RpcQueueContainer.QueueItemType.ServerRpc, Time.realtimeSinceStartup, Transports.NetworkChannel.DefaultMessage,
senderNetworkId, psuedoClients, RpcQueueHistoryFrame.QueueFrameType.Outbound, NetworkUpdateStage.PostLateUpdate);
writer.WriteByteArray(randomGeneratedDataArray, messageChunkSize);
rpcQueueContainer.EndAddQueueItemToFrame(writer, RpcQueueHistoryFrame.QueueFrameType.Outbound, NetworkUpdateStage.PostLateUpdate);
}
// Now verify the data by obtaining the RpcQueueHistoryFrame we just wrote to
var currentFrame = rpcQueueContainer.GetLoopBackHistoryFrame(RpcQueueHistoryFrame.QueueFrameType.Outbound, NetworkUpdateStage.PostLateUpdate);
// Reset our index offset
indexOffset = 0;
int queueEntryItemCount = 0;
// Parse through the entries written to the current RpcQueueHistoryFrame
var currentQueueItem = currentFrame.GetFirstQueueItem();
while (currentQueueItem.QueueItemType != RpcQueueContainer.QueueItemType.None)
{
// Check to make sure the wrapper information is accurate for the entry
Assert.AreEqual(currentQueueItem.NetworkId, senderNetworkId);
Assert.AreEqual(currentQueueItem.QueueItemType, RpcQueueContainer.QueueItemType.ServerRpc);
Assert.AreEqual(currentQueueItem.UpdateStage, NetworkUpdateStage.PostLateUpdate);
Assert.AreEqual(currentQueueItem.NetworkChannel, Transports.NetworkChannel.DefaultMessage);
// Validate the data in the queue
Assert.IsTrue(NetworkManagerHelper.BuffersMatch(currentQueueItem.MessageData.Offset, messageChunkSize, currentQueueItem.MessageData.Array, randomGeneratedDataArray));
// Prepare for next queue item
queueEntryItemCount++;
currentQueueItem = currentFrame.GetNextQueueItem();
}
rpcQueueContainer.Dispose();
}
public void Setup()
{
//Create, instantiate, and host
NetworkManagerHelper.StartNetworkManager(out _);
}
public void NetworkPrefabHandlerClass()
{
Assert.IsTrue(NetworkManagerHelper.StartNetworkManager(out _));
var testPrefabObjectName = "NetworkPrefabHandlerTestObject";
Guid baseObjectID = NetworkManagerHelper.AddGameNetworkObject(testPrefabObjectName);
NetworkObject baseObject = NetworkManagerHelper.InstantiatedNetworkObjects[baseObjectID];
var networkPrefabHandler = new NetworkPrefabHandler();
var networkPrefaInstanceHandler = new NetworkPrefaInstanceHandler(baseObject);
var prefabPosition = new Vector3(1.0f, 5.0f, 3.0f);
var prefabRotation = new Quaternion(1.0f, 0.5f, 0.4f, 0.1f);
//Register via GameObject
var gameObjectRegistered = networkPrefabHandler.AddHandler(baseObject.gameObject, networkPrefaInstanceHandler);
//Test result of registering via GameObject reference
Assert.True(gameObjectRegistered);
var spawnedObject = networkPrefabHandler.HandleNetworkPrefabSpawn(baseObject.GlobalObjectIdHash, 0, prefabPosition, prefabRotation);
//Test that something was instantiated
Assert.NotNull(spawnedObject);
//Test that this is indeed an instance of our original object
Assert.True(spawnedObject.name.Contains(testPrefabObjectName));
//Test for position and rotation
Assert.True(prefabPosition == spawnedObject.transform.position);
Assert.True(prefabRotation == spawnedObject.transform.rotation);
networkPrefabHandler.HandleNetworkPrefabDestroy(spawnedObject); //Destroy our prefab instance
networkPrefabHandler.RemoveHandler(baseObject); //Remove our handler
//Register via NetworkObject
gameObjectRegistered = networkPrefabHandler.AddHandler(baseObject, networkPrefaInstanceHandler);
//Test result of registering via NetworkObject reference
Assert.True(gameObjectRegistered);
//Change it up
prefabPosition = new Vector3(2.0f, 1.0f, 5.0f);
prefabRotation = new Quaternion(4.0f, 1.5f, 5.4f, 5.1f);
spawnedObject = networkPrefabHandler.HandleNetworkPrefabSpawn(baseObject.GlobalObjectIdHash, 0, prefabPosition, prefabRotation);
//Test that something was instantiated
Assert.NotNull(spawnedObject);
//Test that this is indeed an instance of our original object
Assert.True(spawnedObject.name.Contains(testPrefabObjectName));
//Test for position and rotation
Assert.True(prefabPosition == spawnedObject.transform.position);
Assert.True(prefabRotation == spawnedObject.transform.rotation);
networkPrefabHandler.HandleNetworkPrefabDestroy(spawnedObject); //Destroy our prefab instance
networkPrefabHandler.RemoveHandler(baseObject); //Remove our handler
//Register via GlobalObjectIdHash
gameObjectRegistered = networkPrefabHandler.AddHandler(baseObject.GlobalObjectIdHash, networkPrefaInstanceHandler);
//Test result of registering via GlobalObjectIdHash reference
Assert.True(gameObjectRegistered);
//Change it up
prefabPosition = new Vector3(6.0f, 4.0f, 1.0f);
prefabRotation = new Quaternion(3f, 2f, 4f, 1f);
spawnedObject = networkPrefabHandler.HandleNetworkPrefabSpawn(baseObject.GlobalObjectIdHash, 0, prefabPosition, prefabRotation);
//Test that something was instantiated
Assert.NotNull(spawnedObject);
//Test that this is indeed an instance of our original object
Assert.True(spawnedObject.name.Contains(testPrefabObjectName));
//Test for position and rotation
Assert.True(prefabPosition == spawnedObject.transform.position);
Assert.True(prefabRotation == spawnedObject.transform.rotation);
networkPrefabHandler.HandleNetworkPrefabDestroy(spawnedObject); //Destroy our prefab instance
networkPrefabHandler.RemoveHandler(baseObject); //Remove our handler
Assert.False(networkPrefaInstanceHandler.StillHasInstances());
}
public void Setup()
{
//Create, instantiate, and host
NetworkManagerHelper.StartNetworkManager(out _, NetworkManagerHelper.NetworkManagerOperatingMode.None);
}
public void Setup()
{
// Create, instantiate, and host
Assert.IsTrue(NetworkManagerHelper.StartNetworkManager(out _, NetworkManagerHelper.NetworkManagerOperatingMode.None));
m_ValidationToken = Guid.NewGuid();
}
