Fix tests

EmandM · NoelStephensUnity · commit aea56feb38bb · 2025-10-15T11:15:49.000-05:00
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/NetworkAnimator.cs b/com.unity.netcode.gameobjects/Runtime/Components/NetworkAnimator.cs
@@ -213,6 +213,11 @@ internal class TransitionStateinfo
         // [Layer][DestinationState][TransitionStateInfo]
         private Dictionary<int, Dictionary<int, TransitionStateinfo>> m_DestinationStateToTransitioninfo = new Dictionary<int, Dictionary<int, TransitionStateinfo>>();
 
+        // Named differently to avoid serialization conflicts with NetworkBehaviour
+        private NetworkManager m_LocalNetworkManager;
+
+        internal bool DistributedAuthorityMode;
+
         /// <summary>
         /// Builds the m_DestinationStateToTransitioninfo lookup table
         /// </summary>
@@ -509,7 +514,12 @@ internal bool IsServerAuthoritative()
         /// </remarks>
         protected virtual bool OnIsServerAuthoritative()
         {
-            return NetworkManager ? !NetworkManager.DistributedAuthorityMode : true;
+            if (!m_LocalNetworkManager)
+            {
+                return true;
+            }
+
+            return !DistributedAuthorityMode;
         }
 
         private int[] m_TransitionHash;
@@ -713,6 +723,10 @@ internal AnimationMessage GetAnimationMessage()
         /// <inheritdoc/>
         public override void OnNetworkSpawn()
         {
+            // Save internal state references
+            m_LocalNetworkManager = NetworkManager;
+            DistributedAuthorityMode = m_LocalNetworkManager.DistributedAuthorityMode;
+
             // If there is no assigned Animator then generate a server network warning (logged locally and if applicable on the server-host side as well).
             if (m_Animator == null)
             {
@@ -963,7 +977,7 @@ internal void CheckForAnimatorChanges()
 
             if (m_Animator.runtimeAnimatorController == null)
             {
-                if (NetworkManager.LogLevel == LogLevel.Developer)
+                if (m_LocalNetworkManager.LogLevel == LogLevel.Developer)
                 {
                     Debug.LogError($"[{GetType().Name}] Could not find an assigned {nameof(RuntimeAnimatorController)}! Cannot check {nameof(Animator)} for changes in state!");
                 }
@@ -998,9 +1012,9 @@ internal void CheckForAnimatorChanges()
                 {
                     // Just notify all remote clients and not the local server
                     m_ClientSendList.Clear();
-                    foreach (var clientId in NetworkManager.ConnectionManager.ConnectedClientIds)
+                    foreach (var clientId in m_LocalNetworkManager.ConnectionManager.ConnectedClientIds)
                     {
-                        if (clientId == NetworkManager.LocalClientId || !NetworkObject.Observers.Contains(clientId))
+                        if (clientId == m_LocalNetworkManager.LocalClientId || !NetworkObject.Observers.Contains(clientId))
                         {
                             continue;
                         }
@@ -1028,7 +1042,7 @@ private void SendParametersUpdate(ClientRpcParams clientRpcParams = default, boo
                 }
                 else
                 {
-                    Debug.LogError($"[{name}][Client-{NetworkManager.LocalClientId}] Attempting to send parameter updates but not the owner!");
+                    Debug.LogError($"[{name}][Client-{m_LocalNetworkManager.LocalClientId}] Attempting to send parameter updates but not the owner!");
                 }
             }
             else
@@ -1266,12 +1280,12 @@ internal void UpdateAnimationState(AnimationState animationState)
                             // Cross fade from the current to the destination state for the transitions duration while starting at the server's current normalized time of the transition
                             m_Animator.CrossFade(transitionStateInfo.DestinationState, transitionStateInfo.TransitionDuration, transitionStateInfo.Layer, 0.0f, animationState.NormalizedTime);
                         }
-                        else if (NetworkManager.LogLevel == LogLevel.Developer)
+                        else if (m_LocalNetworkManager.LogLevel == LogLevel.Developer)
                         {
                             NetworkLog.LogWarning($"Current State Hash ({currentState.fullPathHash}) != AnimationState.StateHash ({animationState.StateHash})");
                         }
                     }
-                    else if (NetworkManager.LogLevel == LogLevel.Developer)
+                    else if (m_LocalNetworkManager.LogLevel == LogLevel.Developer)
                     {
                         NetworkLog.LogError($"[DestinationState To Transition Info] Layer ({animationState.Layer}) sub-table does not contain destination state ({animationState.DestinationStateHash})!");
                     }
@@ -1314,7 +1328,8 @@ private unsafe void SendParametersUpdateServerRpc(ParametersUpdateMessage parame
                     return;
                 }
                 UpdateParameters(ref parametersUpdate);
-                if (NetworkManager.ConnectedClientsIds.Count > (IsHost ? 2 : 1))
+                var connectedClientIds = m_LocalNetworkManager.ConnectionManager.ConnectedClientIds;
+                if (connectedClientIds.Count <= (IsHost ? 2 : 1))
                 {
                     m_ClientSendList.Clear();
                     foreach (var clientId in NetworkManager.ConnectionManager.ConnectedClientIds)
@@ -1377,7 +1392,8 @@ private void SendAnimStateServerRpc(AnimationMessage animationMessage, ServerRpc
                     UpdateAnimationState(animationState);
                 }
 
-                if (NetworkManager.ConnectedClientsIds.Count > (IsHost ? 2 : 1))
+                var connectedClientIds = m_LocalNetworkManager.ConnectionManager.ConnectedClientIds;
+                if (connectedClientIds.Count <= (IsHost ? 2 : 1))
                 {
                     m_ClientSendList.Clear();
                     foreach (var clientId in NetworkManager.ConnectionManager.ConnectedClientIds)
@@ -1416,7 +1432,7 @@ private void ProcessAnimStates(AnimationMessage animationMessage)
         {
             if (HasAuthority)
             {
-                if (NetworkManager.LogLevel == LogLevel.Developer)
+                if (m_LocalNetworkManager.LogLevel == LogLevel.Developer)
                 {
                     var hostOrOwner = NetworkManager.DistributedAuthorityMode ? "Owner" : "Host";
                     var clientServerOrDAMode = NetworkManager.DistributedAuthorityMode ? "distributed authority" : "client-server";
@@ -1443,7 +1459,7 @@ internal void SendAnimTriggerServerRpc(AnimationTriggerMessage animationTriggerM
             // Ignore if a non-owner sent this.
             if (serverRpcParams.Receive.SenderClientId != OwnerClientId)
             {
-                if (NetworkManager.LogLevel == LogLevel.Developer)
+                if (m_LocalNetworkManager.LogLevel == LogLevel.Developer)
                 {
                     NetworkLog.LogWarning($"[Owner Authoritative] Detected the a non-authoritative client is sending the server animation trigger updates. If you recently changed ownership of the {name} object, then this could be the reason.");
                 }
@@ -1453,6 +1469,8 @@ internal void SendAnimTriggerServerRpc(AnimationTriggerMessage animationTriggerM
             // set the trigger locally on the server
             InternalSetTrigger(animationTriggerMessage.Hash, animationTriggerMessage.IsTriggerSet);
 
+            var connectedClientIds = m_LocalNetworkManager.ConnectionManager.ConnectedClientIds;
+
             m_ClientSendList.Clear();
             foreach (var clientId in NetworkManager.ConnectionManager.ConnectedClientIds)
             {
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/TestHelpers/Components/ObjectNameIdentifier.cs b/com.unity.netcode.gameobjects/Tests/Runtime/TestHelpers/Components/ObjectNameIdentifier.cs
@@ -108,10 +108,7 @@ public override void OnDestroy()
                 DeRegisterNetworkObject();
                 // This is required otherwise it will try to continue to update the NetworkBehaviour even if
                 // it has been destroyed (most likely integration test specific)
-                if (m_NetworkObject.ChildNetworkBehaviours != null && m_NetworkObject.ChildNetworkBehaviours.Contains(this))
-                {
-                    NetworkObject.ChildNetworkBehaviours.Remove(this);
-                }
+                m_NetworkObject.ChildNetworkBehaviours?.Remove(this);
                 m_NetworkObject = null;
             }
             base.OnDestroy();
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/TestHelpers/NetcodeIntegrationTest.cs b/com.unity.netcode.gameobjects/Tests/Runtime/TestHelpers/NetcodeIntegrationTest.cs
@@ -576,6 +576,7 @@ private void InternalOnOneTimeSetup()
             IsRunning = true;
             m_EnableVerboseDebug = OnSetVerboseDebug();
             IntegrationTestSceneHandler.VerboseDebugMode = m_EnableVerboseDebug;
+            NetworkManagerHelper.VerboseDebugMode = m_EnableVerboseDebug;
             VerboseDebug($"Entering {nameof(OneTimeSetup)}");
 
             m_NetworkManagerInstatiationMode = OnSetIntegrationTestMode();
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/TestHelpers/NetworkManagerHelper.cs b/com.unity.netcode.gameobjects/Tests/Runtime/TestHelpers/NetworkManagerHelper.cs
@@ -44,6 +44,11 @@ public static class NetworkManagerHelper
         /// </summary>
         public static NetworkManagerOperatingMode CurrentNetworkManagerMode;
 
+        /// <summary>
+        /// When true, logs will be generated for <see cref="NetworkManager"/> lifecycle events.
+        /// </summary>
+        public static bool VerboseDebugMode;
+
         /// <summary>
         /// This provides the ability to start NetworkManager in various modes
         /// </summary>
@@ -97,7 +102,7 @@ public static bool StartNetworkManager(out NetworkManager networkManager, Networ
                     return false;
                 }
 
-                Debug.Log($"{nameof(NetworkManager)} Instantiated.");
+                VerboseLog($"{nameof(NetworkManager)} Instantiated.");
 
                 var unityTransport = NetworkManagerGameObject.AddComponent<UnityTransport>();
                 if (networkConfig == null)
@@ -212,7 +217,7 @@ private static void StartNetworkManagerMode(NetworkManagerOperatingMode managerM
                 }
 
                 // Only log this if we started an netcode session
-                Debug.Log($"{CurrentNetworkManagerMode} started.");
+                VerboseLog($"{CurrentNetworkManagerMode} started.");
             }
         }
 
@@ -223,7 +228,7 @@ private static void StopNetworkManagerMode()
         {
             NetworkManagerObject.Shutdown();
 
-            Debug.Log($"{CurrentNetworkManagerMode} stopped.");
+            VerboseLog($"{CurrentNetworkManagerMode} stopped.");
             CurrentNetworkManagerMode = NetworkManagerOperatingMode.None;
         }
 
@@ -243,11 +248,11 @@ public static void ShutdownNetworkManager()
 
             if (NetworkManagerGameObject != null)
             {
-                Debug.Log($"{nameof(NetworkManager)} shutdown.");
+                VerboseLog($"{nameof(NetworkManager)} shutdown.");
 
                 StopNetworkManagerMode();
                 UnityEngine.Object.DestroyImmediate(NetworkManagerGameObject);
-                Debug.Log($"{nameof(NetworkManager)} destroyed.");
+                VerboseLog($"{nameof(NetworkManager)} destroyed.");
             }
             NetworkManagerGameObject = null;
             NetworkManagerObject = null;
@@ -304,5 +309,13 @@ public static bool BuffersMatch(int indexOffset, long targetSize, byte[] sourceA
             }
             return true;
         }
+
+        private static void VerboseLog(string message)
+        {
+            if (VerboseDebugMode)
+            {
+                Debug.unityLogger.Log(message);
+            }
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -213,6 +213,11 @@ internal class TransitionStateinfo`
`213`	`213`	`// [Layer][DestinationState][TransitionStateInfo]`
`214`	`214`	`private Dictionary<int, Dictionary<int, TransitionStateinfo>> m_DestinationStateToTransitioninfo = new Dictionary<int, Dictionary<int, TransitionStateinfo>>();`
`215`	`215`
	`216`	`+ // Named differently to avoid serialization conflicts with NetworkBehaviour`
	`217`	`+ private NetworkManager m_LocalNetworkManager;`
	`218`	`+`
	`219`	`+ internal bool DistributedAuthorityMode;`
	`220`	`+`
`216`	`221`	`/// <summary>`
`217`	`222`	`/// Builds the m_DestinationStateToTransitioninfo lookup table`
`218`	`223`	`/// </summary>`
`@@ -509,7 +514,12 @@ internal bool IsServerAuthoritative()`
`509`	`514`	`/// </remarks>`
`510`	`515`	`protected virtual bool OnIsServerAuthoritative()`
`511`	`516`	`{`
`512`		`- return NetworkManager ? !NetworkManager.DistributedAuthorityMode : true;`
	`517`	`+ if (!m_LocalNetworkManager)`
	`518`	`+ {`
	`519`	`+ return true;`
	`520`	`+ }`
	`521`	`+`
	`522`	`+ return !DistributedAuthorityMode;`
`513`	`523`	`}`
`514`	`524`
`515`	`525`	`private int[] m_TransitionHash;`
`@@ -713,6 +723,10 @@ internal AnimationMessage GetAnimationMessage()`
`713`	`723`	`/// <inheritdoc/>`
`714`	`724`	`public override void OnNetworkSpawn()`
`715`	`725`	`{`
	`726`	`+ // Save internal state references`
	`727`	`+ m_LocalNetworkManager = NetworkManager;`
	`728`	`+ DistributedAuthorityMode = m_LocalNetworkManager.DistributedAuthorityMode;`
	`729`	`+`
`716`	`730`	`// If there is no assigned Animator then generate a server network warning (logged locally and if applicable on the server-host side as well).`
`717`	`731`	`if (m_Animator == null)`
`718`	`732`	`{`
`@@ -963,7 +977,7 @@ internal void CheckForAnimatorChanges()`
`963`	`977`
`964`	`978`	`if (m_Animator.runtimeAnimatorController == null)`
`965`	`979`	`{`
`966`		`- if (NetworkManager.LogLevel == LogLevel.Developer)`
	`980`	`+ if (m_LocalNetworkManager.LogLevel == LogLevel.Developer)`
`967`	`981`	`{`
`968`	`982`	`Debug.LogError($"[{GetType().Name}] Could not find an assigned {nameof(RuntimeAnimatorController)}! Cannot check {nameof(Animator)} for changes in state!");`
`969`	`983`	`}`
`@@ -998,9 +1012,9 @@ internal void CheckForAnimatorChanges()`
`998`	`1012`	`{`
`999`	`1013`	`// Just notify all remote clients and not the local server`
`1000`	`1014`	`m_ClientSendList.Clear();`
`1001`		`- foreach (var clientId in NetworkManager.ConnectionManager.ConnectedClientIds)`
	`1015`	`+ foreach (var clientId in m_LocalNetworkManager.ConnectionManager.ConnectedClientIds)`
`1002`	`1016`	`{`
`1003`		`- if (clientId == NetworkManager.LocalClientId \|\| !NetworkObject.Observers.Contains(clientId))`
	`1017`	`+ if (clientId == m_LocalNetworkManager.LocalClientId \|\| !NetworkObject.Observers.Contains(clientId))`
`1004`	`1018`	`{`
`1005`	`1019`	`continue;`
`1006`	`1020`	`}`
`@@ -1028,7 +1042,7 @@ private void SendParametersUpdate(ClientRpcParams clientRpcParams = default, boo`
`1028`	`1042`	`}`
`1029`	`1043`	`else`
`1030`	`1044`	`{`
`1031`		`- Debug.LogError($"[{name}][Client-{NetworkManager.LocalClientId}] Attempting to send parameter updates but not the owner!");`
	`1045`	`+ Debug.LogError($"[{name}][Client-{m_LocalNetworkManager.LocalClientId}] Attempting to send parameter updates but not the owner!");`
`1032`	`1046`	`}`
`1033`	`1047`	`}`
`1034`	`1048`	`else`
`@@ -1266,12 +1280,12 @@ internal void UpdateAnimationState(AnimationState animationState)`
`1266`	`1280`	`// Cross fade from the current to the destination state for the transitions duration while starting at the server's current normalized time of the transition`
`1267`	`1281`	`m_Animator.CrossFade(transitionStateInfo.DestinationState, transitionStateInfo.TransitionDuration, transitionStateInfo.Layer, 0.0f, animationState.NormalizedTime);`
`1268`	`1282`	`}`
`1269`		`- else if (NetworkManager.LogLevel == LogLevel.Developer)`
	`1283`	`+ else if (m_LocalNetworkManager.LogLevel == LogLevel.Developer)`
`1270`	`1284`	`{`
`1271`	`1285`	`NetworkLog.LogWarning($"Current State Hash ({currentState.fullPathHash}) != AnimationState.StateHash ({animationState.StateHash})");`
`1272`	`1286`	`}`
`1273`	`1287`	`}`
`1274`		`- else if (NetworkManager.LogLevel == LogLevel.Developer)`
	`1288`	`+ else if (m_LocalNetworkManager.LogLevel == LogLevel.Developer)`
`1275`	`1289`	`{`
`1276`	`1290`	`NetworkLog.LogError($"[DestinationState To Transition Info] Layer ({animationState.Layer}) sub-table does not contain destination state ({animationState.DestinationStateHash})!");`
`1277`	`1291`	`}`
`@@ -1314,7 +1328,8 @@ private unsafe void SendParametersUpdateServerRpc(ParametersUpdateMessage parame`
`1314`	`1328`	`return;`
`1315`	`1329`	`}`
`1316`	`1330`	`UpdateParameters(ref parametersUpdate);`
`1317`		`- if (NetworkManager.ConnectedClientsIds.Count > (IsHost ? 2 : 1))`
	`1331`	`+ var connectedClientIds = m_LocalNetworkManager.ConnectionManager.ConnectedClientIds;`
	`1332`	`+ if (connectedClientIds.Count <= (IsHost ? 2 : 1))`
`1318`	`1333`	`{`
`1319`	`1334`	`m_ClientSendList.Clear();`
`1320`	`1335`	`foreach (var clientId in NetworkManager.ConnectionManager.ConnectedClientIds)`
`@@ -1377,7 +1392,8 @@ private void SendAnimStateServerRpc(AnimationMessage animationMessage, ServerRpc`
`1377`	`1392`	`UpdateAnimationState(animationState);`
`1378`	`1393`	`}`
`1379`	`1394`
`1380`		`- if (NetworkManager.ConnectedClientsIds.Count > (IsHost ? 2 : 1))`
	`1395`	`+ var connectedClientIds = m_LocalNetworkManager.ConnectionManager.ConnectedClientIds;`
	`1396`	`+ if (connectedClientIds.Count <= (IsHost ? 2 : 1))`
`1381`	`1397`	`{`
`1382`	`1398`	`m_ClientSendList.Clear();`
`1383`	`1399`	`foreach (var clientId in NetworkManager.ConnectionManager.ConnectedClientIds)`
`@@ -1416,7 +1432,7 @@ private void ProcessAnimStates(AnimationMessage animationMessage)`
`1416`	`1432`	`{`
`1417`	`1433`	`if (HasAuthority)`
`1418`	`1434`	`{`
`1419`		`- if (NetworkManager.LogLevel == LogLevel.Developer)`
	`1435`	`+ if (m_LocalNetworkManager.LogLevel == LogLevel.Developer)`
`1420`	`1436`	`{`
`1421`	`1437`	`var hostOrOwner = NetworkManager.DistributedAuthorityMode ? "Owner" : "Host";`
`1422`	`1438`	`var clientServerOrDAMode = NetworkManager.DistributedAuthorityMode ? "distributed authority" : "client-server";`
`@@ -1443,7 +1459,7 @@ internal void SendAnimTriggerServerRpc(AnimationTriggerMessage animationTriggerM`
`1443`	`1459`	`// Ignore if a non-owner sent this.`
`1444`	`1460`	`if (serverRpcParams.Receive.SenderClientId != OwnerClientId)`
`1445`	`1461`	`{`
`1446`		`- if (NetworkManager.LogLevel == LogLevel.Developer)`
	`1462`	`+ if (m_LocalNetworkManager.LogLevel == LogLevel.Developer)`
`1447`	`1463`	`{`
`1448`	`1464`	`NetworkLog.LogWarning($"[Owner Authoritative] Detected the a non-authoritative client is sending the server animation trigger updates. If you recently changed ownership of the {name} object, then this could be the reason.");`
`1449`	`1465`	`}`
`@@ -1453,6 +1469,8 @@ internal void SendAnimTriggerServerRpc(AnimationTriggerMessage animationTriggerM`
`1453`	`1469`	`// set the trigger locally on the server`
`1454`	`1470`	`InternalSetTrigger(animationTriggerMessage.Hash, animationTriggerMessage.IsTriggerSet);`
`1455`	`1471`
	`1472`	`+ var connectedClientIds = m_LocalNetworkManager.ConnectionManager.ConnectedClientIds;`
	`1473`	`+`
`1456`	`1474`	`m_ClientSendList.Clear();`
`1457`	`1475`	`foreach (var clientId in NetworkManager.ConnectionManager.ConnectedClientIds)`
`1458`	`1476`	`{`
Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,11 @@ public static class NetworkManagerHelper`
`44`	`44`	`/// </summary>`
`45`	`45`	`public static NetworkManagerOperatingMode CurrentNetworkManagerMode;`
`46`	`46`
	`47`	`+ /// <summary>`
	`48`	`+ /// When true, logs will be generated for <see cref="NetworkManager"/> lifecycle events.`
	`49`	`+ /// </summary>`
	`50`	`+ public static bool VerboseDebugMode;`
	`51`	`+`
`47`	`52`	`/// <summary>`
`48`	`53`	`/// This provides the ability to start NetworkManager in various modes`
`49`	`54`	`/// </summary>`
`@@ -97,7 +102,7 @@ public static bool StartNetworkManager(out NetworkManager networkManager, Networ`
`97`	`102`	`return false;`
`98`	`103`	`}`
`99`	`104`
`100`		`- Debug.Log($"{nameof(NetworkManager)} Instantiated.");`
	`105`	`+ VerboseLog($"{nameof(NetworkManager)} Instantiated.");`
`101`	`106`
`102`	`107`	`var unityTransport = NetworkManagerGameObject.AddComponent<UnityTransport>();`
`103`	`108`	`if (networkConfig == null)`
`@@ -212,7 +217,7 @@ private static void StartNetworkManagerMode(NetworkManagerOperatingMode managerM`
`212`	`217`	`}`
`213`	`218`
`214`	`219`	`// Only log this if we started an netcode session`
`215`		`- Debug.Log($"{CurrentNetworkManagerMode} started.");`
	`220`	`+ VerboseLog($"{CurrentNetworkManagerMode} started.");`
`216`	`221`	`}`
`217`	`222`	`}`
`218`	`223`
`@@ -223,7 +228,7 @@ private static void StopNetworkManagerMode()`
`223`	`228`	`{`
`224`	`229`	`NetworkManagerObject.Shutdown();`
`225`	`230`
`226`		`- Debug.Log($"{CurrentNetworkManagerMode} stopped.");`
	`231`	`+ VerboseLog($"{CurrentNetworkManagerMode} stopped.");`
`227`	`232`	`CurrentNetworkManagerMode = NetworkManagerOperatingMode.None;`
`228`	`233`	`}`
`229`	`234`
`@@ -243,11 +248,11 @@ public static void ShutdownNetworkManager()`
`243`	`248`
`244`	`249`	`if (NetworkManagerGameObject != null)`
`245`	`250`	`{`
`246`		`- Debug.Log($"{nameof(NetworkManager)} shutdown.");`
	`251`	`+ VerboseLog($"{nameof(NetworkManager)} shutdown.");`
`247`	`252`
`248`	`253`	`StopNetworkManagerMode();`
`249`	`254`	`UnityEngine.Object.DestroyImmediate(NetworkManagerGameObject);`
`250`		`- Debug.Log($"{nameof(NetworkManager)} destroyed.");`
	`255`	`+ VerboseLog($"{nameof(NetworkManager)} destroyed.");`
`251`	`256`	`}`
`252`	`257`	`NetworkManagerGameObject = null;`
`253`	`258`	`NetworkManagerObject = null;`
`@@ -304,5 +309,13 @@ public static bool BuffersMatch(int indexOffset, long targetSize, byte[] sourceA`
`304`	`309`	`}`
`305`	`310`	`return true;`
`306`	`311`	`}`
	`312`	`+`
	`313`	`+ private static void VerboseLog(string message)`
	`314`	`+ {`
	`315`	`+ if (VerboseDebugMode)`
	`316`	`+ {`
	`317`	`+ Debug.unityLogger.Log(message);`
	`318`	`+ }`
	`319`	`+ }`
`307`	`320`	`}`
`308`	`321`	`}`