refactor: FindObjectsByType instead of FindObjectsOfType for 2023.1+ (#2478)

0xFA11 · web-flow · commit e4d628eab817 · 2023-03-27T19:22:09.000Z
diff --git a/com.unity.netcode.gameobjects/TestHelpers/Runtime/NetcodeIntegrationTest.cs b/com.unity.netcode.gameobjects/TestHelpers/Runtime/NetcodeIntegrationTest.cs
@@ -24,6 +24,7 @@ public abstract class NetcodeIntegrationTest
         /// determine how clients will load scenes
         /// </summary>
         internal static bool IsRunning { get; private set; }
+
         protected static TimeoutHelper s_GlobalTimeoutHelper = new TimeoutHelper(8.0f);
         protected static WaitForSecondsRealtime s_DefaultWaitForTick = new WaitForSecondsRealtime(1.0f / k_DefaultTickRate);
 
@@ -46,6 +47,7 @@ public static void RegisterNetworkObject(NetworkObject networkObject)
             {
                 s_GlobalNetworkObjects.Add(networkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
             }
+
             if (s_GlobalNetworkObjects[networkObject.NetworkManager.LocalClientId].ContainsKey(networkObject.NetworkObjectId))
             {
                 if (s_GlobalNetworkObjects[networkObject.NetworkManager.LocalClientId] == null)
@@ -102,9 +104,9 @@ public static void DeregisterNetworkObject(ulong localClientId, ulong networkObj
 
         public enum NetworkManagerInstatiationMode
         {
-            PerTest,        // This will create and destroy new NetworkManagers for each test within a child derived class
-            AllTests,       // This will create one set of NetworkManagers used for all tests within a child derived class (destroyed once all tests are finished)
-            DoNotCreate     // This will not create any NetworkManagers, it is up to the derived class to manage.
+            PerTest, // This will create and destroy new NetworkManagers for each test within a child derived class
+            AllTests, // This will create one set of NetworkManagers used for all tests within a child derived class (destroyed once all tests are finished)
+            DoNotCreate // This will not create any NetworkManagers, it is up to the derived class to manage.
         }
 
         public enum HostOrServer
@@ -286,6 +288,7 @@ protected virtual IEnumerator OnSetup()
         {
             yield return null;
         }
+
         /// <summary>
         /// Called before creating and starting the server and clients
         /// Note: For <see cref="NetworkManagerInstatiationMode.AllTests"/> and
@@ -333,6 +336,7 @@ public IEnumerator SetUp()
                     yield return StartServerAndClients();
                 }
             }
+
             VerboseDebug($"Exiting {nameof(SetUp)}");
         }
 
@@ -397,6 +401,7 @@ private void AddRemoveNetworkManager(NetworkManager networkManager, bool addNetw
             {
                 clientNetworkManagersList.Remove(networkManager);
             }
+
             m_ClientNetworkManagers = clientNetworkManagersList.ToArray();
             m_NumberOfClients = clientNetworkManagersList.Count;
         }
@@ -407,7 +412,6 @@ private void AddRemoveNetworkManager(NetworkManager networkManager, bool addNetw
         /// </summary>
         protected virtual void OnNewClientCreated(NetworkManager networkManager)
         {
-
         }
 
         /// <summary>
@@ -425,7 +429,6 @@ protected virtual void OnNewClientStarted(NetworkManager networkManager)
         /// </summary>
         protected virtual void OnNewClientStartedAndConnected(NetworkManager networkManager)
         {
-
         }
 
         /// <summary>
@@ -461,6 +464,7 @@ protected IEnumerator CreateAndStartNewClient()
                 AddRemoveNetworkManager(networkManager, false);
                 Object.DestroyImmediate(networkManager.gameObject);
             }
+
             AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!");
             ClientNetworkManagerPostStart(networkManager);
             VerboseDebug($"[{networkManager.name}] Created and connected!");
@@ -499,6 +503,7 @@ protected void CreateAndStartNewClientWithTimeTravel()
                 AddRemoveNetworkManager(networkManager, false);
                 Object.DestroyImmediate(networkManager.gameObject);
             }
+
             Assert.IsTrue(connected, $"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!");
             ClientNetworkManagerPostStart(networkManager);
             VerboseDebug($"[{networkManager.name}] Created and connected!");
@@ -638,6 +643,7 @@ private void ClientNetworkManagerPostStart(NetworkManager networkManager)
                 {
                     m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
                 }
+
                 if (!m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].ContainsKey(networkManager.LocalClientId))
                 {
                     m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(networkManager.LocalClientId, playerNetworkObject);
@@ -667,6 +673,7 @@ protected void ClientNetworkManagerPostStartInit()
             {
                 ClientNetworkManagerPostStart(networkManager);
             }
+
             if (m_UseHost)
             {
 #if UNITY_2023_1_OR_NEWER
@@ -681,6 +688,7 @@ protected void ClientNetworkManagerPostStartInit()
                     {
                         m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
                     }
+
                     if (!m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].ContainsKey(m_ServerNetworkManager.LocalClientId))
                     {
                         m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);
@@ -742,6 +750,7 @@ protected IEnumerator StartServerAndClients()
                             {
                                 m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
                             }
+
                             m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);
                         }
                     }
@@ -808,6 +817,7 @@ protected void StartServerAndClientsWithTimeTravel()
                             {
                                 m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
                             }
+
                             m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);
                         }
                     }
@@ -898,7 +908,10 @@ protected void ShutdownAndCleanUp()
                 m_PlayerNetworkObjects.Clear();
                 s_GlobalNetworkObjects.Clear();
             }
-            catch (Exception e) { throw e; }
+            catch (Exception e)
+            {
+                throw e;
+            }
             finally
             {
                 if (m_PlayerPrefab != null)
@@ -1028,6 +1041,7 @@ protected void DestroySceneNetworkObjects()
                 {
                     continue;
                 }
+
                 if (CanDestroyNetworkObject(networkObject))
                 {
                     networkObject.NetworkManagerOwner = m_ServerNetworkManager;
@@ -1086,6 +1100,7 @@ public static IEnumerator WaitForConditionOrTimeOut(Func<bool> checkForCondition
                 // Otherwise wait for 1 tick interval
                 yield return s_DefaultWaitForTick;
             }
+
             // Stop checking for a timeout
             timeOutHelper.Stop();
         }
@@ -1124,6 +1139,7 @@ public bool WaitForConditionOrTimeOutWithTimeTravel(Func<bool> checkForCondition
                     return true;
                 }
             }
+
             return false;
         }
 
@@ -1200,7 +1216,7 @@ protected bool WaitForClientsConnectedOrTimeOutWithTimeTravel(NetworkManager[] c
             var serverClientCount = m_ServerNetworkManager.IsHost ? remoteClientCount + 1 : remoteClientCount;
 
             return WaitForConditionOrTimeOutWithTimeTravel(() => clientsToCheck.Where((c) => c.IsConnectedClient).Count() == remoteClientCount &&
-                                                         m_ServerNetworkManager.ConnectedClients.Count == serverClientCount);
+                                                                 m_ServerNetworkManager.ConnectedClients.Count == serverClientCount);
         }
 
         /// <summary>
@@ -1232,6 +1248,7 @@ internal IEnumerator WaitForMessageReceived<T>(List<NetworkManager> wiatForRecei
                 messageHook.AssignMessageType<T>();
                 messageHookEntriesForSpawn.Add(messageHook);
             }
+
             // Used to determine if all clients received the CreateObjectMessage
             var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
             yield return WaitForConditionOrTimeOut(hooks);
@@ -1251,6 +1268,7 @@ internal IEnumerator WaitForMessagesReceived(List<Type> messagesInOrder, List<Ne
                     messageHookEntriesForSpawn.Add(messageHook);
                 }
             }
+
             // Used to determine if all clients received the CreateObjectMessage
             var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
             yield return WaitForConditionOrTimeOut(hooks);
@@ -1268,6 +1286,7 @@ internal void WaitForMessageReceivedWithTimeTravel<T>(List<NetworkManager> waitF
                 messageHook.AssignMessageType<T>();
                 messageHookEntriesForSpawn.Add(messageHook);
             }
+
             // Used to determine if all clients received the CreateObjectMessage
             var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
             Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks));
@@ -1286,6 +1305,7 @@ internal void WaitForMessagesReceivedWithTimeTravel(List<Type> messagesInOrder,
                     messageHookEntriesForSpawn.Add(messageHook);
                 }
             }
+
             // Used to determine if all clients received the CreateObjectMessage
             var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
             Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks));
@@ -1301,7 +1321,7 @@ internal void WaitForMessagesReceivedWithTimeTravel(List<Type> messagesInOrder,
         protected GameObject CreateNetworkObjectPrefab(string baseName)
         {
             var prefabCreateAssertError = $"You can only invoke this method during {nameof(OnServerAndClientsCreated)} " +
-                $"but before {nameof(OnStartedServerAndClients)}!";
+                                          $"but before {nameof(OnStartedServerAndClients)}!";
             Assert.IsNotNull(m_ServerNetworkManager, prefabCreateAssertError);
             Assert.IsFalse(m_ServerNetworkManager.IsListening, prefabCreateAssertError);
 
@@ -1375,6 +1395,7 @@ private List<GameObject> SpawnObjects(NetworkObject prefabNetworkObject, Network
             {
                 gameObjectsSpawned.Add(SpawnObject(prefabNetworkObject, owner, destroyWithScene));
             }
+
             return gameObjectsSpawned;
         }
 
@@ -1383,7 +1404,6 @@ private List<GameObject> SpawnObjects(NetworkObject prefabNetworkObject, Network
         /// </summary>
         public NetcodeIntegrationTest()
         {
-
         }
 
         /// <summary>
@@ -1429,6 +1449,7 @@ private void UnloadRemainingScenes()
                 {
                     continue;
                 }
+
                 VerboseDebug($"Unloading scene {scene.name}-{scene.handle}");
                 var asyncOperation = SceneManager.UnloadSceneAsync(scene);
             }
@@ -1468,6 +1489,7 @@ private IEnumerator WaitForTickAndFrames(NetworkManager networkManager, int tick
                     }
                 }
             }
+
             m_WaitForLog.Append($"[NetworkManager-{networkManager.LocalClientId}][WaitForTicks-End] Waited for ({networkManager.NetworkTickSystem.LocalTime.Tick - tickStart}) network ticks and ({frameCount}) frames to pass.\n");
             yield break;
         }
@@ -1534,31 +1556,34 @@ public static void SimulateOneFrame()
             foreach (NetworkUpdateStage stage in Enum.GetValues(typeof(NetworkUpdateStage)))
             {
                 NetworkUpdateLoop.RunNetworkUpdateStage(stage);
-                var methodName = "";
+                string methodName = string.Empty;
                 switch (stage)
                 {
                     case NetworkUpdateStage.FixedUpdate:
-                        methodName = "FixedUpdate";
+                        methodName = "FixedUpdate"; // mapping NetworkUpdateStage.FixedUpdate to MonoBehaviour.FixedUpdate
                         break;
                     case NetworkUpdateStage.Update:
-                        methodName = "Update";
+                        methodName = "Update"; // mapping NetworkUpdateStage.Update to MonoBehaviour.Update
                         break;
                     case NetworkUpdateStage.PreLateUpdate:
-                        methodName = "LateUpdate";
+                        methodName = "LateUpdate"; // mapping NetworkUpdateStage.PreLateUpdate to MonoBehaviour.LateUpdate
                         break;
-
                 }
 
-
-                if (methodName != "")
+                if (!string.IsNullOrEmpty(methodName))
                 {
+#if UNITY_2023_1_OR_NEWER
+                    foreach (var behaviour in Object.FindObjectsByType<NetworkBehaviour>(FindObjectsSortMode.InstanceID))
+#else
                     foreach (var behaviour in Object.FindObjectsOfType<NetworkBehaviour>())
+#endif
                     {
                         var method = behaviour.GetType().GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
                         if (method == null)
                         {
                             method = behaviour.GetType().GetMethod(methodName, BindingFlags.Public | BindingFlags.Instance);
                         }
+
                         method?.Invoke(behaviour, new object[] { });
                     }
                 }

Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@ public abstract class NetcodeIntegrationTest`
`24`	`24`	`/// determine how clients will load scenes`
`25`	`25`	`/// </summary>`
`26`	`26`	`internal static bool IsRunning { get; private set; }`
	`27`	`+`
`27`	`28`	`protected static TimeoutHelper s_GlobalTimeoutHelper = new TimeoutHelper(8.0f);`
`28`	`29`	`protected static WaitForSecondsRealtime s_DefaultWaitForTick = new WaitForSecondsRealtime(1.0f / k_DefaultTickRate);`
`29`	`30`
`@@ -46,6 +47,7 @@ public static void RegisterNetworkObject(NetworkObject networkObject)`
`46`	`47`	`{`
`47`	`48`	`s_GlobalNetworkObjects.Add(networkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());`
`48`	`49`	`}`
	`50`	`+`
`49`	`51`	`if (s_GlobalNetworkObjects[networkObject.NetworkManager.LocalClientId].ContainsKey(networkObject.NetworkObjectId))`
`50`	`52`	`{`
`51`	`53`	`if (s_GlobalNetworkObjects[networkObject.NetworkManager.LocalClientId] == null)`
`@@ -102,9 +104,9 @@ public static void DeregisterNetworkObject(ulong localClientId, ulong networkObj`
`102`	`104`
`103`	`105`	`public enum NetworkManagerInstatiationMode`
`104`	`106`	`{`
`105`		`- PerTest, // This will create and destroy new NetworkManagers for each test within a child derived class`
`106`		`- AllTests, // This will create one set of NetworkManagers used for all tests within a child derived class (destroyed once all tests are finished)`
`107`		`- DoNotCreate // This will not create any NetworkManagers, it is up to the derived class to manage.`
	`107`	`+ PerTest, // This will create and destroy new NetworkManagers for each test within a child derived class`
	`108`	`+ AllTests, // This will create one set of NetworkManagers used for all tests within a child derived class (destroyed once all tests are finished)`
	`109`	`+ DoNotCreate // This will not create any NetworkManagers, it is up to the derived class to manage.`
`108`	`110`	`}`
`109`	`111`
`110`	`112`	`public enum HostOrServer`
`@@ -286,6 +288,7 @@ protected virtual IEnumerator OnSetup()`
`286`	`288`	`{`
`287`	`289`	`yield return null;`
`288`	`290`	`}`
	`291`	`+`
`289`	`292`	`/// <summary>`
`290`	`293`	`/// Called before creating and starting the server and clients`
`291`	`294`	`/// Note: For <see cref="NetworkManagerInstatiationMode.AllTests"/> and`
`@@ -333,6 +336,7 @@ public IEnumerator SetUp()`
`333`	`336`	`yield return StartServerAndClients();`
`334`	`337`	`}`
`335`	`338`	`}`
	`339`	`+`
`336`	`340`	`VerboseDebug($"Exiting {nameof(SetUp)}");`
`337`	`341`	`}`
`338`	`342`
`@@ -397,6 +401,7 @@ private void AddRemoveNetworkManager(NetworkManager networkManager, bool addNetw`
`397`	`401`	`{`
`398`	`402`	`clientNetworkManagersList.Remove(networkManager);`
`399`	`403`	`}`
	`404`	`+`
`400`	`405`	`m_ClientNetworkManagers = clientNetworkManagersList.ToArray();`
`401`	`406`	`m_NumberOfClients = clientNetworkManagersList.Count;`
`402`	`407`	`}`
`@@ -407,7 +412,6 @@ private void AddRemoveNetworkManager(NetworkManager networkManager, bool addNetw`
`407`	`412`	`/// </summary>`
`408`	`413`	`protected virtual void OnNewClientCreated(NetworkManager networkManager)`
`409`	`414`	`{`
`410`		`-`
`411`	`415`	`}`
`412`	`416`
`413`	`417`	`/// <summary>`
`@@ -425,7 +429,6 @@ protected virtual void OnNewClientStarted(NetworkManager networkManager)`
`425`	`429`	`/// </summary>`
`426`	`430`	`protected virtual void OnNewClientStartedAndConnected(NetworkManager networkManager)`
`427`	`431`	`{`
`428`		`-`
`429`	`432`	`}`
`430`	`433`
`431`	`434`	`/// <summary>`
`@@ -461,6 +464,7 @@ protected IEnumerator CreateAndStartNewClient()`
`461`	`464`	`AddRemoveNetworkManager(networkManager, false);`
`462`	`465`	`Object.DestroyImmediate(networkManager.gameObject);`
`463`	`466`	`}`
	`467`	`+`
`464`	`468`	`AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!");`
`465`	`469`	`ClientNetworkManagerPostStart(networkManager);`
`466`	`470`	`VerboseDebug($"[{networkManager.name}] Created and connected!");`
`@@ -499,6 +503,7 @@ protected void CreateAndStartNewClientWithTimeTravel()`
`499`	`503`	`AddRemoveNetworkManager(networkManager, false);`
`500`	`504`	`Object.DestroyImmediate(networkManager.gameObject);`
`501`	`505`	`}`
	`506`	`+`
`502`	`507`	`Assert.IsTrue(connected, $"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!");`
`503`	`508`	`ClientNetworkManagerPostStart(networkManager);`
`504`	`509`	`VerboseDebug($"[{networkManager.name}] Created and connected!");`
`@@ -638,6 +643,7 @@ private void ClientNetworkManagerPostStart(NetworkManager networkManager)`
`638`	`643`	`{`
`639`	`644`	`m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());`
`640`	`645`	`}`
	`646`	`+`
`641`	`647`	`if (!m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].ContainsKey(networkManager.LocalClientId))`
`642`	`648`	`{`
`643`	`649`	`m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(networkManager.LocalClientId, playerNetworkObject);`
`@@ -667,6 +673,7 @@ protected void ClientNetworkManagerPostStartInit()`
`667`	`673`	`{`
`668`	`674`	`ClientNetworkManagerPostStart(networkManager);`
`669`	`675`	`}`
	`676`	`+`
`670`	`677`	`if (m_UseHost)`
`671`	`678`	`{`
`672`	`679`	`#if UNITY_2023_1_OR_NEWER`
`@@ -681,6 +688,7 @@ protected void ClientNetworkManagerPostStartInit()`
`681`	`688`	`{`
`682`	`689`	`m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());`
`683`	`690`	`}`
	`691`	`+`
`684`	`692`	`if (!m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].ContainsKey(m_ServerNetworkManager.LocalClientId))`
`685`	`693`	`{`
`686`	`694`	`m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);`
`@@ -742,6 +750,7 @@ protected IEnumerator StartServerAndClients()`
`742`	`750`	`{`
`743`	`751`	`m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());`
`744`	`752`	`}`
	`753`	`+`
`745`	`754`	`m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);`
`746`	`755`	`}`
`747`	`756`	`}`
`@@ -808,6 +817,7 @@ protected void StartServerAndClientsWithTimeTravel()`
`808`	`817`	`{`
`809`	`818`	`m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());`
`810`	`819`	`}`
	`820`	`+`
`811`	`821`	`m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);`
`812`	`822`	`}`
`813`	`823`	`}`
`@@ -898,7 +908,10 @@ protected void ShutdownAndCleanUp()`
`898`	`908`	`m_PlayerNetworkObjects.Clear();`
`899`	`909`	`s_GlobalNetworkObjects.Clear();`
`900`	`910`	`}`
`901`		`- catch (Exception e) { throw e; }`
	`911`	`+ catch (Exception e)`
	`912`	`+ {`
	`913`	`+ throw e;`
	`914`	`+ }`
`902`	`915`	`finally`
`903`	`916`	`{`
`904`	`917`	`if (m_PlayerPrefab != null)`
`@@ -1028,6 +1041,7 @@ protected void DestroySceneNetworkObjects()`
`1028`	`1041`	`{`
`1029`	`1042`	`continue;`
`1030`	`1043`	`}`
	`1044`	`+`
`1031`	`1045`	`if (CanDestroyNetworkObject(networkObject))`
`1032`	`1046`	`{`
`1033`	`1047`	`networkObject.NetworkManagerOwner = m_ServerNetworkManager;`
`@@ -1086,6 +1100,7 @@ public static IEnumerator WaitForConditionOrTimeOut(Func<bool> checkForCondition`
`1086`	`1100`	`// Otherwise wait for 1 tick interval`
`1087`	`1101`	`yield return s_DefaultWaitForTick;`
`1088`	`1102`	`}`
	`1103`	`+`
`1089`	`1104`	`// Stop checking for a timeout`
`1090`	`1105`	`timeOutHelper.Stop();`
`1091`	`1106`	`}`
`@@ -1124,6 +1139,7 @@ public bool WaitForConditionOrTimeOutWithTimeTravel(Func<bool> checkForCondition`
`1124`	`1139`	`return true;`
`1125`	`1140`	`}`
`1126`	`1141`	`}`
	`1142`	`+`
`1127`	`1143`	`return false;`
`1128`	`1144`	`}`
`1129`	`1145`
`@@ -1200,7 +1216,7 @@ protected bool WaitForClientsConnectedOrTimeOutWithTimeTravel(NetworkManager[] c`
`1200`	`1216`	`var serverClientCount = m_ServerNetworkManager.IsHost ? remoteClientCount + 1 : remoteClientCount;`
`1201`	`1217`
`1202`	`1218`	`return WaitForConditionOrTimeOutWithTimeTravel(() => clientsToCheck.Where((c) => c.IsConnectedClient).Count() == remoteClientCount &&`
`1203`		`- m_ServerNetworkManager.ConnectedClients.Count == serverClientCount);`
	`1219`	`+ m_ServerNetworkManager.ConnectedClients.Count == serverClientCount);`
`1204`	`1220`	`}`
`1205`	`1221`
`1206`	`1222`	`/// <summary>`
`@@ -1232,6 +1248,7 @@ internal IEnumerator WaitForMessageReceived<T>(List<NetworkManager> wiatForRecei`
`1232`	`1248`	`messageHook.AssignMessageType<T>();`
`1233`	`1249`	`messageHookEntriesForSpawn.Add(messageHook);`
`1234`	`1250`	`}`
	`1251`	`+`
`1235`	`1252`	`// Used to determine if all clients received the CreateObjectMessage`
`1236`	`1253`	`var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);`
`1237`	`1254`	`yield return WaitForConditionOrTimeOut(hooks);`
`@@ -1251,6 +1268,7 @@ internal IEnumerator WaitForMessagesReceived(List<Type> messagesInOrder, List<Ne`
`1251`	`1268`	`messageHookEntriesForSpawn.Add(messageHook);`
`1252`	`1269`	`}`
`1253`	`1270`	`}`
	`1271`	`+`
`1254`	`1272`	`// Used to determine if all clients received the CreateObjectMessage`
`1255`	`1273`	`var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);`
`1256`	`1274`	`yield return WaitForConditionOrTimeOut(hooks);`
`@@ -1268,6 +1286,7 @@ internal void WaitForMessageReceivedWithTimeTravel<T>(List<NetworkManager> waitF`
`1268`	`1286`	`messageHook.AssignMessageType<T>();`
`1269`	`1287`	`messageHookEntriesForSpawn.Add(messageHook);`
`1270`	`1288`	`}`
	`1289`	`+`
`1271`	`1290`	`// Used to determine if all clients received the CreateObjectMessage`
`1272`	`1291`	`var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);`
`1273`	`1292`	`Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks));`
`@@ -1286,6 +1305,7 @@ internal void WaitForMessagesReceivedWithTimeTravel(List<Type> messagesInOrder,`
`1286`	`1305`	`messageHookEntriesForSpawn.Add(messageHook);`
`1287`	`1306`	`}`
`1288`	`1307`	`}`
	`1308`	`+`
`1289`	`1309`	`// Used to determine if all clients received the CreateObjectMessage`
`1290`	`1310`	`var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);`
`1291`	`1311`	`Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks));`
`@@ -1301,7 +1321,7 @@ internal void WaitForMessagesReceivedWithTimeTravel(List<Type> messagesInOrder,`
`1301`	`1321`	`protected GameObject CreateNetworkObjectPrefab(string baseName)`
`1302`	`1322`	`{`
`1303`	`1323`	`var prefabCreateAssertError = $"You can only invoke this method during {nameof(OnServerAndClientsCreated)} " +`
`1304`		`- $"but before {nameof(OnStartedServerAndClients)}!";`
	`1324`	`+ $"but before {nameof(OnStartedServerAndClients)}!";`
`1305`	`1325`	`Assert.IsNotNull(m_ServerNetworkManager, prefabCreateAssertError);`
`1306`	`1326`	`Assert.IsFalse(m_ServerNetworkManager.IsListening, prefabCreateAssertError);`
`1307`	`1327`
`@@ -1375,6 +1395,7 @@ private List<GameObject> SpawnObjects(NetworkObject prefabNetworkObject, Network`
`1375`	`1395`	`{`
`1376`	`1396`	`gameObjectsSpawned.Add(SpawnObject(prefabNetworkObject, owner, destroyWithScene));`
`1377`	`1397`	`}`
	`1398`	`+`
`1378`	`1399`	`return gameObjectsSpawned;`
`1379`	`1400`	`}`
`1380`	`1401`
`@@ -1383,7 +1404,6 @@ private List<GameObject> SpawnObjects(NetworkObject prefabNetworkObject, Network`
`1383`	`1404`	`/// </summary>`
`1384`	`1405`	`public NetcodeIntegrationTest()`
`1385`	`1406`	`{`
`1386`		`-`
`1387`	`1407`	`}`
`1388`	`1408`
`1389`	`1409`	`/// <summary>`
`@@ -1429,6 +1449,7 @@ private void UnloadRemainingScenes()`
`1429`	`1449`	`{`
`1430`	`1450`	`continue;`
`1431`	`1451`	`}`
	`1452`	`+`
`1432`	`1453`	`VerboseDebug($"Unloading scene {scene.name}-{scene.handle}");`
`1433`	`1454`	`var asyncOperation = SceneManager.UnloadSceneAsync(scene);`
`1434`	`1455`	`}`
`@@ -1468,6 +1489,7 @@ private IEnumerator WaitForTickAndFrames(NetworkManager networkManager, int tick`
`1468`	`1489`	`}`
`1469`	`1490`	`}`
`1470`	`1491`	`}`
	`1492`	`+`
`1471`	`1493`	`m_WaitForLog.Append($"[NetworkManager-{networkManager.LocalClientId}][WaitForTicks-End] Waited for ({networkManager.NetworkTickSystem.LocalTime.Tick - tickStart}) network ticks and ({frameCount}) frames to pass.\n");`
`1472`	`1494`	`yield break;`
`1473`	`1495`	`}`
`@@ -1534,31 +1556,34 @@ public static void SimulateOneFrame()`
`1534`	`1556`	`foreach (NetworkUpdateStage stage in Enum.GetValues(typeof(NetworkUpdateStage)))`
`1535`	`1557`	`{`
`1536`	`1558`	`NetworkUpdateLoop.RunNetworkUpdateStage(stage);`
`1537`		`- var methodName = "";`
	`1559`	`+ string methodName = string.Empty;`
`1538`	`1560`	`switch (stage)`
`1539`	`1561`	`{`
`1540`	`1562`	`case NetworkUpdateStage.FixedUpdate:`
`1541`		`- methodName = "FixedUpdate";`
	`1563`	`+ methodName = "FixedUpdate"; // mapping NetworkUpdateStage.FixedUpdate to MonoBehaviour.FixedUpdate`
`1542`	`1564`	`break;`
`1543`	`1565`	`case NetworkUpdateStage.Update:`
`1544`		`- methodName = "Update";`
	`1566`	`+ methodName = "Update"; // mapping NetworkUpdateStage.Update to MonoBehaviour.Update`
`1545`	`1567`	`break;`
`1546`	`1568`	`case NetworkUpdateStage.PreLateUpdate:`
`1547`		`- methodName = "LateUpdate";`
	`1569`	`+ methodName = "LateUpdate"; // mapping NetworkUpdateStage.PreLateUpdate to MonoBehaviour.LateUpdate`
`1548`	`1570`	`break;`
`1549`		`-`
`1550`	`1571`	`}`
`1551`	`1572`
`1552`		`-`
`1553`		`- if (methodName != "")`
	`1573`	`+ if (!string.IsNullOrEmpty(methodName))`
`1554`	`1574`	`{`
	`1575`	`+#if UNITY_2023_1_OR_NEWER`
	`1576`	`+ foreach (var behaviour in Object.FindObjectsByType<NetworkBehaviour>(FindObjectsSortMode.InstanceID))`
	`1577`	`+#else`
`1555`	`1578`	`foreach (var behaviour in Object.FindObjectsOfType<NetworkBehaviour>())`
	`1579`	`+#endif`
`1556`	`1580`	`{`
`1557`	`1581`	`var method = behaviour.GetType().GetMethod(methodName, BindingFlags.NonPublic \| BindingFlags.Instance);`
`1558`	`1582`	`if (method == null)`
`1559`	`1583`	`{`
`1560`	`1584`	`method = behaviour.GetType().GetMethod(methodName, BindingFlags.Public \| BindingFlags.Instance);`
`1561`	`1585`	`}`
	`1586`	`+`
`1562`	`1587`	`method?.Invoke(behaviour, new object[] { });`
`1563`	`1588`	`}`
`1564`	`1589`	`}`