Unity-Technologies
diff --git a/‎com.unity.netcode.adapter.utp/Tests/Runtime/Helpers/RuntimeTestsHelpers.cs
Lines changed: 13 additions & 10 deletions b/‎com.unity.netcode.adapter.utp/Tests/Runtime/Helpers/RuntimeTestsHelpers.cs
Lines changed: 13 additions & 10 deletions
diff --git a/‎com.unity.netcode.adapter.utp/Tests/Runtime/TransportTests.cs
Lines changed: 30 additions & 16 deletions b/‎com.unity.netcode.adapter.utp/Tests/Runtime/TransportTests.cs
Lines changed: 30 additions & 16 deletions
diff --git a/‎com.unity.netcode.gameobjects/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs
Lines changed: 7 additions & 2 deletions b/‎com.unity.netcode.gameobjects/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs
Lines changed: 7 additions & 2 deletions
@@ -1,34 +1,38 @@
 using NUnit.Framework;
 using System;
-using System.Linq;
 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
-
 namespace Unity.Netcode.UTP.RuntimeTests
 {
     public static class RuntimeTestsHelpers
     {
         // Half a second might seem like a very long time to wait for a network event, but in CI
         // many of the machines are underpowered (e.g. old Android devices or Macs) and there are
-        // sometimes lag spikes that cause can cause delays upwards of 300ms.
+        // sometimes very high lag spikes. PS4 and Switch are particularly sensitive in this regard
+        // so we allow even more time for these platforms.
+#if UNITY_PS4 || UNITY_SWITCH
+        public const float MaxNetworkEventWaitTime = 2.0f;
+#else
         public const float MaxNetworkEventWaitTime = 0.5f;
+#endif
 
         // Wait for an event to appear in the given event list (must be the very next event).
-        public static IEnumerator WaitForNetworkEvent(NetworkEvent type, List<TransportEvent> events)
+        public static IEnumerator WaitForNetworkEvent(NetworkEvent type, List<TransportEvent> events,
+            float timeout = MaxNetworkEventWaitTime)
         {
             int initialCount = events.Count;
             float startTime = Time.realtimeSinceStartup;
 
-            while (Time.realtimeSinceStartup - startTime < MaxNetworkEventWaitTime)
+            while (Time.realtimeSinceStartup - startTime < timeout)
             {
                 if (events.Count > initialCount)
                 {
                     Assert.AreEqual(type, events[initialCount].Type);
                     yield break;
                 }
 
-                yield return null;
+                yield return new WaitForSeconds(0.01f);
             }
 
             Assert.Fail("Timed out while waiting for network event.");
@@ -56,23 +60,22 @@ public struct TransportEvent
             public ArraySegment<byte> Data;
             public float ReceiveTime;
         }
-
         // Utility class that logs events generated by a UnityTransport. Set it up by adding the
         // HandleEvent method as an OnTransportEvent delegate of the transport. The list of events
         // (in order in which they were generated) can be accessed through the Events property.
         public class TransportEventLogger
         {
             private readonly List<TransportEvent> m_Events = new List<TransportEvent>();
             public List<TransportEvent> Events => m_Events;
-
             public void HandleEvent(NetworkEvent type, ulong clientID, ArraySegment<byte> data, float receiveTime)
             {
                 // Copy the data since the backing array will be reused for future messages.
                 if (data != default(ArraySegment<byte>))
                 {
-                    data = new ArraySegment<byte>(data.ToArray());
+                    var dataCopy = new byte[data.Count];
+                    Array.Copy(data.Array, data.Offset, dataCopy, 0, data.Count);
+                    data = new ArraySegment<byte>(dataCopy);
                 }
-
                 m_Events.Add(new TransportEvent
                 {
                     Type = type,
 
@@ -1,3 +1,5 @@
+// todo @simon-lemay-unity: un-guard/re-enable after validating UTP on consoles
+#if UNITY_EDITOR || UNITY_STANDALONE || UNITY_IOS || UNITY_ANDROID
 using NUnit.Framework;
 using System;
 using System.Collections;
@@ -30,19 +32,25 @@ public IEnumerator Cleanup()
             if (m_Server)
             {
                 m_Server.Shutdown();
-                UnityEngine.Object.DestroyImmediate(m_Server);
+
+                // Need to destroy the GameObject (all assigned components will get destroyed too)
+                UnityEngine.Object.DestroyImmediate(m_Server.gameObject);
             }
 
             if (m_Client1)
             {
                 m_Client1.Shutdown();
-                UnityEngine.Object.DestroyImmediate(m_Client1);
+
+                // Need to destroy the GameObject (all assigned components will get destroyed too)
+                UnityEngine.Object.DestroyImmediate(m_Client1.gameObject);
             }
 
             if (m_Client2)
             {
                 m_Client2.Shutdown();
-                UnityEngine.Object.DestroyImmediate(m_Client2);
+
+                // Need to destroy the GameObject (all assigned components will get destroyed too)
+                UnityEngine.Object.DestroyImmediate(m_Client2.gameObject);
             }
 
             m_ServerEvents?.Clear();
@@ -62,7 +70,7 @@ public IEnumerator PingPong([ValueSource("k_DeliveryParameters")] NetworkDeliver
             m_Server.StartServer();
             m_Client1.StartClient();
 
-            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ServerEvents);
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
 
             var ping = new ArraySegment<byte>(Encoding.ASCII.GetBytes("ping"));
             m_Client1.Send(m_Client1.ServerClientId, ping, delivery);
@@ -91,7 +99,7 @@ public IEnumerator PingPongSimultaneous([ValueSource("k_DeliveryParameters")] Ne
             m_Server.StartServer();
             m_Client1.StartClient();
 
-            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ServerEvents);
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
 
             var ping = new ArraySegment<byte>(Encoding.ASCII.GetBytes("ping"));
             m_Server.Send(m_ServerEvents[0].ClientID, ping, delivery);
@@ -128,7 +136,7 @@ public IEnumerator SendMaximumPayloadSize([ValueSource("k_DeliveryParameters")]
             m_Server.StartServer();
             m_Client1.StartClient();
 
-            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ServerEvents);
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
 
             var payloadData = new byte[payloadSize];
             for (int i = 0; i < payloadData.Length; i++)
@@ -139,7 +147,7 @@ public IEnumerator SendMaximumPayloadSize([ValueSource("k_DeliveryParameters")]
             var payload = new ArraySegment<byte>(payloadData);
             m_Client1.Send(m_Client1.ServerClientId, payload, delivery);
 
-            yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
+            yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents, MaxNetworkEventWaitTime * 2);
 
             Assert.AreEqual(payloadSize, m_ServerEvents[1].Data.Count);
 
@@ -162,7 +170,7 @@ public IEnumerator FilledSendQueueMultipleSends([ValueSource("k_DeliveryParamete
             m_Server.StartServer();
             m_Client1.StartClient();
 
-            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ServerEvents);
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
 
             var numSends = UnityTransport.InitialMaxSendQueueSize / 1024;
 
@@ -180,7 +188,7 @@ public IEnumerator FilledSendQueueMultipleSends([ValueSource("k_DeliveryParamete
             yield return new WaitForSeconds(numSends * 0.02f);
 
             // Extra event is the connect event.
-            Assert.AreEqual(m_ServerEvents.Count, numSends + 1);
+            Assert.AreEqual(numSends + 1, m_ServerEvents.Count);
 
             for (int i = 1; i <= numSends; i++)
             {
@@ -201,7 +209,7 @@ public IEnumerator MultipleSendsSingleFrame([ValueSource("k_DeliveryParameters")
             m_Server.StartServer();
             m_Client1.StartClient();
 
-            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ServerEvents);
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
 
             var data1 = new ArraySegment<byte>(new byte[] { 11 });
             m_Client1.Send(m_Client1.ServerClientId, data1, delivery);
@@ -232,7 +240,11 @@ public IEnumerator SendMultipleClients([ValueSource("k_DeliveryParameters")] Net
             m_Client1.StartClient();
             m_Client2.StartClient();
 
-            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ServerEvents);
+            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
+            if (m_Client2Events.Count == 0)
+            {
+                yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client2Events);
+            }
 
             // Ensure we got both Connect events.
             Assert.AreEqual(2, m_ServerEvents.Count);
@@ -252,7 +264,7 @@ public IEnumerator SendMultipleClients([ValueSource("k_DeliveryParameters")] Net
 
             byte c1Data = m_Client1Events[1].Data.First();
             byte c2Data = m_Client2Events[1].Data.First();
-            Assert.True((c1Data == 11 && c2Data == 22) || (c1Data == 22 && c2Data == 11));
+            Assert.That((c1Data == 11 && c2Data == 22) || (c1Data == 22 && c2Data == 11));
 
             yield return null;
         }
@@ -270,9 +282,10 @@ public IEnumerator ReceiveMultipleClients([ValueSource("k_DeliveryParameters")]
             m_Client2.StartClient();
 
             yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
-
-            // Ensure we got the Connect event on the other client too.
-            Assert.AreEqual(1, m_Client2Events.Count);
+            if (m_Client2Events.Count == 0)
+            {
+                yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client2Events);
+            }
 
             var data1 = new ArraySegment<byte>(new byte[] { 11 });
             m_Client1.Send(m_Client1.ServerClientId, data1, delivery);
@@ -288,9 +301,10 @@ public IEnumerator ReceiveMultipleClients([ValueSource("k_DeliveryParameters")]
 
             byte sData1 = m_ServerEvents[2].Data.First();
             byte sData2 = m_ServerEvents[3].Data.First();
-            Assert.True((sData1 == 11 && sData2 == 22) || (sData1 == 22 && sData2 == 11));
+            Assert.That((sData1 == 11 && sData2 == 22) || (sData1 == 22 && sData2 == 11));
 
             yield return null;
         }
     }
 }
+#endif
@@ -36,7 +36,7 @@ public void Serialize(FastBufferWriter writer)
                     // This var does not belong to the currently iterating delivery group.
                     if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                     {
-                        writer.WriteValueSafe((short)0);
+                        writer.WriteValueSafe((ushort)0);
                     }
                     else
                     {
@@ -69,7 +69,12 @@ public void Serialize(FastBufferWriter writer)
                         var tmpWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, short.MaxValue);
                         NetworkBehaviour.NetworkVariableFields[k].WriteDelta(tmpWriter);
 
-                        writer.WriteValueSafe((ushort)tmpWriter.Length);
+                        if (!writer.TryBeginWrite(FastBufferWriter.GetWriteSize<ushort>() + tmpWriter.Length))
+                        {
+                            throw new OverflowException($"Not enough space in the buffer to write {nameof(NetworkVariableDeltaMessage)}");
+                        }
+
+                        writer.WriteValue((ushort)tmpWriter.Length);
                         tmpWriter.CopyTo(writer);
                     }
                     else
Original file line number	Diff line number	Diff line change
`@@ -1,34 +1,38 @@`
`1`	`1`	`using NUnit.Framework;`
`2`	`2`	`using System;`
`3`		`-using System.Linq;`
`4`	`3`	`using System.Collections;`
`5`	`4`	`using System.Collections.Generic;`
`6`	`5`	`using UnityEngine;`
`7`		`-`
`8`	`6`	`namespace Unity.Netcode.UTP.RuntimeTests`
`9`	`7`	`{`
`10`	`8`	`public static class RuntimeTestsHelpers`
`11`	`9`	`{`
`12`	`10`	`// Half a second might seem like a very long time to wait for a network event, but in CI`
`13`	`11`	`// many of the machines are underpowered (e.g. old Android devices or Macs) and there are`
`14`		`- // sometimes lag spikes that cause can cause delays upwards of 300ms.`
	`12`	`+ // sometimes very high lag spikes. PS4 and Switch are particularly sensitive in this regard`
	`13`	`+ // so we allow even more time for these platforms.`
	`14`	`+#if UNITY_PS4 \|\| UNITY_SWITCH`
	`15`	`+ public const float MaxNetworkEventWaitTime = 2.0f;`
	`16`	`+#else`
`15`	`17`	`public const float MaxNetworkEventWaitTime = 0.5f;`
	`18`	`+#endif`
`16`	`19`
`17`	`20`	`// Wait for an event to appear in the given event list (must be the very next event).`
`18`		`- public static IEnumerator WaitForNetworkEvent(NetworkEvent type, List<TransportEvent> events)`
	`21`	`+ public static IEnumerator WaitForNetworkEvent(NetworkEvent type, List<TransportEvent> events,`
	`22`	`+ float timeout = MaxNetworkEventWaitTime)`
`19`	`23`	`{`
`20`	`24`	`int initialCount = events.Count;`
`21`	`25`	`float startTime = Time.realtimeSinceStartup;`
`22`	`26`
`23`		`- while (Time.realtimeSinceStartup - startTime < MaxNetworkEventWaitTime)`
	`27`	`+ while (Time.realtimeSinceStartup - startTime < timeout)`
`24`	`28`	`{`
`25`	`29`	`if (events.Count > initialCount)`
`26`	`30`	`{`
`27`	`31`	`Assert.AreEqual(type, events[initialCount].Type);`
`28`	`32`	`yield break;`
`29`	`33`	`}`
`30`	`34`
`31`		`- yield return null;`
	`35`	`+ yield return new WaitForSeconds(0.01f);`
`32`	`36`	`}`
`33`	`37`
`34`	`38`	`Assert.Fail("Timed out while waiting for network event.");`
`@@ -56,23 +60,22 @@ public struct TransportEvent`
`56`	`60`	`public ArraySegment<byte> Data;`
`57`	`61`	`public float ReceiveTime;`
`58`	`62`	`}`
`59`		`-`
`60`	`63`	`// Utility class that logs events generated by a UnityTransport. Set it up by adding the`
`61`	`64`	`// HandleEvent method as an OnTransportEvent delegate of the transport. The list of events`
`62`	`65`	`// (in order in which they were generated) can be accessed through the Events property.`
`63`	`66`	`public class TransportEventLogger`
`64`	`67`	`{`
`65`	`68`	`private readonly List<TransportEvent> m_Events = new List<TransportEvent>();`
`66`	`69`	`public List<TransportEvent> Events => m_Events;`
`67`		`-`
`68`	`70`	`public void HandleEvent(NetworkEvent type, ulong clientID, ArraySegment<byte> data, float receiveTime)`
`69`	`71`	`{`
`70`	`72`	`// Copy the data since the backing array will be reused for future messages.`
`71`	`73`	`if (data != default(ArraySegment<byte>))`
`72`	`74`	`{`
`73`		`- data = new ArraySegment<byte>(data.ToArray());`
	`75`	`+ var dataCopy = new byte[data.Count];`
	`76`	`+ Array.Copy(data.Array, data.Offset, dataCopy, 0, data.Count);`
	`77`	`+ data = new ArraySegment<byte>(dataCopy);`
`74`	`78`	`}`
`75`		`-`
`76`	`79`	`m_Events.Add(new TransportEvent`
`77`	`80`	`{`
`78`	`81`	`Type = type,`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public void Serialize(FastBufferWriter writer)`
`36`	`36`	`// This var does not belong to the currently iterating delivery group.`
`37`	`37`	`if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)`
`38`	`38`	`{`
`39`		`- writer.WriteValueSafe((short)0);`
	`39`	`+ writer.WriteValueSafe((ushort)0);`
`40`	`40`	`}`
`41`	`41`	`else`
`42`	`42`	`{`
`@@ -69,7 +69,12 @@ public void Serialize(FastBufferWriter writer)`
`69`	`69`	`var tmpWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, short.MaxValue);`
`70`	`70`	`NetworkBehaviour.NetworkVariableFields[k].WriteDelta(tmpWriter);`
`71`	`71`
`72`		`- writer.WriteValueSafe((ushort)tmpWriter.Length);`
	`72`	`+ if (!writer.TryBeginWrite(FastBufferWriter.GetWriteSize<ushort>() + tmpWriter.Length))`
	`73`	`+ {`
	`74`	`+ throw new OverflowException($"Not enough space in the buffer to write {nameof(NetworkVariableDeltaMessage)}");`
	`75`	`+ }`
	`76`	`+`
	`77`	`+ writer.WriteValue((ushort)tmpWriter.Length);`
`73`	`78`	`tmpWriter.CopyTo(writer);`
`74`	`79`	`}`
`75`	`80`	`else`