InnoLab/com.unity.netcode.gameobjects
Archived
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

com.unity.netcode.gameobjects@1.3.1

Browse Source 
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).

## [1.3.1] - 2023-03-27

### Added

- Added detection and graceful handling of corrupt packets for additional safety. (#2419)

### Changed

- The UTP component UI has been updated to be more user-friendly for new users by adding a simple toggle to switch between local-only (127.0.0.1) and remote (0.0.0.0) binding modes, using the toggle "Allow Remote Connections" (#2408)
- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.3. (#2450)
- `NetworkShow()` of `NetworkObject`s are delayed until the end of the frame to ensure consistency of delta-driven variables like `NetworkList`.
- Dirty `NetworkObject` are reset at end-of-frame and not at serialization time.
- `NetworkHide()` of an object that was just `NetworkShow()`n produces a warning, as remote clients will _not_ get a spawn/despawn pair.
- Renamed the NetworkTransform.SetState parameter `shouldGhostsInterpolate` to `teleportDisabled` for better clarity of what that parameter does. (#2228)
- Network prefabs are now stored in a ScriptableObject that can be shared between NetworkManagers, and have been exposed for public access. By default, a Default Prefabs List is created that contains all NetworkObject prefabs in the project, and new NetworkManagers will default to using that unless that option is turned off in the Netcode for GameObjects settings. Existing NetworkManagers will maintain their existing lists, which can be migrated to the new format via a button in their inspector. (#2322)

### Fixed

- Fixed issue where changes to a layer's weight would not synchronize unless a state transition was occurring.(#2399)
- Fixed issue where `NetworkManager.LocalClientId` was returning the `NetworkTransport.ServerClientId` as opposed to the `NetworkManager.m_LocalClientId`. (#2398)
- Fixed issue where a dynamically spawned `NetworkObject` parented under an in-scene placed `NetworkObject` would have its `InScenePlaced` value changed to `true`. This would result in a soft synchronization error for late joining clients. (#2396)
- Fixed a UTP test that was failing when you install Unity Transport package 2.0.0 or newer. (#2347)
- Fixed issue where `NetcodeSettingsProvider` would throw an exception in Unity 2020.3.x versions. (#2345)
- Fixed server side issue where, depending upon component ordering, some NetworkBehaviour components might not have their OnNetworkDespawn method invoked if the client side disconnected. (#2323)
- Fixed a case where data corruption could occur when using UnityTransport when reaching a certain level of send throughput. (#2332)
- Fixed an issue in `UnityTransport` where an exception would be thrown if starting a Relay host/server on WebGL. This exception should only be thrown if using direct connections (where WebGL can't act as a host/server). (#2321)
- Fixed `NetworkAnimator` issue where it was not checking for `AnimatorStateTtansition.destinationStateMachine` and any possible sub-states defined within it. (#2309)
- Fixed `NetworkAnimator` issue where the host client was receiving the ClientRpc animation updates when the host was the owner.(#2309)
- Fixed `NetworkAnimator` issue with using pooled objects and when specific properties are cleaned during despawn and destroy.(#2309)
- Fixed issue where `NetworkAnimator` was checking for animation changes when the associated `NetworkObject` was not spawned.(#2309)
- Corrected an issue with the documentation for BufferSerializer (#2401)
This commit is contained in:
Unity Technologies
2023-03-27 00:00:00 +00:00
parent fe02ca682e
commit 8060718e04
69 changed files with 3128 additions and 888 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Tests/Editor/Build/BuildTests.cs
View File

@@ -12,7 +12,6 @@ namespace Unity.Netcode.EditorTests
public const string DefaultBuildScenePath = "Tests/Editor/Build/BuildTestScene.unity";
[Test]
[Ignore("Disabling this test on release/1.2.0 branch due to Burst failures caused when running with upm ci")]
public void BasicBuildTest()
{
var execAssembly = Assembly.GetExecutingAssembly();

203
Tests/Editor/Messaging/MessageCorruptionTests.cs Normal file
View File

@@ -0,0 +1,203 @@
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using NUnit.Framework;
using NUnit.Framework.Internal;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using UnityEngine;
using UnityEngine.TestTools;
namespace Unity.Netcode.EditorTests
{
public class MessageCorruptionTests
{
private struct TestMessage : INetworkMessage, INetworkSerializeByMemcpy
{
public ForceNetworkSerializeByMemcpy<Guid> Value;
public static bool Handled;
public static bool Deserialized;
public void Serialize(FastBufferWriter writer, int targetVersion)
{
writer.WriteValueSafe(Value);
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
Deserialized = true;
reader.ReadValueSafe(out Value);
return true;
}
public void Handle(ref NetworkContext context)
{
Handled = true;
}
public int Version => 0;
}
private class TestMessageProvider : IMessageProvider
{
public List<MessagingSystem.MessageWithHandler> GetMessages()
{
return new List<MessagingSystem.MessageWithHandler>
{
new MessagingSystem.MessageWithHandler
{
MessageType = typeof(TestMessage),
Handler = MessagingSystem.ReceiveMessage<TestMessage>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessage>
}
};
}
}
public enum TypeOfCorruption
{
OffsetPlus,
OffsetMinus,
CorruptBytes,
Truncated,
AdditionalGarbageData,
}
private class TestMessageSender : IMessageSender
{
public TypeOfCorruption Corruption;
public List<byte[]> MessageQueue = new List<byte[]>();
public unsafe void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData)
{
switch (Corruption)
{
case TypeOfCorruption.OffsetPlus:
{
using var subWriter = new FastBufferWriter(batchData.Length + 1, Allocator.Temp);
subWriter.WriteByteSafe(0);
subWriter.WriteBytesSafe(batchData.GetUnsafePtr(), batchData.Length);
MessageQueue.Add(subWriter.ToArray());
break;
}
case TypeOfCorruption.OffsetMinus:
{
using var subWriter = new FastBufferWriter(batchData.Length - 1, Allocator.Temp);
subWriter.WriteBytesSafe(batchData.GetUnsafePtr() + 1, batchData.Length - 1);
MessageQueue.Add(subWriter.ToArray());
break;
}
case TypeOfCorruption.CorruptBytes:
batchData.Seek(batchData.Length - 2);
var currentByte = batchData.GetUnsafePtr()[0];
batchData.WriteByteSafe((byte)(currentByte == 0 ? 1 : 0));
MessageQueue.Add(batchData.ToArray());
break;
case TypeOfCorruption.Truncated:
batchData.Truncate(batchData.Length - 1);
MessageQueue.Add(batchData.ToArray());
break;
case TypeOfCorruption.AdditionalGarbageData:
batchData.Seek(batchData.Length);
batchData.WriteByteSafe(0);
MessageQueue.Add(batchData.ToArray());
break;
}
}
}
private MessagingSystem m_MessagingSystem;
private TestMessageSender m_MessageSender;
[SetUp]
public void SetUp()
{
TestMessage.Handled = false;
TestMessage.Deserialized = false;
m_MessageSender = new TestMessageSender();
m_MessagingSystem = new MessagingSystem(m_MessageSender, this, new TestMessageProvider());
m_MessagingSystem.ClientConnected(0);
m_MessagingSystem.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
}
[TearDown]
public void TearDown()
{
m_MessagingSystem.Dispose();
}
private TestMessage GetMessage()
{
return new TestMessage
{
Value = Guid.NewGuid()
};
}
[Test]
public unsafe void WhenPacketsAreCorrupted_TheyDontGetProcessed([Values] TypeOfCorruption typeOfCorruption)
{
m_MessageSender.Corruption = typeOfCorruption;
switch (typeOfCorruption)
{
case TypeOfCorruption.OffsetMinus:
case TypeOfCorruption.OffsetPlus:
LogAssert.Expect(LogType.Error, new Regex("Received a packet with an invalid Magic Value\\."));
break;
case TypeOfCorruption.Truncated:
case TypeOfCorruption.AdditionalGarbageData:
LogAssert.Expect(LogType.Error, new Regex("Received a packet with an invalid Batch Size Value\\."));
break;
case TypeOfCorruption.CorruptBytes:
LogAssert.Expect(LogType.Error, new Regex("Received a packet with an invalid Hash Value\\."));
break;
}
// Dummy batch header
var batchHeader = new BatchHeader
{
BatchCount = 1
};
var messageHeader = new MessageHeader
{
MessageSize = (ushort)UnsafeUtility.SizeOf<TestMessage>(),
MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)),
};
var message = GetMessage();
var writer = new FastBufferWriter(1300, Allocator.Temp);
using (writer)
{
writer.TryBeginWrite(FastBufferWriter.GetWriteSize(batchHeader) +
FastBufferWriter.GetWriteSize(messageHeader) +
FastBufferWriter.GetWriteSize(message));
writer.WriteValue(batchHeader);
writer.WriteValue(messageHeader);
writer.WriteValue(message);
// Fill out the rest of the batch header
writer.Seek(0);
batchHeader = new BatchHeader
{
Magic = BatchHeader.MagicValue,
BatchSize = writer.Length,
BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
BatchCount = 1
};
writer.WriteValue(batchHeader);
m_MessageSender.Send(0, NetworkDelivery.Reliable, writer);
var receivedMessage = m_MessageSender.MessageQueue[0];
m_MessageSender.MessageQueue.Clear();
m_MessagingSystem.HandleIncomingData(0, new ArraySegment<byte>(receivedMessage), 0);
Assert.IsFalse(TestMessage.Deserialized);
Assert.IsFalse(TestMessage.Handled);
}
}
}
}

3
Tests/Editor/Messaging/MessageCorruptionTests.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: d3c01a0b5a0e478ebc5182fe339bde04
timeCreated: 1676997550

45
Tests/Editor/Messaging/MessageReceivingTests.cs
View File

@@ -114,11 +114,11 @@ namespace Unity.Netcode.EditorTests
}
[Test]
public void WhenHandlingIncomingData_ReceiveIsNotCalledBeforeProcessingIncomingMessageQueue()
public unsafe void WhenHandlingIncomingData_ReceiveIsNotCalledBeforeProcessingIncomingMessageQueue()
{
var batchHeader = new BatchHeader
{
BatchSize = 1
BatchCount = 1
};
var messageHeader = new MessageHeader
{
@@ -137,6 +137,17 @@ namespace Unity.Netcode.EditorTests
writer.WriteValue(messageHeader);
writer.WriteValue(message);
// Fill out the rest of the batch header
writer.Seek(0);
batchHeader = new BatchHeader
{
Magic = BatchHeader.MagicValue,
BatchSize = writer.Length,
BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
BatchCount = 1
};
writer.WriteValue(batchHeader);
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
@@ -149,11 +160,11 @@ namespace Unity.Netcode.EditorTests
}
[Test]
public void WhenReceivingAMessageAndProcessingMessageQueue_ReceiveMethodIsCalled()
public unsafe void WhenReceivingAMessageAndProcessingMessageQueue_ReceiveMethodIsCalled()
{
var batchHeader = new BatchHeader
{
BatchSize = 1
BatchCount = 1
};
var messageHeader = new MessageHeader
{
@@ -170,6 +181,17 @@ namespace Unity.Netcode.EditorTests
BytePacker.WriteValueBitPacked(writer, messageHeader.MessageSize);
writer.WriteValueSafe(message);
// Fill out the rest of the batch header
writer.Seek(0);
batchHeader = new BatchHeader
{
Magic = BatchHeader.MagicValue,
BatchSize = writer.Length,
BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
BatchCount = 1
};
writer.WriteValue(batchHeader);
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
@@ -184,11 +206,11 @@ namespace Unity.Netcode.EditorTests
}
[Test]
public void WhenReceivingMultipleMessagesAndProcessingMessageQueue_ReceiveMethodIsCalledMultipleTimes()
public unsafe void WhenReceivingMultipleMessagesAndProcessingMessageQueue_ReceiveMethodIsCalledMultipleTimes()
{
var batchHeader = new BatchHeader
{
BatchSize = 2
BatchCount = 2
};
var messageHeader = new MessageHeader
{
@@ -209,6 +231,17 @@ namespace Unity.Netcode.EditorTests
BytePacker.WriteValueBitPacked(writer, messageHeader.MessageSize);
writer.WriteValueSafe(message2);
// Fill out the rest of the batch header
writer.Seek(0);
batchHeader = new BatchHeader
{
Magic = BatchHeader.MagicValue,
BatchSize = writer.Length,
BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
BatchCount = 2
};
writer.WriteValue(batchHeader);
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{

8
Tests/Editor/Messaging/MessageSendingTests.cs
View File

@@ -155,7 +155,7 @@ namespace Unity.Netcode.EditorTests
{
var message = GetMessage();
var size = UnsafeUtility.SizeOf<TestMessage>() + 2; // MessageHeader packed with this message will be 2 bytes
for (var i = 0; i < 1300 / size; ++i)
for (var i = 0; i < (1300 - UnsafeUtility.SizeOf<BatchHeader>()) / size; ++i)
{
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
}
@@ -169,7 +169,7 @@ namespace Unity.Netcode.EditorTests
{
var message = GetMessage();
var size = UnsafeUtility.SizeOf<TestMessage>() + 2; // MessageHeader packed with this message will be 2 bytes
for (var i = 0; i < (1300 / size) + 1; ++i)
for (var i = 0; i < ((1300 - UnsafeUtility.SizeOf<BatchHeader>()) / size) + 1; ++i)
{
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
}
@@ -183,7 +183,7 @@ namespace Unity.Netcode.EditorTests
{
var message = GetMessage();
var size = UnsafeUtility.SizeOf<TestMessage>() + 2; // MessageHeader packed with this message will be 2 bytes
for (var i = 0; i < (1300 / size) + 1; ++i)
for (var i = 0; i < ((1300 - UnsafeUtility.SizeOf<BatchHeader>()) / size) + 1; ++i)
{
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, m_Clients);
}
@@ -229,7 +229,7 @@ namespace Unity.Netcode.EditorTests
using (reader)
{
reader.ReadValueSafe(out BatchHeader header);
Assert.AreEqual(2, header.BatchSize);
Assert.AreEqual(2, header.BatchCount);
MessageHeader messageHeader;

180
Tests/Editor/NetworkManagerConfigurationTests.cs
View File

@@ -1,6 +1,8 @@
using System.Collections.Generic;
using NUnit.Framework;
using UnityEngine;
using Unity.Netcode.Editor;
using Unity.Netcode.Transports.UTP;
using UnityEditor.SceneManagement;
using UnityEngine.SceneManagement;
using UnityEngine.TestTools;
@@ -105,12 +107,188 @@ namespace Unity.Netcode.EditorTests
networkManager.OnValidate();
// Expect a warning
LogAssert.Expect(LogType.Warning, $"[Netcode] {NetworkManager.PrefabDebugHelper(networkManager.NetworkConfig.NetworkPrefabs[0])} has child {nameof(NetworkObject)}(s) but they will not be spawned across the network (unsupported {nameof(NetworkPrefab)} setup)");
LogAssert.Expect(LogType.Warning, $"[Netcode] {NetworkManager.PrefabDebugHelper(networkManager.NetworkConfig.Prefabs.Prefabs[0])} has child {nameof(NetworkObject)}(s) but they will not be spawned across the network (unsupported {nameof(NetworkPrefab)} setup)");
// Clean up
Object.DestroyImmediate(networkManagerObject);
Object.DestroyImmediate(parent);
}
[Test]
public void WhenNetworkConfigContainsOldPrefabList_TheyMigrateProperlyToTheNewList()
{
var networkConfig = new NetworkConfig();
var regularPrefab = new GameObject("Regular Prefab").AddComponent<NetworkObject>();
var overriddenPrefab = new GameObject("Overridden Prefab").AddComponent<NetworkObject>();
var overridingTargetPrefab = new GameObject("Overriding Target Prefab").AddComponent<NetworkObject>();
var sourcePrefabToOverride = new GameObject("Overriding Source Prefab").AddComponent<NetworkObject>();
regularPrefab.GlobalObjectIdHash = 1;
overriddenPrefab.GlobalObjectIdHash = 2;
overridingTargetPrefab.GlobalObjectIdHash = 3;
sourcePrefabToOverride.GlobalObjectIdHash = 4;
networkConfig.OldPrefabList = new List<NetworkPrefab>();
networkConfig.OldPrefabList.Add(new NetworkPrefab { Prefab = regularPrefab.gameObject });
networkConfig.OldPrefabList.Add(new NetworkPrefab { Prefab = overriddenPrefab.gameObject, Override = NetworkPrefabOverride.Prefab, OverridingTargetPrefab = overridingTargetPrefab.gameObject, SourcePrefabToOverride = sourcePrefabToOverride.gameObject, SourceHashToOverride = 123456 });
networkConfig.InitializePrefabs();
Assert.IsNull(networkConfig.OldPrefabList);
Assert.IsNotNull(networkConfig.Prefabs);
Assert.IsNotNull(networkConfig.Prefabs.Prefabs);
Assert.AreEqual(2, networkConfig.Prefabs.Prefabs.Count);
Assert.AreSame(regularPrefab.gameObject, networkConfig.Prefabs.Prefabs[0].Prefab);
Assert.AreEqual(NetworkPrefabOverride.None, networkConfig.Prefabs.Prefabs[0].Override);
Assert.IsNull(networkConfig.Prefabs.Prefabs[0].SourcePrefabToOverride);
Assert.IsNull(networkConfig.Prefabs.Prefabs[0].OverridingTargetPrefab);
Assert.AreSame(overriddenPrefab.gameObject, networkConfig.Prefabs.Prefabs[1].Prefab);
Assert.AreEqual(NetworkPrefabOverride.Prefab, networkConfig.Prefabs.Prefabs[1].Override);
Assert.AreEqual(123456, networkConfig.Prefabs.Prefabs[1].SourceHashToOverride);
Assert.AreSame(sourcePrefabToOverride.gameObject, networkConfig.Prefabs.Prefabs[1].SourcePrefabToOverride);
Assert.AreSame(overridingTargetPrefab.gameObject, networkConfig.Prefabs.Prefabs[1].OverridingTargetPrefab);
}
[Test]
public void WhenModifyingPrefabListUsingNetworkManagerAPI_ModificationIsLocal()
{
// Setup
var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
var networkManager = networkManagerObject.AddComponent<NetworkManager>();
networkManager.NetworkConfig = new NetworkConfig();
networkManager.NetworkConfig.NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>();
var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
var networkManager2 = networkManagerObject2.AddComponent<NetworkManager>();
networkManager2.NetworkConfig = new NetworkConfig();
networkManager2.NetworkConfig.NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>();
var object1 = new GameObject("Object 1").AddComponent<NetworkObject>();
var object2 = new GameObject("Object 2").AddComponent<NetworkObject>();
var object3 = new GameObject("Object 3").AddComponent<NetworkObject>();
object1.GlobalObjectIdHash = 1;
object2.GlobalObjectIdHash = 2;
object3.GlobalObjectIdHash = 3;
var sharedList = ScriptableObject.CreateInstance<NetworkPrefabsList>();
sharedList.List.Add(new NetworkPrefab { Prefab = object1.gameObject });
networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
networkManager.Initialize(true);
networkManager2.Initialize(false);
networkManager.AddNetworkPrefab(object2.gameObject);
networkManager2.AddNetworkPrefab(object3.gameObject);
Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object1.gameObject));
Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object1.gameObject));
Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object2.gameObject));
Assert.IsFalse(networkManager2.NetworkConfig.Prefabs.Contains(object2.gameObject));
Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object3.gameObject));
Assert.IsFalse(networkManager.NetworkConfig.Prefabs.Contains(object3.gameObject));
Assert.IsTrue(sharedList.Contains(object1.gameObject));
Assert.IsFalse(sharedList.Contains(object2.gameObject));
Assert.IsFalse(sharedList.Contains(object3.gameObject));
}
[Test]
public void WhenModifyingPrefabListUsingPrefabsAPI_ModificationIsLocal()
{
// Setup
var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
var networkManager = networkManagerObject.AddComponent<NetworkManager>();
networkManager.NetworkConfig = new NetworkConfig();
networkManager.NetworkConfig.NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>();
var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
var networkManager2 = networkManagerObject2.AddComponent<NetworkManager>();
networkManager2.NetworkConfig = new NetworkConfig();
networkManager2.NetworkConfig.NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>();
var object1 = new GameObject("Object 1").AddComponent<NetworkObject>();
var object2 = new GameObject("Object 2").AddComponent<NetworkObject>();
var object3 = new GameObject("Object 3").AddComponent<NetworkObject>();
object1.GlobalObjectIdHash = 1;
object2.GlobalObjectIdHash = 2;
object3.GlobalObjectIdHash = 3;
var sharedList = ScriptableObject.CreateInstance<NetworkPrefabsList>();
sharedList.List.Add(new NetworkPrefab { Prefab = object1.gameObject });
networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
networkManager.Initialize(true);
networkManager2.Initialize(false);
networkManager.NetworkConfig.Prefabs.Add(new NetworkPrefab { Prefab = object2.gameObject });
networkManager2.NetworkConfig.Prefabs.Add(new NetworkPrefab { Prefab = object3.gameObject });
Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object1.gameObject));
Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object1.gameObject));
Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object2.gameObject));
Assert.IsFalse(networkManager2.NetworkConfig.Prefabs.Contains(object2.gameObject));
Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object3.gameObject));
Assert.IsFalse(networkManager.NetworkConfig.Prefabs.Contains(object3.gameObject));
Assert.IsTrue(sharedList.Contains(object1.gameObject));
Assert.IsFalse(sharedList.Contains(object2.gameObject));
Assert.IsFalse(sharedList.Contains(object3.gameObject));
}
[Test]
public void WhenModifyingPrefabListUsingPrefabsListAPI_ModificationIsShared()
{
// Setup
var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
var networkManager = networkManagerObject.AddComponent<NetworkManager>();
networkManager.NetworkConfig = new NetworkConfig();
networkManager.NetworkConfig.NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>();
var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
var networkManager2 = networkManagerObject2.AddComponent<NetworkManager>();
networkManager2.NetworkConfig = new NetworkConfig();
networkManager2.NetworkConfig.NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>();
var object1 = new GameObject("Object 1").AddComponent<NetworkObject>();
var object2 = new GameObject("Object 2").AddComponent<NetworkObject>();
var object3 = new GameObject("Object 3").AddComponent<NetworkObject>();
object1.GlobalObjectIdHash = 1;
object2.GlobalObjectIdHash = 2;
object3.GlobalObjectIdHash = 3;
var sharedList = ScriptableObject.CreateInstance<NetworkPrefabsList>();
sharedList.List.Add(new NetworkPrefab { Prefab = object1.gameObject });
networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
networkManager.Initialize(true);
networkManager2.Initialize(false);
networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists[0].Add(new NetworkPrefab { Prefab = object2.gameObject });
networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists[0].Add(new NetworkPrefab { Prefab = object3.gameObject });
Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object1.gameObject));
Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object1.gameObject));
Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object2.gameObject));
Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object2.gameObject));
Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object3.gameObject));
Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object3.gameObject));
Assert.IsTrue(sharedList.Contains(object1.gameObject));
Assert.IsTrue(sharedList.Contains(object2.gameObject));
Assert.IsTrue(sharedList.Contains(object3.gameObject));
}
}
}

90
Tests/Editor/NetworkPrefabProcessorTests.cs Normal file
View File

@@ -0,0 +1,90 @@
using NUnit.Framework;
using UnityEngine;
using Unity.Netcode.Editor.Configuration;
using UnityEditor;
namespace Unity.Netcode.EditorTests
{
public class NetworkPrefabProcessorTests
{
private NetcodeForGameObjectsProjectSettings m_Settings;
private bool m_EditorDefaultPrefabSetting;
private string m_EditorDefaultPrefabLocation;
private GameObject m_Prefab;
private const string k_PrefabName = "Assets/TestPrefab.prefab";
private const string k_DefaultAssetString = "Assets/TestPrefabList.asset";
[SetUp]
public void SetUp()
{
m_Settings = NetcodeForGameObjectsProjectSettings.instance;
m_EditorDefaultPrefabSetting = m_Settings.GenerateDefaultNetworkPrefabs;
m_EditorDefaultPrefabLocation = NetworkPrefabProcessor.DefaultNetworkPrefabsPath;
NetworkPrefabProcessor.DefaultNetworkPrefabsPath = k_DefaultAssetString;
}
[TearDown]
public void TearDown()
{
m_Settings.GenerateDefaultNetworkPrefabs = m_EditorDefaultPrefabSetting;
NetworkPrefabProcessor.DefaultNetworkPrefabsPath = m_EditorDefaultPrefabLocation;
AssetDatabase.DeleteAsset(k_PrefabName);
AssetDatabase.DeleteAsset(k_DefaultAssetString);
}
[Test]
public void WhenGenerateDefaultNetworkPrefabsIsEnabled_AddingAPrefabUpdatesDefaultPrefabList()
{
var obj = new GameObject("Object");
obj.AddComponent<NetworkObject>();
m_Settings.GenerateDefaultNetworkPrefabs = true;
m_Prefab = PrefabUtility.SaveAsPrefabAsset(obj, k_PrefabName);
Object.DestroyImmediate(obj);
var prefabList = NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out var isNew, false);
Assert.IsFalse(isNew);
Assert.IsTrue(prefabList.Contains(m_Prefab));
}
[Test]
public void WhenGenerateDefaultNetworkPrefabsIsEnabled_RemovingAPrefabUpdatesDefaultPrefabList()
{
WhenGenerateDefaultNetworkPrefabsIsEnabled_AddingAPrefabUpdatesDefaultPrefabList();
AssetDatabase.DeleteAsset(k_PrefabName);
var prefabList = NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out var isNew, false);
Assert.IsFalse(isNew);
Assert.IsFalse(prefabList.Contains(m_Prefab));
}
[Test]
public void WhenGenerateDefaultNetworkPrefabsIsNotEnabled_AddingAPrefabDoesNotUpdateDefaultPrefabList()
{
var obj = new GameObject("Object");
obj.AddComponent<NetworkObject>();
m_Settings.GenerateDefaultNetworkPrefabs = false;
m_Prefab = PrefabUtility.SaveAsPrefabAsset(obj, k_PrefabName);
Object.DestroyImmediate(obj);
var prefabList = NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out var isNew, false);
Assert.IsTrue(isNew);
Assert.IsFalse(prefabList.Contains(m_Prefab));
}
[Test]
public void WhenGenerateDefaultNetworkPrefabsIsNotEnabled_RemovingAPrefabDoesNotUpdateDefaultPrefabList()
{
// Add it with the list enabled, then disable the list. Removing it
// should then be nop.
WhenGenerateDefaultNetworkPrefabsIsEnabled_AddingAPrefabUpdatesDefaultPrefabList();
m_Settings.GenerateDefaultNetworkPrefabs = false;
AssetDatabase.DeleteAsset(k_PrefabName);
var prefabList = NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out var isNew, false);
Assert.IsFalse(isNew);
Assert.IsTrue(prefabList.Contains(m_Prefab));
}
}
}

3
Tests/Editor/NetworkPrefabProcessorTests.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 6471efe05b0548ef9d2171e07d4a561b
timeCreated: 1669140101

6
Tests/Editor/Transports/BatchedSendQueueTests.cs
View File

@@ -229,6 +229,12 @@ namespace Unity.Netcode.EditorTests
var writer = new DataStreamWriter(data);
Assert.AreEqual(messageLength, q.FillWriterWithMessages(ref writer));
AssertIsTestMessage(data);
q.Consume(messageLength);
writer = new DataStreamWriter(data);
Assert.AreEqual(messageLength, q.FillWriterWithMessages(ref writer));
AssertIsTestMessage(data);
}
[Test]

22
Tests/Editor/Transports/UnityTransportTests.cs
View File

@@ -115,13 +115,29 @@ namespace Unity.Netcode.EditorTests
UnityTransport transport = new GameObject().AddComponent<UnityTransport>();
transport.Initialize();
transport.SetConnectionData("127.0.0.", 4242);
transport.SetConnectionData("127.0.0.", 4242, "127.0.0.");
Assert.False(transport.StartServer());
LogAssert.Expect(LogType.Error, "Invalid network endpoint: 127.0.0.:4242.");
LogAssert.Expect(LogType.Error, "Server failed to bind");
#if UTP_TRANSPORT_2_0_ABOVE
LogAssert.Expect(LogType.Error, "Socket creation failed (error Unity.Baselib.LowLevel.Binding+Baselib_ErrorState: Invalid argument (0x01000003) <argument name stripped>");
#endif
LogAssert.Expect(LogType.Error, "Server failed to bind. This is usually caused by another process being bound to the same port.");
transport.SetConnectionData("127.0.0.1", 4242);
transport.SetConnectionData("127.0.0.1", 4242, "127.0.0.1");
Assert.True(transport.StartServer());
transport.Shutdown();
}
// Check that leaving all addresses empty is valid.
[Test]
public void UnityTransport_StartServerWithoutAddresses()
{
UnityTransport transport = new GameObject().AddComponent<UnityTransport>();
transport.Initialize();
transport.SetConnectionData(string.Empty, 4242);
Assert.True(transport.StartServer());
transport.Shutdown();

8
Tests/Runtime/AssemblyInfo.cs
View File

@@ -1,5 +1,11 @@
using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("TestProject.EditorTests")]
#if UNITY_INCLUDE_TESTS
[assembly: InternalsVisibleTo("TestProject.RuntimeTests")]
#if UNITY_EDITOR
[assembly: InternalsVisibleTo("TestProject.EditorTests")]
#endif // UNITY_EDITOR
#if MULTIPLAYER_TOOLS
[assembly: InternalsVisibleTo("TestProject.ToolsIntegration.RuntimeTests")]
#endif // MULTIPLAYER_TOOLS
#endif // UNITY_INCLUDE_TESTS

167
Tests/Runtime/InvalidConnectionEventsTest.cs Normal file
View File

@@ -0,0 +1,167 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using NUnit.Framework;
using Unity.Collections;
using UnityEngine.TestTools;
using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine;
using Debug = UnityEngine.Debug;
namespace Unity.Netcode.RuntimeTests
{
public class InvalidConnectionEventsTest : NetcodeIntegrationTest
{
protected override int NumberOfClients => 1;
public InvalidConnectionEventsTest() : base(HostOrServer.Server) { }
private class Hooks<TCatchType> : INetworkHooks
{
public void OnBeforeSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery) where T : INetworkMessage
{
}
public void OnAfterSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery, int messageSizeBytes) where T : INetworkMessage
{
}
public void OnBeforeReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
{
}
public void OnAfterReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
{
}
public void OnBeforeSendBatch(ulong clientId, int messageCount, int batchSizeInBytes, NetworkDelivery delivery)
{
}
public void OnAfterSendBatch(ulong clientId, int messageCount, int batchSizeInBytes, NetworkDelivery delivery)
{
}
public void OnBeforeReceiveBatch(ulong senderId, int messageCount, int batchSizeInBytes)
{
}
public void OnAfterReceiveBatch(ulong senderId, int messageCount, int batchSizeInBytes)
{
}
public bool OnVerifyCanSend(ulong destinationId, Type messageType, NetworkDelivery delivery)
{
return true;
}
public bool OnVerifyCanReceive(ulong senderId, Type messageType, FastBufferReader messageContent, ref NetworkContext context)
{
return true;
}
public void OnBeforeHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
{
if (typeof(T) == typeof(TCatchType))
{
Debug.Log("Woompa");
Assert.Fail($"{typeof(T).Name} was received when it should not have been.");
}
}
public void OnAfterHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
{
}
}
[UnityTest]
public IEnumerator WhenSendingConnectionApprovedToAlreadyConnectedClient_ConnectionApprovedMessageIsRejected()
{
var message = new ConnectionApprovedMessage();
m_ServerNetworkManager.SendMessage(ref message, NetworkDelivery.Reliable, m_ClientNetworkManagers[0].LocalClientId);
// Unnamed message is something to wait for. When this one is received,
// we know the above one has also reached its destination.
var writer = new FastBufferWriter(1, Allocator.Temp);
using (writer)
{
writer.WriteByteSafe(0);
m_ServerNetworkManager.CustomMessagingManager.SendUnnamedMessage(m_ClientNetworkManagers[0].LocalClientId, writer);
}
m_ClientNetworkManagers[0].MessagingSystem.Hook(new Hooks<ConnectionApprovedMessage>());
LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established\\. This should not happen\\."));
yield return WaitForMessageReceived<UnnamedMessage>(m_ClientNetworkManagers.ToList());
}
[UnityTest]
public IEnumerator WhenSendingConnectionRequestToAnyClient_ConnectionRequestMessageIsRejected()
{
var message = new ConnectionRequestMessage();
m_ServerNetworkManager.SendMessage(ref message, NetworkDelivery.Reliable, m_ClientNetworkManagers[0].LocalClientId);
// Unnamed message is something to wait for. When this one is received,
// we know the above one has also reached its destination.
var writer = new FastBufferWriter(1, Allocator.Temp);
using (writer)
{
writer.WriteByteSafe(0);
m_ServerNetworkManager.CustomMessagingManager.SendUnnamedMessage(m_ClientNetworkManagers[0].LocalClientId, writer);
}
m_ClientNetworkManagers[0].MessagingSystem.Hook(new Hooks<ConnectionRequestMessage>());
LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side\\. This should not happen\\."));
yield return WaitForMessageReceived<UnnamedMessage>(m_ClientNetworkManagers.ToList());
}
[UnityTest]
public IEnumerator WhenSendingConnectionRequestFromAlreadyConnectedClient_ConnectionRequestMessageIsRejected()
{
var message = new ConnectionRequestMessage();
m_ClientNetworkManagers[0].SendMessage(ref message, NetworkDelivery.Reliable, m_ServerNetworkManager.LocalClientId);
// Unnamed message is something to wait for. When this one is received,
// we know the above one has also reached its destination.
var writer = new FastBufferWriter(1, Allocator.Temp);
using (writer)
{
writer.WriteByteSafe(0);
m_ClientNetworkManagers[0].CustomMessagingManager.SendUnnamedMessage(m_ServerNetworkManager.LocalClientId, writer);
}
m_ServerNetworkManager.MessagingSystem.Hook(new Hooks<ConnectionRequestMessage>());
LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established\\. This should not happen\\."));
yield return WaitForMessageReceived<UnnamedMessage>(new List<NetworkManager> { m_ServerNetworkManager });
}
[UnityTest]
public IEnumerator WhenSendingConnectionApprovedFromAnyClient_ConnectionApprovedMessageIsRejected()
{
var message = new ConnectionApprovedMessage();
m_ClientNetworkManagers[0].SendMessage(ref message, NetworkDelivery.Reliable, m_ServerNetworkManager.LocalClientId);
// Unnamed message is something to wait for. When this one is received,
// we know the above one has also reached its destination.
var writer = new FastBufferWriter(1, Allocator.Temp);
using (writer)
{
writer.WriteByteSafe(0);
m_ClientNetworkManagers[0].CustomMessagingManager.SendUnnamedMessage(m_ServerNetworkManager.LocalClientId, writer);
}
m_ServerNetworkManager.MessagingSystem.Hook(new Hooks<ConnectionApprovedMessage>());
LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side\\. This should not happen\\."));
yield return WaitForMessageReceived<UnnamedMessage>(new List<NetworkManager> { m_ServerNetworkManager });
}
}
}

3
Tests/Runtime/InvalidConnectionEventsTest.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: c30dd8c697274dd195f0fa8b86a4cf9d
timeCreated: 1677003739

4
Tests/Runtime/Metrics/OwnershipChangeMetricsTests.cs
View File

@@ -25,10 +25,10 @@ namespace Unity.Netcode.RuntimeTests.Metrics
NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(m_NewNetworkPrefab);
var networkPrefab = new NetworkPrefab { Prefab = gameObject };
m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(networkPrefab);
m_ServerNetworkManager.NetworkConfig.Prefabs.Add(networkPrefab);
foreach (var client in m_ClientNetworkManagers)
{
client.NetworkConfig.NetworkPrefabs.Add(networkPrefab);
client.NetworkConfig.Prefabs.Add(networkPrefab);
}
base.OnServerAndClientsCreated();
}

31
Tests/Runtime/NetworkBehaviourGenericTests.cs
View File

@@ -1,5 +1,6 @@
using System.Collections;
using UnityEngine;
using NUnit.Framework;
using UnityEngine.TestTools;
using Unity.Netcode.TestHelpers.Runtime;
using Unity.Netcode.Components;
@@ -147,5 +148,35 @@ namespace Unity.Netcode.RuntimeTests
// (validating the fix)
Object.Destroy(parentObject);
}
protected override void OnPlayerPrefabGameObjectCreated()
{
// Adds the SimpleNetworkBehaviour before the NetworkObject
// for OnNetworkDespawnInvokedWhenClientDisconnects testing
m_PlayerPrefab.AddComponent<SimpleNetworkBehaviour>();
}
/// <summary>
/// This validates that upon a client disconnecting, the server-side
/// client's player clone will invoke NetworkBehaviour.OnNetworkDespawn
/// when the component precedes the NetworkObject component.(PR-2323)
/// </summary>
[UnityTest]
public IEnumerator OnNetworkDespawnInvokedWhenClientDisconnects()
{
m_AllowServerToStart = true;
// Now just start the Host
yield return StartServerAndClients();
// Now create and connect a new client
yield return CreateAndStartNewClient();
var serverSidePlayer = m_PlayerNetworkObjects[NetworkManager.ServerClientId][m_ClientNetworkManagers[0].LocalClientId].GetComponent<SimpleNetworkBehaviour>();
yield return StopOneClient(m_ClientNetworkManagers[0]);
Assert.True(serverSidePlayer.OnNetworkDespawnCalled, $"Server-side player clone did not invoke OnNetworkDespawn!");
}
}
}

10
Tests/Runtime/NetworkBehaviourUpdaterTests.cs
View File

@@ -183,6 +183,11 @@ namespace Unity.Netcode.RuntimeTests
/// </summary>
private IEnumerator StartClientsAndServer(bool useHost, int numberOfClients, GameObject prefabObject)
{
void AddNetworkPrefab(NetworkConfig config, NetworkPrefab prefab)
{
config.Prefabs.Add(prefab);
}
// Sanity check to make sure we are not trying to create more clients than we have available to use
Assert.True(numberOfClients <= m_ClientNetworkManagers.Length);
m_ActiveClientsForCurrentTest = new List<NetworkManager>();
@@ -194,12 +199,13 @@ namespace Unity.Netcode.RuntimeTests
}
// Add the prefab to be used for this particular test iteration
m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Prefab = prefabObject });
var np = new NetworkPrefab { Prefab = prefabObject };
AddNetworkPrefab(m_ServerNetworkManager.NetworkConfig, np);
m_ServerNetworkManager.NetworkConfig.TickRate = 30;
foreach (var clientManager in m_ActiveClientsForCurrentTest)
{
m_ServerNetworkManager.NetworkConfig.TickRate = 30;
clientManager.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Prefab = prefabObject });
AddNetworkPrefab(clientManager.NetworkConfig, np);
}
// Now spin everything up normally

26
Tests/Runtime/NetworkObject/NetworkObjectNetworkClientOwnedObjectsTests.cs
View File

@@ -15,32 +15,18 @@ namespace Unity.Netcode.RuntimeTests
}
protected override int NumberOfClients => 1;
private NetworkPrefab m_NetworkPrefab;
private GameObject m_NetworkObject;
protected override void OnServerAndClientsCreated()
{
// create prefab
var gameObject = new GameObject("ClientOwnedObject");
var networkObject = gameObject.AddComponent<NetworkObject>();
gameObject.AddComponent<DummyNetworkBehaviour>();
NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject);
m_NetworkPrefab = (new NetworkPrefab()
{
Prefab = gameObject
});
m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(m_NetworkPrefab);
foreach (var client in m_ClientNetworkManagers)
{
client.NetworkConfig.NetworkPrefabs.Add(m_NetworkPrefab);
}
m_NetworkObject = CreateNetworkObjectPrefab("ClientOwnedObject");
m_NetworkObject.gameObject.AddComponent<DummyNetworkBehaviour>();
}
[UnityTest]
public IEnumerator ChangeOwnershipOwnedObjectsAddTest()
{
NetworkObject serverObject = Object.Instantiate(m_NetworkPrefab.Prefab).GetComponent<NetworkObject>();
NetworkObject serverObject = m_NetworkObject.GetComponent<NetworkObject>();
serverObject.NetworkManagerOwner = m_ServerNetworkManager;
serverObject.Spawn();
@@ -64,7 +50,7 @@ namespace Unity.Netcode.RuntimeTests
[UnityTest]
public IEnumerator WhenOwnershipIsChanged_OwnershipValuesUpdateCorrectly()
{
NetworkObject serverObject = Object.Instantiate(m_NetworkPrefab.Prefab).GetComponent<NetworkObject>();
NetworkObject serverObject = m_NetworkObject.GetComponent<NetworkObject>();
serverObject.NetworkManagerOwner = m_ServerNetworkManager;
serverObject.Spawn();

17
Tests/Runtime/NetworkObject/NetworkObjectOnNetworkDespawnTests.cs
View File

@@ -40,21 +40,9 @@ namespace Unity.Netcode.RuntimeTests
{
Assert.IsTrue(NetcodeIntegrationTestHelpers.Create(1, out m_ServerHost, out m_Clients));
m_ObjectToSpawn = new GameObject();
m_NetworkObject = m_ObjectToSpawn.AddComponent<NetworkObject>();
m_ObjectToSpawn = NetcodeIntegrationTestHelpers.CreateNetworkObjectPrefab(nameof(NetworkObjectOnNetworkDespawnTests), m_ServerHost, m_Clients);
m_ObjectToSpawn.AddComponent<OnNetworkDespawnTestComponent>();
// Make it a prefab
NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(m_NetworkObject);
var networkPrefab = new NetworkPrefab();
networkPrefab.Prefab = m_ObjectToSpawn;
m_ServerHost.NetworkConfig.NetworkPrefabs.Add(networkPrefab);
foreach (var client in m_Clients)
{
client.NetworkConfig.NetworkPrefabs.Add(networkPrefab);
}
m_NetworkObject = m_ObjectToSpawn.GetComponent<NetworkObject>();
yield return null;
}
@@ -130,4 +118,3 @@ namespace Unity.Netcode.RuntimeTests
}
}
}

4
Tests/Runtime/NetworkObject/NetworkObjectSpawnManyObjectsTests.cs
View File

@@ -39,10 +39,10 @@ namespace Unity.Netcode.RuntimeTests
m_PrefabToSpawn = new NetworkPrefab() { Prefab = gameObject };
m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(m_PrefabToSpawn);
m_ServerNetworkManager.NetworkConfig.Prefabs.Add(m_PrefabToSpawn);
foreach (var client in m_ClientNetworkManagers)
{
client.NetworkConfig.NetworkPrefabs.Add(m_PrefabToSpawn);
client.NetworkConfig.Prefabs.Add(m_PrefabToSpawn);
}
}

4
Tests/Runtime/NetworkObject/NetworkObjectSynchronizationTests.cs
View File

@@ -78,13 +78,13 @@ namespace Unity.Netcode.RuntimeTests
{
networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety = m_VariableLengthSafety == VariableLengthSafety.EnabledNetVarSafety;
foreach (var networkPrefab in m_ServerNetworkManager.NetworkConfig.NetworkPrefabs)
foreach (var networkPrefab in m_ServerNetworkManager.NetworkConfig.Prefabs.Prefabs)
{
// To simulate a failure, we exclude the m_InValidNetworkPrefab from the connecting
// client's side.
if (networkPrefab.Prefab.name != m_InValidNetworkPrefab.name)
{
networkManager.NetworkConfig.NetworkPrefabs.Add(networkPrefab);
networkManager.NetworkConfig.Prefabs.Add(networkPrefab);
}
}
// Disable forcing the same prefabs to avoid failed connections

24
Tests/Runtime/NetworkPrefabHandlerTests.cs
View File

@@ -29,7 +29,7 @@ namespace Unity.Netcode.RuntimeTests
}
/// <summary>
/// Tests the NetwokConfig NetworkPrefabs initialization during NetworkManager's Init method to make sure that
/// Tests the NetwokConfig NetworkPrefabsList initialization during NetworkManager's Init method to make sure that
/// it will still initialize but remove the invalid prefabs
/// </summary>
[Test]
@@ -37,34 +37,34 @@ namespace Unity.Netcode.RuntimeTests
{
// Add null entry
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(null);
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(null);
// Add a NetworkPrefab with no prefab
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab());
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab());
// Add a NetworkPrefab override with an invalid hash
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 0 });
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 0 });
// Add a NetworkPrefab override with a valid hash but an invalid target prefab
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 654321, OverridingTargetPrefab = null });
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 654321, OverridingTargetPrefab = null });
// Add a NetworkPrefab override with a valid hash to override but an invalid target prefab
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourceHashToOverride = 654321, OverridingTargetPrefab = null });
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourceHashToOverride = 654321, OverridingTargetPrefab = null });
// Add a NetworkPrefab override with an invalid source prefab to override
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = null });
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = null });
// Add a NetworkPrefab override with a valid source prefab to override but an invalid target prefab
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = MakeValidNetworkPrefab(), OverridingTargetPrefab = null });
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = MakeValidNetworkPrefab(), OverridingTargetPrefab = null });
// Add a valid prefab
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Prefab = MakeValidNetworkPrefab() });
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Prefab = MakeValidNetworkPrefab() });
// Add a NetworkPrefab override with a valid hash and valid target prefab
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 11111111, OverridingTargetPrefab = MakeValidNetworkPrefab() });
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 11111111, OverridingTargetPrefab = MakeValidNetworkPrefab() });
// Add a NetworkPrefab override with a valid prefab and valid target prefab
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = MakeValidNetworkPrefab(), OverridingTargetPrefab = MakeValidNetworkPrefab() });
NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = MakeValidNetworkPrefab(), OverridingTargetPrefab = MakeValidNetworkPrefab() });
var exceptionOccurred = false;
try
@@ -79,7 +79,7 @@ namespace Unity.Netcode.RuntimeTests
Assert.False(exceptionOccurred);
// In the end we should only have 3 valid registered network prefabs
Assert.True(NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabOverrideLinks.Count == 3);
Assert.True(NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.Count == 3);
}
private const string k_PrefabObjectName = "NetworkPrefabHandlerTestObject";

198
Tests/Runtime/NetworkShowHideTests.cs
View File

@@ -14,6 +14,8 @@ namespace Unity.Netcode.RuntimeTests
public static ulong ClientIdToTarget;
public static bool Silent;
public static int ValueAfterOwnershipChange = 0;
public static Dictionary<ulong, ShowHideObject> ObjectsPerClientId = new Dictionary<ulong, ShowHideObject>();
public static List<ulong> ClientIdsRpcCalledOn;
public static NetworkObject GetNetworkObjectById(ulong networkObjectId)
{
@@ -44,6 +46,15 @@ namespace Unity.Netcode.RuntimeTests
Debug.Assert(MyListSetOnSpawn[0] == 45);
}
if (ObjectsPerClientId.ContainsKey(NetworkManager.LocalClientId))
{
ObjectsPerClientId[NetworkManager.LocalClientId] = this;
}
else
{
ObjectsPerClientId.Add(NetworkManager.LocalClientId, this);
}
base.OnNetworkSpawn();
}
@@ -59,6 +70,7 @@ namespace Unity.Netcode.RuntimeTests
public NetworkVariable<int> MyNetworkVariable;
public NetworkList<int> MyListSetOnSpawn;
public NetworkVariable<int> MyOwnerReadNetworkVariable;
public NetworkList<int> MyList;
static public NetworkManager NetworkManagerOfInterest;
internal static int GainOwnershipCount = 0;
@@ -70,6 +82,7 @@ namespace Unity.Netcode.RuntimeTests
MyNetworkVariable.OnValueChanged += Changed;
MyListSetOnSpawn = new NetworkList<int>();
MyList = new NetworkList<int>();
MyOwnerReadNetworkVariable = new NetworkVariable<int>(readPerm: NetworkVariableReadPermission.Owner);
MyOwnerReadNetworkVariable.OnValueChanged += OwnerReadChanged;
@@ -96,11 +109,26 @@ namespace Unity.Netcode.RuntimeTests
Debug.Log($"Value changed from {before} to {after}");
}
}
[ClientRpc]
public void SomeRandomClientRPC()
{
Debug.Log($"RPC called {NetworkManager.LocalClientId}");
if (ClientIdsRpcCalledOn != null)
{
ClientIdsRpcCalledOn.Add(NetworkManager.LocalClientId);
}
}
public void TriggerRpc()
{
SomeRandomClientRPC();
}
}
public class NetworkShowHideTests : NetcodeIntegrationTest
{
protected override int NumberOfClients => 2;
protected override int NumberOfClients => 4;
private ulong m_ClientId0;
private GameObject m_PrefabToSpawn;
@@ -124,7 +152,7 @@ namespace Unity.Netcode.RuntimeTests
int count = 0;
do
{
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5);
yield return WaitForTicks(m_ServerNetworkManager, 5);
count++;
if (count > 20)
@@ -240,11 +268,11 @@ namespace Unity.Netcode.RuntimeTests
// hide them on one client
Show(mode == 0, false);
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5);
yield return WaitForTicks(m_ServerNetworkManager, 5);
m_NetSpawnedObject1.GetComponent<ShowHideObject>().MyNetworkVariable.Value = 3;
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5);
yield return WaitForTicks(m_ServerNetworkManager, 5);
// verify they got hidden
yield return CheckVisible(false);
@@ -286,10 +314,10 @@ namespace Unity.Netcode.RuntimeTests
Show(mode == 0, false);
Show(mode == 0, true);
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5);
yield return WaitForTicks(m_ServerNetworkManager, 5);
yield return WaitForConditionOrTimeOut(RefreshNetworkObjects);
AssertOnTimeout($"Could not refresh all NetworkObjects!");
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5);
yield return WaitForTicks(m_ServerNetworkManager, 5);
// verify they become visible
yield return CheckVisible(true);
@@ -315,7 +343,7 @@ namespace Unity.Netcode.RuntimeTests
m_NetSpawnedObject1.NetworkHide(m_ClientId0);
m_NetSpawnedObject1.Despawn();
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5);
yield return WaitForTicks(m_ServerNetworkManager, 5);
LogAssert.NoUnexpectedReceived();
}
@@ -372,7 +400,7 @@ namespace Unity.Netcode.RuntimeTests
m_NetSpawnedObject1.GetComponent<ShowHideObject>().MyOwnerReadNetworkVariable.Value++;
// wait for three ticks
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 3);
yield return WaitForTicks(m_ServerNetworkManager, 3);
// check we'll actually be changing owners
Assert.False(ShowHideObject.ClientTargetedNetworkObjects[0].OwnerClientId == m_ClientNetworkManagers[0].LocalClientId);
@@ -384,8 +412,8 @@ namespace Unity.Netcode.RuntimeTests
m_NetSpawnedObject1.ChangeOwnership(m_ClientNetworkManagers[0].LocalClientId);
// wait three ticks
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 3);
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ClientNetworkManagers[0], 3);
yield return WaitForTicks(m_ServerNetworkManager, 3);
yield return WaitForTicks(m_ClientNetworkManagers[0], 3);
// verify ownership changed
Assert.True(ShowHideObject.ClientTargetedNetworkObjects[0].OwnerClientId == m_ClientNetworkManagers[0].LocalClientId);
@@ -394,5 +422,155 @@ namespace Unity.Netcode.RuntimeTests
Assert.True(ShowHideObject.ValueAfterOwnershipChange == 1);
}
private string Display(NetworkList<int> list)
{
string message = "";
foreach (var i in list)
{
message += $"{i}, ";
}
return message;
}
private void Compare(NetworkList<int> list1, NetworkList<int> list2)
{
if (list1.Count != list2.Count)
{
string message = $"{Display(list1)} versus {Display(list2)}";
Debug.Log(message);
}
else
{
for (var i = 0; i < list1.Count; i++)
{
if (list1[i] != list2[i])
{
string message = $"{Display(list1)} versus {Display(list2)}";
Debug.Log(message);
break;
}
}
}
Debug.Assert(list1.Count == list2.Count);
}
private IEnumerator HideThenShowAndHideThenModifyAndShow()
{
Debug.Log("Hiding");
// hide
m_NetSpawnedObject1.NetworkHide(1);
yield return WaitForTicks(m_ServerNetworkManager, 3);
yield return WaitForTicks(m_ClientNetworkManagers[0], 3);
Debug.Log("Showing and Hiding");
// show and hide
m_NetSpawnedObject1.NetworkShow(1);
m_NetSpawnedObject1.NetworkHide(1);
yield return WaitForTicks(m_ServerNetworkManager, 3);
yield return WaitForTicks(m_ClientNetworkManagers[0], 3);
Debug.Log("Modifying and Showing");
// modify and show
m_NetSpawnedObject1.GetComponent<ShowHideObject>().MyList.Add(5);
m_NetSpawnedObject1.NetworkShow(1);
yield return WaitForTicks(m_ServerNetworkManager, 3);
yield return WaitForTicks(m_ClientNetworkManagers[0], 3);
}
private IEnumerator HideThenModifyAndShow()
{
// hide
m_NetSpawnedObject1.NetworkHide(1);
yield return WaitForTicks(m_ServerNetworkManager, 3);
// modify
m_NetSpawnedObject1.GetComponent<ShowHideObject>().MyList.Add(5);
// show
m_NetSpawnedObject1.NetworkShow(1);
yield return WaitForTicks(m_ServerNetworkManager, 3);
yield return WaitForTicks(m_ClientNetworkManagers[0], 3);
}
private IEnumerator HideThenShowAndModify()
{
// hide
m_NetSpawnedObject1.NetworkHide(1);
yield return WaitForTicks(m_ServerNetworkManager, 3);
// show
m_NetSpawnedObject1.NetworkShow(1);
// modify
m_NetSpawnedObject1.GetComponent<ShowHideObject>().MyList.Add(5);
yield return WaitForTicks(m_ServerNetworkManager, 3);
yield return WaitForTicks(m_ClientNetworkManagers[0], 3);
}
private IEnumerator HideThenShowAndRPC()
{
// hide
m_NetSpawnedObject1.NetworkHide(1);
yield return WaitForTicks(m_ServerNetworkManager, 3);
// show
m_NetSpawnedObject1.NetworkShow(1);
m_NetSpawnedObject1.GetComponent<ShowHideObject>().TriggerRpc();
yield return WaitForTicks(m_ServerNetworkManager, 3);
}
[UnityTest]
public IEnumerator NetworkShowHideAroundListModify()
{
ShowHideObject.ClientTargetedNetworkObjects.Clear();
ShowHideObject.ClientIdToTarget = m_ClientNetworkManagers[1].LocalClientId;
ShowHideObject.Silent = true;
var spawnedObject1 = SpawnObject(m_PrefabToSpawn, m_ServerNetworkManager);
m_NetSpawnedObject1 = spawnedObject1.GetComponent<NetworkObject>();
// wait for host to have spawned and gained ownership
while (ShowHideObject.GainOwnershipCount == 0)
{
yield return new WaitForSeconds(0.0f);
}
for (int i = 0; i < 4; i++)
{
// wait for three ticks
yield return WaitForTicks(m_ServerNetworkManager, 3);
yield return WaitForTicks(m_ClientNetworkManagers[0], 3);
switch (i)
{
case 0:
Debug.Log("Running HideThenModifyAndShow");
yield return HideThenModifyAndShow();
break;
case 1:
Debug.Log("Running HideThenShowAndModify");
yield return HideThenShowAndModify();
break;
case 2:
Debug.Log("Running HideThenShowAndHideThenModifyAndShow");
yield return HideThenShowAndHideThenModifyAndShow();
break;
case 3:
Debug.Log("Running HideThenShowAndRPC");
ShowHideObject.ClientIdsRpcCalledOn = new List<ulong>();
yield return HideThenShowAndRPC();
// Provide enough time for slower systems or VM systems possibly under a heavy load could fail on this test
yield return WaitForConditionOrTimeOut(() => ShowHideObject.ClientIdsRpcCalledOn.Count == NumberOfClients + 1);
AssertOnTimeout($"Timed out waiting for ClientIdsRpcCalledOn.Count ({ShowHideObject.ClientIdsRpcCalledOn.Count}) to equal ({NumberOfClients + 1})!");
break;
}
Compare(ShowHideObject.ObjectsPerClientId[0].MyList, ShowHideObject.ObjectsPerClientId[1].MyList);
Compare(ShowHideObject.ObjectsPerClientId[0].MyList, ShowHideObject.ObjectsPerClientId[2].MyList);
}
}
}
}

2
Tests/Runtime/NetworkTransform/NetworkTransformTests.cs
View File

@@ -402,7 +402,7 @@ namespace Unity.Netcode.RuntimeTests
protected override void OnNewClientCreated(NetworkManager networkManager)
{
networkManager.NetworkConfig.NetworkPrefabs = m_ServerNetworkManager.NetworkConfig.NetworkPrefabs;
networkManager.NetworkConfig.Prefabs = m_ServerNetworkManager.NetworkConfig.Prefabs;
base.OnNewClientCreated(networkManager);
}

8
Tests/Runtime/NetworkVariableTests.cs
View File

@@ -236,7 +236,7 @@ namespace Unity.Netcode.RuntimeTests
int clientManagerIndex = m_ClientNetworkManagers.Length - 1;
var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId;
testObjServer.ChangeOwnership(newOwnerClientId);
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 2);
yield return WaitForTicks(m_ServerNetworkManager, 2);
yield return WaitForOwnerWritableAreEqualOnAll();
@@ -269,7 +269,7 @@ namespace Unity.Netcode.RuntimeTests
int clientManagerIndex = m_ClientNetworkManagers.Length - 1;
var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId;
testObjServer.ChangeOwnership(newOwnerClientId);
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 2);
yield return WaitForTicks(m_ServerNetworkManager, 2);
yield return WaitForOwnerWritableAreEqualOnAll();
@@ -301,7 +301,7 @@ namespace Unity.Netcode.RuntimeTests
int clientManagerIndex = m_ClientNetworkManagers.Length - 1;
var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId;
testObjServer.ChangeOwnership(newOwnerClientId);
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 2);
yield return WaitForTicks(m_ServerNetworkManager, 2);
yield return WaitForServerWritableAreEqualOnAll();
@@ -333,7 +333,7 @@ namespace Unity.Netcode.RuntimeTests
int clientManagerIndex = m_ClientNetworkManagers.Length - 1;
var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId;
testObjServer.ChangeOwnership(newOwnerClientId);
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 2);
yield return WaitForTicks(m_ServerNetworkManager, 2);
yield return WaitForOwnerWritableAreEqualOnAll();

4
Tests/Runtime/OwnerModifiedTests.cs
View File

@@ -91,10 +91,10 @@ namespace Unity.Netcode.RuntimeTests
ownerModLastClient.NetworkUpdateStageToCheck = (NetworkUpdateStage)updateLoopType;
Debug.Log($"Testing Update Stage: {ownerModLastClient.NetworkUpdateStageToCheck}");
ownerModLastClient.AddValues = true;
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5);
yield return WaitForTicks(m_ServerNetworkManager, 5);
}
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5);
yield return WaitForTicks(m_ServerNetworkManager, 5);
// We'll have at least one update per stage per client, if all goes well.
Assert.True(OwnerModifiedObject.Updates > 20);

6
Tests/Runtime/OwnerPermissionTests.cs
View File

@@ -197,9 +197,9 @@ namespace Unity.Netcode.RuntimeTests
// Verify client-owned networkList can only be written by owner
Debug.Assert(gotException == (clientWriting != objectIndex));
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5);
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ClientNetworkManagers[0], 5);
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ClientNetworkManagers[1], 5);
yield return WaitForTicks(m_ServerNetworkManager, 5);
yield return WaitForTicks(m_ClientNetworkManagers[0], 5);
yield return WaitForTicks(m_ClientNetworkManagers[1], 5);
OwnerPermissionObject.VerifyConsistency();
}

6
Tests/Runtime/Physics/NetworkRigidbody2DTest.cs
View File

@@ -53,7 +53,7 @@ namespace Unity.Netcode.RuntimeTests
Assert.IsNotNull(serverPlayer);
Assert.IsNotNull(clientPlayer);
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5);
yield return WaitForTicks(m_ServerNetworkManager, 5);
// server rigidbody has authority and should have a kinematic mode of false
Assert.True(serverPlayer.GetComponent<Rigidbody2D>().isKinematic == Kinematic);
@@ -66,12 +66,12 @@ namespace Unity.Netcode.RuntimeTests
// despawn the server player, (but keep it around on the server)
serverPlayer.GetComponent<NetworkObject>().Despawn(false);
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5);
yield return WaitForTicks(m_ServerNetworkManager, 5);
// This should equal Kinematic
Assert.IsTrue(serverPlayer.GetComponent<Rigidbody2D>().isKinematic == Kinematic);
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5);
yield return WaitForTicks(m_ServerNetworkManager, 5);
Assert.IsTrue(clientPlayer == null); // safety check that object is actually despawned.
}

6
Tests/Runtime/Physics/NetworkRigidbodyTest.cs
View File

@@ -40,7 +40,7 @@ namespace Unity.Netcode.RuntimeTests
Assert.IsNotNull(serverPlayer, "serverPlayer is not null");
Assert.IsNotNull(clientPlayer, "clientPlayer is not null");
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 3);
yield return WaitForTicks(m_ServerNetworkManager, 3);
// server rigidbody has authority and should not be kinematic
Assert.True(serverPlayer.GetComponent<Rigidbody>().isKinematic == false, "serverPlayer kinematic");
@@ -53,12 +53,12 @@ namespace Unity.Netcode.RuntimeTests
// despawn the server player (but keep it around on the server)
serverPlayer.GetComponent<NetworkObject>().Despawn(false);
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 3);
yield return WaitForTicks(m_ServerNetworkManager, 3);
// When despawned, we should always be kinematic (i.e. don't apply physics when despawned)
Assert.IsTrue(serverPlayer.GetComponent<Rigidbody>().isKinematic == true, "serverPlayer second kinematic");
yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 3);
yield return WaitForTicks(m_ServerNetworkManager, 3);
Assert.IsTrue(clientPlayer == null, "clientPlayer being null"); // safety check that object is actually despawned.
}

4
Tests/Runtime/RpcManyClientsTests.cs
View File

@@ -62,10 +62,10 @@ namespace Unity.Netcode.RuntimeTests
prefabToSpawn.AddComponent(type);
var networkObjectPrefab = prefabToSpawn.AddComponent<NetworkObject>();
NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObjectPrefab);
m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Prefab = prefabToSpawn });
m_ServerNetworkManager.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Prefab = prefabToSpawn });
foreach (var clientNetworkManager in m_ClientNetworkManagers)
{
clientNetworkManager.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Prefab = prefabToSpawn });
clientNetworkManager.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Prefab = prefabToSpawn });
}
return prefabToSpawn;
}