test: replace manual tests with automated tests (#1365)

- C788903	Verify null arrays of custom types are being serialized
- C788904	Verify RpcDelivery option exposed on both ServerRpc and ClientRpc attributes
- C788905	Verify RpcDelivery options are mapping to matching transport channels for replication
- C788906	Verify when RpcDelivery is not specified that Rpc still replicates
- C788912	Verify ServerRpc method with no parameters replicates from client to server
- C788913	Verify ClientRpc method with no parameters replicates from server to 1 client
- C788915	Verify ServerRpc method with 1 parameter replicates from client to server
- C788916	Verify ClientRpc method with 1 parameter replicates from server to 1 client
- C788918	Verify ServerRpc method with more than 1 parameters replicates from client to server
- C788919	Verify ClientRpc method with more than 1 parameters replicates from server to 1 client
- C788921	Verify C# and Unity primitive types are supported in Rpc method signatures
- C816309	Verify that sending Rpc messages are sent and received properly through the queue system
- C816312	Verifies the core functionality of the RcpQueueContainer

Author: jeffreyrainy

com.unity.netcode.gameobjects/Tests/Runtime/RpcOwnershipCustomTests.cs

@@ -73,6 +73,16 @@ public class RpcOwnershipObject : NetworkBehaviour
         public int RequireOwnershipCount = 0;
         public int DoesntRequireOwnershipCount = 0;
         public int ArrayRpcCount = 0;
+        public bool ReliableServerRpcCalled;
+        public bool ReliableClientRpcCalled;
+        public bool UnreliableServerRpcCalled;
+        public bool UnreliableClientRpcCalled;
+
+        [ServerRpc]
+        public void ExpectingNullObjectServerRpc(CustomType anObject)
+        {
+            Debug.Assert(anObject == null);
+        }
 
         [ServerRpc(RequireOwnership = true)]
         public void RequireOwnershipServerRpc()
@@ -98,7 +108,7 @@ public void TwoCustomTypesAndVect3ServerRpc(CustomType someObject, DifferentCust
         }
 
         [ServerRpc]
-        public void ArrayOfCustomTypesServerRpc(CustomType[] arrayOfObjects, CustomType[] emptyArray)
+        public void ArrayOfCustomTypesServerRpc(CustomType[] arrayOfObjects, CustomType[] emptyArray, CustomType[] nullArray)
         {
             Debug.Assert(arrayOfObjects.Length > 0);
             for (int i = 0; i < arrayOfObjects.Length; i++)
@@ -110,9 +120,31 @@ public void ArrayOfCustomTypesServerRpc(CustomType[] arrayOfObjects, CustomType[
             }
 
             Debug.Assert(emptyArray.Length == 0);
+            Debug.Assert(nullArray == null);
 
             ArrayRpcCount++;
         }
+
+        [ServerRpc(Delivery = RpcDelivery.Unreliable)]
+        public void UnreliableServerRpc()
+        {
+            UnreliableServerRpcCalled = true;
+        }
+        [ServerRpc(Delivery = RpcDelivery.Reliable)]
+        public void ReliableServerRpc()
+        {
+            ReliableServerRpcCalled = true;
+        }
+        [ClientRpc(Delivery = RpcDelivery.Unreliable)]
+        public void UnreliableClientRpc()
+        {
+            UnreliableClientRpcCalled = true;
+        }
+        [ClientRpc(Delivery = RpcDelivery.Reliable)]
+        public void ReliableClientRpc()
+        {
+            ReliableClientRpcCalled = true;
+        }
     }
 
     public class RpcOwnershipCustomTests : BaseMultiInstanceTest
@@ -166,13 +198,15 @@ public IEnumerator RpcArrayCustomTypesTest()
 
             netSpawnedObject.Spawn();
 
+            netSpawnedObject.GetComponent<RpcOwnershipObject>().ExpectingNullObjectServerRpc(null);
+
             var arrayOfObjects = new CustomType[2] { new CustomType(), new CustomType() };
             var emptyArray = new CustomType[0];
 
             arrayOfObjects[0].SomeValue = 1;
             arrayOfObjects[1].SomeValue = 2;
 
-            netSpawnedObject.GetComponent<RpcOwnershipObject>().ArrayOfCustomTypesServerRpc(arrayOfObjects, emptyArray);
+            netSpawnedObject.GetComponent<RpcOwnershipObject>().ArrayOfCustomTypesServerRpc(arrayOfObjects, emptyArray, null);
 
             Debug.Assert(netSpawnedObject.GetComponent<RpcOwnershipObject>().ArrayRpcCount == 1);
             yield return null;
@@ -196,6 +230,38 @@ public IEnumerator CustomTypesTest()
             yield return null;
         }
 
+        [UnityTest]
+        public IEnumerator RpcDeliveryTests()
+        {
+            var spawnedObject = UnityEngine.Object.Instantiate(m_PrefabToSpawn);
+            var netSpawnedObject = spawnedObject.GetComponent<NetworkObject>();
+            netSpawnedObject.NetworkManagerOwner = m_ServerNetworkManager;
+
+            var rpcObject = spawnedObject.GetComponent<RpcOwnershipObject>();
+
+            netSpawnedObject.Spawn();
+
+            rpcObject.ReliableServerRpc();
+            rpcObject.ReliableClientRpc();
+
+            // Those two calls are unreliable. So, for testing, we'll call them multiple
+            // times (just one call might be dropped). If it so happens that 10 calls in a row are missed, then some
+            // debugging would be worth.
+            for (int i = 0; i < 10; i++)
+            {
+                rpcObject.UnreliableServerRpc();
+                rpcObject.UnreliableClientRpc();
+
+                var nextFrameNumber = Time.frameCount + 1;
+                yield return new WaitUntil(() => Time.frameCount >= nextFrameNumber);
+            }
+
+            Debug.Assert(rpcObject.ReliableServerRpcCalled);
+            Debug.Assert(rpcObject.UnreliableServerRpcCalled);
+            Debug.Assert(rpcObject.ReliableClientRpcCalled);
+            Debug.Assert(rpcObject.UnreliableClientRpcCalled);
+        }
+
         private IEnumerator RunTests(bool serverOwned)
         {
             m_ExpectedRequireOwnershipCount = 0;