test - update

Fixing an issue with `ClientDisconnectMultipleClients` beginning to disconnect clients before they were connected.
Added `UnityTransportTestHelpers.WaitForMultipleNetworkEvents` helper method to wait for a specific number of events of a specified type.
Added a `UnityTransportTestHelpers.VerboseDebug` helper method.

Author: NoelStephensUnity

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

@@ -22,6 +22,7 @@ internal class UnityTransportConnectionTests
         [UnityTearDown]
         public IEnumerator Cleanup()
         {
+            LogEventsReceived = false;
             if (m_Server)
             {
                 m_Server.Shutdown();
@@ -198,26 +199,32 @@ public IEnumerator ClientDisconnectSingleClient()
         [UnityTest]
         public IEnumerator ClientDisconnectMultipleClients()
         {
-            InitializeTransport(out m_Server, out m_ServerEvents);
-            m_Server.StartServer();
+            LogEventsReceived = true;
+            InitializeTransport(out m_Server, out m_ServerEvents, identifier: "Server");
+            Assert.True(m_Server.StartServer(), "Failed to start server!");
+
             for (int i = 0; i < k_NumClients; i++)
             {
-                InitializeTransport(out m_Clients[i], out m_ClientsEvents[i]);
-                m_Clients[i].StartClient();
+                InitializeTransport(out m_Clients[i], out m_ClientsEvents[i], identifier: $"Client-{i + 1}");
+                Assert.True(m_Clients[i].StartClient(), $"Failed to start client-{i + 1}");
+                // Assure all clients have connected before disconnecting them
+                yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ClientsEvents[i], 5);
             }
-            yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ClientsEvents[k_NumClients - 1]);
 
             // Disconnect a single client.
+            VerboseLog($"Disconnecting Client-1");
             m_Clients[0].DisconnectLocalClient();
 
-            yield return WaitForNetworkEvent(NetworkEvent.Disconnect, m_ServerEvents);
+            yield return WaitForNetworkEvent(NetworkEvent.Disconnect, m_ServerEvents, 1);
 
             // Disconnect all the other clients.
             for (int i = 1; i < k_NumClients; i++)
             {
+                VerboseLog($"Disconnecting Client-{i + 1}");
                 m_Clients[i].DisconnectLocalClient();
             }
-            yield return WaitForNetworkEvent(NetworkEvent.Disconnect, m_ServerEvents, 5);
+
+            yield return WaitForMultipleNetworkEvents(NetworkEvent.Disconnect, m_ServerEvents, 4, 20);
 
             // Check that we got the correct number of Disconnect events on the server.
             Assert.AreEqual(k_NumClients * 2, m_ServerEvents.Count);

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

@@ -19,21 +19,63 @@ internal static class UnityTransportTestHelpers
         // 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, float timeout = MaxNetworkEventWaitTime)
         {
-            int initialCount = events.Count;
-            float startTime = Time.realtimeSinceStartup;
-
-            while (Time.realtimeSinceStartup - startTime < timeout)
+            var initialCount = events.Count;
+            var startTime = Time.realtimeSinceStartup + timeout;
+            var waitPeriod = new WaitForSeconds(0.01f);
+            var conditionMet = false;
+            while (startTime > Time.realtimeSinceStartup)
             {
                 if (events.Count > initialCount)
                 {
                     Assert.AreEqual(type, events[initialCount].Type);
-                    yield break;
+                    conditionMet = true;
+                    break;
                 }
 
-                yield return new WaitForSeconds(0.01f);
+                yield return waitPeriod;
+            }
+            if (!conditionMet)
+            {
+                Assert.Fail("Timed out while waiting for network event.");
             }
+        }
+
+        public static IEnumerator WaitForMultipleNetworkEvents(NetworkEvent type, List<TransportEvent> events, int count, float timeout = MaxNetworkEventWaitTime)
+        {
+            var initialCount = events.Count;
+            var startTime = Time.realtimeSinceStartup + timeout;
+            var waitPeriod = new WaitForSeconds(0.01f);
+            var conditionMet = false;
+            while (startTime > Time.realtimeSinceStartup)
+            {
+                // Wait until we have received at least (count) number of events
+                if ((events.Count - initialCount) >= count)
+                {
+                    var foundTypes = 0;
+                    // Look through all events received to match against the type we
+                    // are looking for.
+                    for (int i = initialCount; i < initialCount + count; i++)
+                    {
+                        if (type.Equals(events[i].Type))
+                        {
+                            foundTypes++;
+                        }
+                    }
+                    // If we reached the number of events we were expecting
+                    conditionMet = foundTypes == count;
+                    if (conditionMet)
+                    {
+                        // break from the wait loop
+                        break;
+                    }
+                }
 
-            Assert.Fail("Timed out while waiting for network event.");
+                yield return waitPeriod;
+            }
+            if (!conditionMet)
+            {
+                Assert.Fail("Timed out while waiting for network event.");
+            }
         }
 
         // Wait to ensure no event is sent.
@@ -53,12 +95,14 @@ public static IEnumerator EnsureNoNetworkEvent(List<TransportEvent> events, floa
             }
         }
 
-
         // Common code to initialize a UnityTransport that logs its events.
         public static void InitializeTransport(out UnityTransport transport, out List<TransportEvent> events,
-            int maxPayloadSize = UnityTransport.InitialMaxPayloadSize, int maxSendQueueSize = 0, NetworkFamily family = NetworkFamily.Ipv4)
+            int maxPayloadSize = UnityTransport.InitialMaxPayloadSize, int maxSendQueueSize = 0, NetworkFamily family = NetworkFamily.Ipv4, string identifier = "")
         {
-            var logger = new TransportEventLogger();
+            var logger = new TransportEventLogger()
+            {
+                Identifier = identifier,
+            };
             events = logger.Events;
 
             transport = new GameObject().AddComponent<UnityTransportTestComponent>();
@@ -75,6 +119,16 @@ public static void InitializeTransport(out UnityTransport transport, out List<Tr
             transport.Initialize();
         }
 
+        public static bool LogEventsReceived = false;
+
+        public static void VerboseLog(string msg)
+        {
+            if (LogEventsReceived)
+            {
+                Debug.Log($"{msg}");
+            }
+        }
+
         // Information about an event generated by a transport (basically just the parameters that
         // are normally passed along to a TransportEventDelegate).
         internal struct TransportEvent
@@ -91,8 +145,15 @@ internal class TransportEventLogger
         {
             private readonly List<TransportEvent> m_Events = new List<TransportEvent>();
             public List<TransportEvent> Events => m_Events;
+
+            public string Identifier;
             public void HandleEvent(NetworkEvent type, ulong clientID, ArraySegment<byte> data, float receiveTime)
             {
+                if (LogEventsReceived)
+                {
+                    VerboseLog($"[{Identifier}]Tansport Event][{type}][{receiveTime}] Client-{clientID}");
+                }
+
                 // Copy the data since the backing array will be reused for future messages.
                 if (data != default(ArraySegment<byte>))
                 {