Update tests to test fix properly

Author: EmandM

com.unity.netcode.gameobjects/Runtime/Transports/UTP/BatchedSendQueue.cs

@@ -32,6 +32,8 @@ internal struct BatchedSendQueue : IDisposable
 
         internal const int MinimumMinimumCapacity = 4096;
         // int.MaxValue is odd and maximum must be even.
+        // This is safe to be so large as the queue is dynamically allocated.
+        // It's very unlikely that the actual send queue will ever grow this large
         internal const int MaximumMaximumCapacity = int.MaxValue - 1;
 
         // Indices into m_HeadTailIndicies.

com.unity.netcode.gameobjects/Runtime/Transports/UTP/UnityTransport.cs

@@ -1519,7 +1519,7 @@ public override void Send(ulong clientId, ArraySegment<byte> payload, NetworkDel
                 if (maxCapacity <= 0)
                 {
                     // Setting m_DisconnectTimeoutMS to zero will disable the timeout entirely
-                    // by setting the maxCapacity to it's maximum capacity
+                    // Set the capacity as if the disconnect timeout is the largest possible value
                     if (m_DisconnectTimeoutMS == 0)
                     {
                         maxCapacity = BatchedSendQueue.MaximumMaximumCapacity;

com.unity.netcode.gameobjects/Tests/Runtime/Transports/UnityTransportTests.cs

@@ -192,8 +192,9 @@ public IEnumerator SendMaximumPayloadSize(
         [UnityTest]
         public IEnumerator VeryLargeDisconnectTimeout()
         {
-            // We want something that's over the old limit of ~44KB for reliable payloads.
-            var payloadSize = 64 * 1024;
+            // The calculation will never be lower than the UnityTransport.InitialMaxPayloadSize
+            // We want to send a message larger than that size to ensure the maximum is high enough
+            var payloadSize = UnityTransport.InitialMaxPayloadSize * 2;
 
             var disconnectTimeout = int.MaxValue;
 
@@ -207,21 +208,33 @@ public IEnumerator VeryLargeDisconnectTimeout()
 
             yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
 
-            var payload = new ArraySegment<byte>(Encoding.ASCII.GetBytes("Some message"));
+            var payloadData = new byte[payloadSize];
+            for (int i = 0; i < payloadData.Length; i++)
+            {
+                payloadData[i] = (byte)i;
+            }
+
+            var payload = new ArraySegment<byte>(payloadData);
             m_Client1.Send(m_Client1.ServerClientId, payload, NetworkDelivery.Reliable);
 
             yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents, MaxNetworkEventWaitTime * 4);
 
-            Assert.That(m_ServerEvents[1].Data, Is.EquivalentTo(Encoding.ASCII.GetBytes("Some message")));
+            Assert.AreEqual(payloadSize, m_ServerEvents[1].Data.Count);
 
-            yield return null;
+            var receivedArray = m_ServerEvents[1].Data.Array;
+            var receivedArrayOffset = m_ServerEvents[1].Data.Offset;
+            for (int i = 0; i < payloadSize; i++)
+            {
+                Assert.AreEqual(payloadData[i], receivedArray[receivedArrayOffset + i]);
+            }
         }
 
         [UnityTest]
         public IEnumerator ZeroDisconnectTimeoutSetToZero()
         {
-            // We want something that's over the old limit of ~44KB for reliable payloads.
-            var payloadSize = 64 * 1024;
+            // The calculation will never be lower than the UnityTransport.InitialMaxPayloadSize
+            // We want to send a message larger than that size to ensure the maximum is high enough
+            var payloadSize = UnityTransport.InitialMaxPayloadSize * 2;
 
             var disconnectTimeout = 0;
 
@@ -235,14 +248,25 @@ public IEnumerator ZeroDisconnectTimeoutSetToZero()
 
             yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
 
-            var payload = new ArraySegment<byte>(Encoding.ASCII.GetBytes("Some message"));
+            var payloadData = new byte[payloadSize];
+            for (int i = 0; i < payloadData.Length; i++)
+            {
+                payloadData[i] = (byte)i;
+            }
+
+            var payload = new ArraySegment<byte>(payloadData);
             m_Client1.Send(m_Client1.ServerClientId, payload, NetworkDelivery.Reliable);
 
             yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents, MaxNetworkEventWaitTime * 4);
 
-            Assert.That(m_ServerEvents[1].Data, Is.EquivalentTo(Encoding.ASCII.GetBytes("Some message")));
+            Assert.AreEqual(payloadSize, m_ServerEvents[1].Data.Count);
 
-            yield return null;
+            var receivedArray = m_ServerEvents[1].Data.Array;
+            var receivedArrayOffset = m_ServerEvents[1].Data.Offset;
+            for (int i = 0; i < payloadSize; i++)
+            {
+                Assert.AreEqual(payloadData[i], receivedArray[receivedArrayOffset + i]);
+            }
         }
 
         // Check making multiple sends to a client in a single frame.