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.5.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.5.1] - 2023-06-07

### Added

- Added support for serializing `NativeArray<>` and `NativeList<>` in `FastBufferReader`/`FastBufferWriter`, `BufferSerializer`, `NetworkVariable`, and RPCs. (To use `NativeList<>`, add `UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT` to your Scripting Define Symbols in `Project Settings > Player`) (#2375)
- The location of the automatically-created default network prefab list can now be configured (#2544)
- Added: Message size limits (max single message and max fragmented message) can now be set using NetworkManager.MaximumTransmissionUnitSize and NetworkManager.MaximumFragmentedMessageSize for transports that don't work with the default values (#2530)
- Added `NetworkObject.SpawnWithObservers` property (default is true) that when set to false will spawn a `NetworkObject` with no observers and will not be spawned on any client until `NetworkObject.NetworkShow` is invoked. (#2568)

### Fixed

- Fixed: Fixed a null reference in codegen in some projects (#2581)
- Fixed issue where the `OnClientDisconnected` client identifier was incorrect after a pending client connection was denied. (#2569)
- Fixed warning "Runtime Network Prefabs was not empty at initialization time." being erroneously logged when no runtime network prefabs had been added (#2565)
- Fixed issue where some temporary debug console logging was left in a merged PR. (#2562)
- Fixed the "Generate Default Network Prefabs List" setting not loading correctly and always reverting to being checked. (#2545)
- Fixed issue where users could not use NetworkSceneManager.VerifySceneBeforeLoading to exclude runtime generated scenes from client synchronization. (#2550)
- Fixed missing value on `NetworkListEvent` for `EventType.RemoveAt` events.  (#2542,#2543)
- Fixed issue where parenting a NetworkTransform under a transform with a scale other than Vector3.one would result in incorrect values on non-authoritative instances. (#2538)
- Fixed issue where a server would include scene migrated and then despawned NetworkObjects to a client that was being synchronized. (#2532)
- Fixed the inspector throwing exceptions when attempting to render `NetworkVariable`s of enum types. (#2529)
- Making a `NetworkVariable` with an `INetworkSerializable` type that doesn't meet the `new()` constraint will now create a compile-time error instead of an editor crash (#2528)
- Fixed Multiplayer Tools package installation docs page link on the NetworkManager popup. (#2526)
- Fixed an exception and error logging when two different objects are shown and hidden on the same frame (#2524)
- Fixed a memory leak in `UnityTransport` that occurred if `StartClient` failed. (#2518)
- Fixed issue where a client could throw an exception if abruptly disconnected from a network session with one or more spawned `NetworkObject`(s). (#2510)
- Fixed issue where invalid endpoint addresses were not being detected and returning false from NGO UnityTransport. (#2496)
- Fixed some errors that could occur if a connection is lost and the loss is detected when attempting to write to the socket. (#2495)

## Changed

- Adding network prefabs before NetworkManager initialization is now supported. (#2565)
- Connecting clients being synchronized now switch to the server's active scene before spawning and synchronizing NetworkObjects. (#2532)
- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.4. (#2533)
- Improved performance of NetworkBehaviour initialization by replacing reflection when initializing NetworkVariables with compile-time code generation, which should help reduce hitching during additive scene loads. (#2522)
This commit is contained in:
Unity Technologies
2023-06-07 00:00:00 +00:00
parent b5abc3ff7c
commit 4d70c198bd
119 changed files with 11328 additions and 3164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
Tests/Editor/Messaging/DisconnectOnSendTests.cs Normal file
View File

@@ -0,0 +1,92 @@
using System.Collections.Generic;
using NUnit.Framework;
namespace Unity.Netcode.EditorTests
{
public class DisconnectOnSendTests
{
private struct TestMessage : INetworkMessage, INetworkSerializeByMemcpy
{
public void Serialize(FastBufferWriter writer, int targetVersion)
{
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
return true;
}
public void Handle(ref NetworkContext context)
{
}
public int Version => 0;
}
private class DisconnectOnSendMessageSender : INetworkMessageSender
{
public NetworkMessageManager MessageManager;
public void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData)
{
MessageManager.ClientDisconnected(clientId);
}
}
private class TestMessageProvider : INetworkMessageProvider
{
// Keep track of what we sent
private List<NetworkMessageManager.MessageWithHandler> m_MessageList = new List<NetworkMessageManager.MessageWithHandler>
{
new NetworkMessageManager.MessageWithHandler
{
MessageType = typeof(TestMessage),
Handler = NetworkMessageManager.ReceiveMessage<TestMessage>,
GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessage>
}
};
public List<NetworkMessageManager.MessageWithHandler> GetMessages()
{
return m_MessageList;
}
}
private TestMessageProvider m_TestMessageProvider;
private DisconnectOnSendMessageSender m_MessageSender;
private NetworkMessageManager m_MessageManager;
private ulong[] m_Clients = { 0 };
[SetUp]
public void SetUp()
{
m_MessageSender = new DisconnectOnSendMessageSender();
m_TestMessageProvider = new TestMessageProvider();
m_MessageManager = new NetworkMessageManager(m_MessageSender, this, m_TestMessageProvider);
m_MessageSender.MessageManager = m_MessageManager;
m_MessageManager.ClientConnected(0);
m_MessageManager.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
}
[TearDown]
public void TearDown()
{
m_MessageManager.Dispose();
}
private TestMessage GetMessage()
{
return new TestMessage();
}
[Test]
public void WhenDisconnectIsCalledDuringSend_NoErrorsOccur()
{
var message = GetMessage();
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
// This is where an exception would be thrown and logged.
m_MessageManager.ProcessSendQueues();
}
}
}

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

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 7984df99de5c4b85a1b8567582d00c64
timeCreated: 1680888331

38
Tests/Editor/Messaging/MessageCorruptionTests.cs
View File

@@ -39,17 +39,17 @@ namespace Unity.Netcode.EditorTests
public int Version => 0;
}
private class TestMessageProvider : IMessageProvider
private class TestMessageProvider : INetworkMessageProvider
{
public List<MessagingSystem.MessageWithHandler> GetMessages()
public List<NetworkMessageManager.MessageWithHandler> GetMessages()
{
return new List<MessagingSystem.MessageWithHandler>
return new List<NetworkMessageManager.MessageWithHandler>
{
new MessagingSystem.MessageWithHandler
new NetworkMessageManager.MessageWithHandler
{
MessageType = typeof(TestMessage),
Handler = MessagingSystem.ReceiveMessage<TestMessage>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessage>
Handler = NetworkMessageManager.ReceiveMessage<TestMessage>,
GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessage>
}
};
}
@@ -64,7 +64,7 @@ namespace Unity.Netcode.EditorTests
AdditionalGarbageData,
}
private class TestMessageSender : IMessageSender
private class TestMessageSender : INetworkMessageSender
{
public TypeOfCorruption Corruption;
@@ -108,7 +108,7 @@ namespace Unity.Netcode.EditorTests
}
}
private MessagingSystem m_MessagingSystem;
private NetworkMessageManager m_MessageManager;
private TestMessageSender m_MessageSender;
[SetUp]
@@ -118,16 +118,16 @@ namespace Unity.Netcode.EditorTests
TestMessage.Deserialized = false;
m_MessageSender = new TestMessageSender();
m_MessagingSystem = new MessagingSystem(m_MessageSender, this, new TestMessageProvider());
m_MessageManager = new NetworkMessageManager(m_MessageSender, this, new TestMessageProvider());
m_MessagingSystem.ClientConnected(0);
m_MessagingSystem.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
m_MessageManager.ClientConnected(0);
m_MessageManager.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
}
[TearDown]
public void TearDown()
{
m_MessagingSystem.Dispose();
m_MessageManager.Dispose();
}
private TestMessage GetMessage()
@@ -159,14 +159,14 @@ namespace Unity.Netcode.EditorTests
}
// Dummy batch header
var batchHeader = new BatchHeader
var batchHeader = new NetworkBatchHeader
{
BatchCount = 1
};
var messageHeader = new MessageHeader
var messageHeader = new NetworkMessageHeader
{
MessageSize = (ushort)UnsafeUtility.SizeOf<TestMessage>(),
MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)),
MessageType = m_MessageManager.GetMessageType(typeof(TestMessage)),
};
var message = GetMessage();
@@ -182,11 +182,11 @@ namespace Unity.Netcode.EditorTests
// Fill out the rest of the batch header
writer.Seek(0);
batchHeader = new BatchHeader
batchHeader = new NetworkBatchHeader
{
Magic = BatchHeader.MagicValue,
Magic = NetworkBatchHeader.MagicValue,
BatchSize = writer.Length,
BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), writer.Length - sizeof(NetworkBatchHeader)),
BatchCount = 1
};
writer.WriteValue(batchHeader);
@@ -194,7 +194,7 @@ namespace Unity.Netcode.EditorTests
var receivedMessage = m_MessageSender.MessageQueue[0];
m_MessageSender.MessageQueue.Clear();
m_MessagingSystem.HandleIncomingData(0, new ArraySegment<byte>(receivedMessage), 0);
m_MessageManager.HandleIncomingData(0, new ArraySegment<byte>(receivedMessage), 0);
Assert.IsFalse(TestMessage.Deserialized);
Assert.IsFalse(TestMessage.Handled);
}

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

@@ -39,23 +39,23 @@ namespace Unity.Netcode.EditorTests
public int Version => 0;
}
private class TestMessageProvider : IMessageProvider
private class TestMessageProvider : INetworkMessageProvider
{
public List<MessagingSystem.MessageWithHandler> GetMessages()
public List<NetworkMessageManager.MessageWithHandler> GetMessages()
{
return new List<MessagingSystem.MessageWithHandler>
return new List<NetworkMessageManager.MessageWithHandler>
{
new MessagingSystem.MessageWithHandler
new NetworkMessageManager.MessageWithHandler
{
MessageType = typeof(TestMessage),
Handler = MessagingSystem.ReceiveMessage<TestMessage>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessage>
Handler = NetworkMessageManager.ReceiveMessage<TestMessage>,
GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessage>
}
};
}
}
private MessagingSystem m_MessagingSystem;
private NetworkMessageManager m_MessageManager;
[SetUp]
public void SetUp()
@@ -64,14 +64,14 @@ namespace Unity.Netcode.EditorTests
TestMessage.Handled = false;
TestMessage.DeserializedValues.Clear();
m_MessagingSystem = new MessagingSystem(new NopMessageSender(), this, new TestMessageProvider());
m_MessagingSystem.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
m_MessageManager = new NetworkMessageManager(new NopMessageSender(), this, new TestMessageProvider());
m_MessageManager.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
}
[TearDown]
public void TearDown()
{
m_MessagingSystem.Dispose();
m_MessageManager.Dispose();
}
private TestMessage GetMessage()
@@ -88,10 +88,10 @@ namespace Unity.Netcode.EditorTests
[Test]
public void WhenHandlingAMessage_ReceiveMethodIsCalled()
{
var messageHeader = new MessageHeader
var messageHeader = new NetworkMessageHeader
{
MessageSize = (ushort)UnsafeUtility.SizeOf<TestMessage>(),
MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)),
MessageType = m_MessageManager.GetMessageType(typeof(TestMessage)),
};
var message = GetMessage();
@@ -104,7 +104,7 @@ namespace Unity.Netcode.EditorTests
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
m_MessagingSystem.HandleMessage(messageHeader, reader, 0, 0, 0);
m_MessageManager.HandleMessage(messageHeader, reader, 0, 0, 0);
Assert.IsTrue(TestMessage.Deserialized);
Assert.IsTrue(TestMessage.Handled);
Assert.AreEqual(1, TestMessage.DeserializedValues.Count);
@@ -116,14 +116,14 @@ namespace Unity.Netcode.EditorTests
[Test]
public unsafe void WhenHandlingIncomingData_ReceiveIsNotCalledBeforeProcessingIncomingMessageQueue()
{
var batchHeader = new BatchHeader
var batchHeader = new NetworkBatchHeader
{
BatchCount = 1
};
var messageHeader = new MessageHeader
var messageHeader = new NetworkMessageHeader
{
MessageSize = (ushort)UnsafeUtility.SizeOf<TestMessage>(),
MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)),
MessageType = m_MessageManager.GetMessageType(typeof(TestMessage)),
};
var message = GetMessage();
@@ -139,11 +139,11 @@ namespace Unity.Netcode.EditorTests
// Fill out the rest of the batch header
writer.Seek(0);
batchHeader = new BatchHeader
batchHeader = new NetworkBatchHeader
{
Magic = BatchHeader.MagicValue,
Magic = NetworkBatchHeader.MagicValue,
BatchSize = writer.Length,
BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), writer.Length - sizeof(NetworkBatchHeader)),
BatchCount = 1
};
writer.WriteValue(batchHeader);
@@ -151,7 +151,7 @@ namespace Unity.Netcode.EditorTests
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
m_MessagingSystem.HandleIncomingData(0, new ArraySegment<byte>(writer.ToArray()), 0);
m_MessageManager.HandleIncomingData(0, new ArraySegment<byte>(writer.ToArray()), 0);
Assert.IsFalse(TestMessage.Deserialized);
Assert.IsFalse(TestMessage.Handled);
Assert.IsEmpty(TestMessage.DeserializedValues);
@@ -162,14 +162,14 @@ namespace Unity.Netcode.EditorTests
[Test]
public unsafe void WhenReceivingAMessageAndProcessingMessageQueue_ReceiveMethodIsCalled()
{
var batchHeader = new BatchHeader
var batchHeader = new NetworkBatchHeader
{
BatchCount = 1
};
var messageHeader = new MessageHeader
var messageHeader = new NetworkMessageHeader
{
MessageSize = (uint)UnsafeUtility.SizeOf<TestMessage>(),
MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)),
MessageType = m_MessageManager.GetMessageType(typeof(TestMessage)),
};
var message = GetMessage();
@@ -183,11 +183,11 @@ namespace Unity.Netcode.EditorTests
// Fill out the rest of the batch header
writer.Seek(0);
batchHeader = new BatchHeader
batchHeader = new NetworkBatchHeader
{
Magic = BatchHeader.MagicValue,
Magic = NetworkBatchHeader.MagicValue,
BatchSize = writer.Length,
BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), writer.Length - sizeof(NetworkBatchHeader)),
BatchCount = 1
};
writer.WriteValue(batchHeader);
@@ -195,8 +195,8 @@ namespace Unity.Netcode.EditorTests
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
m_MessagingSystem.HandleIncomingData(0, new ArraySegment<byte>(writer.ToArray()), 0);
m_MessagingSystem.ProcessIncomingMessageQueue();
m_MessageManager.HandleIncomingData(0, new ArraySegment<byte>(writer.ToArray()), 0);
m_MessageManager.ProcessIncomingMessageQueue();
Assert.IsTrue(TestMessage.Deserialized);
Assert.IsTrue(TestMessage.Handled);
Assert.AreEqual(1, TestMessage.DeserializedValues.Count);
@@ -208,14 +208,14 @@ namespace Unity.Netcode.EditorTests
[Test]
public unsafe void WhenReceivingMultipleMessagesAndProcessingMessageQueue_ReceiveMethodIsCalledMultipleTimes()
{
var batchHeader = new BatchHeader
var batchHeader = new NetworkBatchHeader
{
BatchCount = 2
};
var messageHeader = new MessageHeader
var messageHeader = new NetworkMessageHeader
{
MessageSize = (ushort)UnsafeUtility.SizeOf<TestMessage>(),
MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)),
MessageType = m_MessageManager.GetMessageType(typeof(TestMessage)),
};
var message = GetMessage();
var message2 = GetMessage();
@@ -233,11 +233,11 @@ namespace Unity.Netcode.EditorTests
// Fill out the rest of the batch header
writer.Seek(0);
batchHeader = new BatchHeader
batchHeader = new NetworkBatchHeader
{
Magic = BatchHeader.MagicValue,
Magic = NetworkBatchHeader.MagicValue,
BatchSize = writer.Length,
BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), writer.Length - sizeof(NetworkBatchHeader)),
BatchCount = 2
};
writer.WriteValue(batchHeader);
@@ -245,12 +245,12 @@ namespace Unity.Netcode.EditorTests
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
m_MessagingSystem.HandleIncomingData(0, new ArraySegment<byte>(writer.ToArray()), 0);
m_MessageManager.HandleIncomingData(0, new ArraySegment<byte>(writer.ToArray()), 0);
Assert.IsFalse(TestMessage.Deserialized);
Assert.IsFalse(TestMessage.Handled);
Assert.IsEmpty(TestMessage.DeserializedValues);
m_MessagingSystem.ProcessIncomingMessageQueue();
m_MessageManager.ProcessIncomingMessageQueue();
Assert.IsTrue(TestMessage.Deserialized);
Assert.IsTrue(TestMessage.Handled);
Assert.AreEqual(2, TestMessage.DeserializedValues.Count);

90
Tests/Editor/Messaging/MessageRegistrationTests.cs
View File

@@ -48,23 +48,23 @@ namespace Unity.Netcode.EditorTests
public int Version => 0;
}
private class TestMessageProviderOne : IMessageProvider
private class TestMessageProviderOne : INetworkMessageProvider
{
public List<MessagingSystem.MessageWithHandler> GetMessages()
public List<NetworkMessageManager.MessageWithHandler> GetMessages()
{
return new List<MessagingSystem.MessageWithHandler>
return new List<NetworkMessageManager.MessageWithHandler>
{
new MessagingSystem.MessageWithHandler
new NetworkMessageManager.MessageWithHandler
{
MessageType = typeof(TestMessageOne),
Handler = MessagingSystem.ReceiveMessage<TestMessageOne>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessageOne>
Handler = NetworkMessageManager.ReceiveMessage<TestMessageOne>,
GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessageOne>
},
new MessagingSystem.MessageWithHandler
new NetworkMessageManager.MessageWithHandler
{
MessageType = typeof(TestMessageTwo),
Handler = MessagingSystem.ReceiveMessage<TestMessageTwo>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessageTwo>
Handler = NetworkMessageManager.ReceiveMessage<TestMessageTwo>,
GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessageTwo>
}
};
}
@@ -91,17 +91,17 @@ namespace Unity.Netcode.EditorTests
public int Version => 0;
}
private class TestMessageProviderTwo : IMessageProvider
private class TestMessageProviderTwo : INetworkMessageProvider
{
public List<MessagingSystem.MessageWithHandler> GetMessages()
public List<NetworkMessageManager.MessageWithHandler> GetMessages()
{
return new List<MessagingSystem.MessageWithHandler>
return new List<NetworkMessageManager.MessageWithHandler>
{
new MessagingSystem.MessageWithHandler
new NetworkMessageManager.MessageWithHandler
{
MessageType = typeof(TestMessageThree),
Handler = MessagingSystem.ReceiveMessage<TestMessageThree>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessageThree>
Handler = NetworkMessageManager.ReceiveMessage<TestMessageThree>,
GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessageThree>
}
};
}
@@ -127,17 +127,17 @@ namespace Unity.Netcode.EditorTests
public int Version => 0;
}
private class TestMessageProviderThree : IMessageProvider
private class TestMessageProviderThree : INetworkMessageProvider
{
public List<MessagingSystem.MessageWithHandler> GetMessages()
public List<NetworkMessageManager.MessageWithHandler> GetMessages()
{
return new List<MessagingSystem.MessageWithHandler>
return new List<NetworkMessageManager.MessageWithHandler>
{
new MessagingSystem.MessageWithHandler
new NetworkMessageManager.MessageWithHandler
{
MessageType = typeof(TestMessageFour),
Handler = MessagingSystem.ReceiveMessage<TestMessageFour>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessageFour>
Handler = NetworkMessageManager.ReceiveMessage<TestMessageFour>,
GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessageFour>
}
};
}
@@ -148,9 +148,9 @@ namespace Unity.Netcode.EditorTests
{
var sender = new NopMessageSender();
using var systemOne = new MessagingSystem(sender, null, new TestMessageProviderOne());
using var systemTwo = new MessagingSystem(sender, null, new TestMessageProviderTwo());
using var systemThree = new MessagingSystem(sender, null, new TestMessageProviderThree());
using var systemOne = new NetworkMessageManager(sender, null, new TestMessageProviderOne());
using var systemTwo = new NetworkMessageManager(sender, null, new TestMessageProviderTwo());
using var systemThree = new NetworkMessageManager(sender, null, new TestMessageProviderThree());
using (systemOne)
using (systemTwo)
@@ -172,18 +172,18 @@ namespace Unity.Netcode.EditorTests
{
var sender = new NopMessageSender();
using var systemOne = new MessagingSystem(sender, null, new TestMessageProviderOne());
using var systemTwo = new MessagingSystem(sender, null, new TestMessageProviderTwo());
using var systemThree = new MessagingSystem(sender, null, new TestMessageProviderThree());
using var systemOne = new NetworkMessageManager(sender, null, new TestMessageProviderOne());
using var systemTwo = new NetworkMessageManager(sender, null, new TestMessageProviderTwo());
using var systemThree = new NetworkMessageManager(sender, null, new TestMessageProviderThree());
using (systemOne)
using (systemTwo)
using (systemThree)
{
MessagingSystem.MessageHandler handlerOne = MessagingSystem.ReceiveMessage<TestMessageOne>;
MessagingSystem.MessageHandler handlerTwo = MessagingSystem.ReceiveMessage<TestMessageTwo>;
MessagingSystem.MessageHandler handlerThree = MessagingSystem.ReceiveMessage<TestMessageThree>;
MessagingSystem.MessageHandler handlerFour = MessagingSystem.ReceiveMessage<TestMessageFour>;
NetworkMessageManager.MessageHandler handlerOne = NetworkMessageManager.ReceiveMessage<TestMessageOne>;
NetworkMessageManager.MessageHandler handlerTwo = NetworkMessageManager.ReceiveMessage<TestMessageTwo>;
NetworkMessageManager.MessageHandler handlerThree = NetworkMessageManager.ReceiveMessage<TestMessageThree>;
NetworkMessageManager.MessageHandler handlerFour = NetworkMessageManager.ReceiveMessage<TestMessageFour>;
Assert.AreEqual(handlerOne, systemOne.MessageHandlers[systemOne.GetMessageType(typeof(TestMessageOne))]);
Assert.AreEqual(handlerTwo, systemOne.MessageHandlers[systemOne.GetMessageType(typeof(TestMessageTwo))]);
@@ -216,29 +216,29 @@ namespace Unity.Netcode.EditorTests
}
#pragma warning restore IDE1006
internal class OrderingMessageProvider : IMessageProvider
internal class OrderingMessageProvider : INetworkMessageProvider
{
public List<MessagingSystem.MessageWithHandler> GetMessages()
public List<NetworkMessageManager.MessageWithHandler> GetMessages()
{
var listMessages = new List<MessagingSystem.MessageWithHandler>();
var listMessages = new List<NetworkMessageManager.MessageWithHandler>();
var messageWithHandler = new MessagingSystem.MessageWithHandler
var messageWithHandler = new NetworkMessageManager.MessageWithHandler
{
MessageType = typeof(zzzLateLexicographicNetworkMessage),
GetVersion = MessagingSystem.CreateMessageAndGetVersion<zzzLateLexicographicNetworkMessage>
GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<zzzLateLexicographicNetworkMessage>
};
listMessages.Add(messageWithHandler);
messageWithHandler.MessageType = typeof(ConnectionRequestMessage);
messageWithHandler.GetVersion = MessagingSystem.CreateMessageAndGetVersion<ConnectionRequestMessage>;
messageWithHandler.GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<ConnectionRequestMessage>;
listMessages.Add(messageWithHandler);
messageWithHandler.MessageType = typeof(ConnectionApprovedMessage);
messageWithHandler.GetVersion = MessagingSystem.CreateMessageAndGetVersion<ConnectionApprovedMessage>;
messageWithHandler.GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<ConnectionApprovedMessage>;
listMessages.Add(messageWithHandler);
messageWithHandler.MessageType = typeof(AAAEarlyLexicographicNetworkMessage);
messageWithHandler.GetVersion = MessagingSystem.CreateMessageAndGetVersion<AAAEarlyLexicographicNetworkMessage>;
messageWithHandler.GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<AAAEarlyLexicographicNetworkMessage>;
listMessages.Add(messageWithHandler);
return listMessages;
@@ -250,18 +250,18 @@ namespace Unity.Netcode.EditorTests
{
var sender = new NopMessageSender();
var provider = new OrderingMessageProvider();
using var messagingSystem = new MessagingSystem(sender, null, provider);
using var messageManager = new NetworkMessageManager(sender, null, provider);
// the 2 priority messages should appear first, in lexicographic order
Assert.AreEqual(messagingSystem.MessageTypes[0], typeof(ConnectionApprovedMessage));
Assert.AreEqual(messagingSystem.MessageTypes[1], typeof(ConnectionRequestMessage));
Assert.AreEqual(messageManager.MessageTypes[0], typeof(ConnectionApprovedMessage));
Assert.AreEqual(messageManager.MessageTypes[1], typeof(ConnectionRequestMessage));
// the other should follow after
Assert.AreEqual(messagingSystem.MessageTypes[2], typeof(AAAEarlyLexicographicNetworkMessage));
Assert.AreEqual(messagingSystem.MessageTypes[3], typeof(zzzLateLexicographicNetworkMessage));
Assert.AreEqual(messageManager.MessageTypes[2], typeof(AAAEarlyLexicographicNetworkMessage));
Assert.AreEqual(messageManager.MessageTypes[3], typeof(zzzLateLexicographicNetworkMessage));
// there should not be any extras
Assert.AreEqual(messagingSystem.MessageHandlerCount, 4);
Assert.AreEqual(messageManager.MessageHandlerCount, 4);
}
}
}

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

@@ -18,6 +18,7 @@ namespace Unity.Netcode.EditorTests
public int B;
public int C;
public static bool Serialized;
public void Serialize(FastBufferWriter writer, int targetVersion)
{
Serialized = true;
@@ -36,7 +37,7 @@ namespace Unity.Netcode.EditorTests
public int Version => 0;
}
private class TestMessageSender : IMessageSender
private class TestMessageSender : INetworkMessageSender
{
public List<byte[]> MessageQueue = new List<byte[]>();
@@ -46,30 +47,31 @@ namespace Unity.Netcode.EditorTests
}
}
private class TestMessageProvider : IMessageProvider, IDisposable
private class TestMessageProvider : INetworkMessageProvider, IDisposable
{
// Keep track of what we sent
private List<List<MessagingSystem.MessageWithHandler>> m_CachedMessages = new List<List<MessagingSystem.MessageWithHandler>>();
private List<List<NetworkMessageManager.MessageWithHandler>> m_CachedMessages = new List<List<NetworkMessageManager.MessageWithHandler>>();
public void Dispose()
{
foreach (var cachedItem in m_CachedMessages)
{
// Clear out any references to MessagingSystem.MessageWithHandlers
// Clear out any references to NetworkMessageManager.MessageWithHandlers
cachedItem.Clear();
}
m_CachedMessages.Clear();
}
public List<MessagingSystem.MessageWithHandler> GetMessages()
public List<NetworkMessageManager.MessageWithHandler> GetMessages()
{
var messageList = new List<MessagingSystem.MessageWithHandler>
var messageList = new List<NetworkMessageManager.MessageWithHandler>
{
new MessagingSystem.MessageWithHandler
new NetworkMessageManager.MessageWithHandler
{
MessageType = typeof(TestMessage),
Handler = MessagingSystem.ReceiveMessage<TestMessage>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessage>
Handler = NetworkMessageManager.ReceiveMessage<TestMessage>,
GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessage>
}
};
// Track messages sent
@@ -80,7 +82,7 @@ namespace Unity.Netcode.EditorTests
private TestMessageProvider m_TestMessageProvider;
private TestMessageSender m_MessageSender;
private MessagingSystem m_MessagingSystem;
private NetworkMessageManager m_MessageManager;
private ulong[] m_Clients = { 0 };
[SetUp]
@@ -89,16 +91,16 @@ namespace Unity.Netcode.EditorTests
TestMessage.Serialized = false;
m_MessageSender = new TestMessageSender();
m_TestMessageProvider = new TestMessageProvider();
m_MessagingSystem = new MessagingSystem(m_MessageSender, this, m_TestMessageProvider);
m_MessagingSystem.ClientConnected(0);
m_MessagingSystem.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
m_MessageManager = new NetworkMessageManager(m_MessageSender, this, m_TestMessageProvider);
m_MessageManager.ClientConnected(0);
m_MessageManager.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
}
[TearDown]
public void TearDown()
{
m_TestMessageProvider.Dispose();
m_MessagingSystem.Dispose();
m_MessageManager.Dispose();
}
private TestMessage GetMessage()
@@ -116,7 +118,7 @@ namespace Unity.Netcode.EditorTests
public void WhenSendingMessage_SerializeIsCalled()
{
var message = GetMessage();
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
Assert.IsTrue(TestMessage.Serialized);
}
@@ -124,7 +126,7 @@ namespace Unity.Netcode.EditorTests
public void WhenSendingMessage_NothingIsSentBeforeProcessingSendQueue()
{
var message = GetMessage();
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
Assert.IsEmpty(m_MessageSender.MessageQueue);
}
@@ -132,9 +134,9 @@ namespace Unity.Netcode.EditorTests
public void WhenProcessingSendQueue_MessageIsSent()
{
var message = GetMessage();
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessagingSystem.ProcessSendQueues();
m_MessageManager.ProcessSendQueues();
Assert.AreEqual(1, m_MessageSender.MessageQueue.Count);
}
@@ -142,11 +144,11 @@ namespace Unity.Netcode.EditorTests
public void WhenSendingMultipleMessages_MessagesAreBatched()
{
var message = GetMessage();
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessagingSystem.ProcessSendQueues();
m_MessageManager.ProcessSendQueues();
Assert.AreEqual(1, m_MessageSender.MessageQueue.Count);
}
@@ -155,40 +157,42 @@ 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 - UnsafeUtility.SizeOf<BatchHeader>()) / size; ++i)
for (var i = 0; i < (m_MessageManager.NonFragmentedMessageMaxSize - UnsafeUtility.SizeOf<NetworkBatchHeader>()) / size; ++i)
{
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
}
m_MessagingSystem.ProcessSendQueues();
m_MessageManager.ProcessSendQueues();
Assert.AreEqual(1, m_MessageSender.MessageQueue.Count);
}
[Test]
public void WhenExceedingBatchSize_NewBatchesAreCreated()
public void WhenExceedingBatchSize_NewBatchesAreCreated([Values(500, 1000, 1300, 2000)] int maxMessageSize)
{
var message = GetMessage();
m_MessageManager.NonFragmentedMessageMaxSize = maxMessageSize;
var size = UnsafeUtility.SizeOf<TestMessage>() + 2; // MessageHeader packed with this message will be 2 bytes
for (var i = 0; i < ((1300 - UnsafeUtility.SizeOf<BatchHeader>()) / size) + 1; ++i)
for (var i = 0; i < ((m_MessageManager.NonFragmentedMessageMaxSize - UnsafeUtility.SizeOf<NetworkBatchHeader>()) / size) + 1; ++i)
{
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
}
m_MessagingSystem.ProcessSendQueues();
m_MessageManager.ProcessSendQueues();
Assert.AreEqual(2, m_MessageSender.MessageQueue.Count);
}
[Test]
public void WhenExceedingMTUSizeWithFragmentedDelivery_NewBatchesAreNotCreated()
public void WhenExceedingMTUSizeWithFragmentedDelivery_NewBatchesAreNotCreated([Values(500, 1000, 1300, 2000)] int maxMessageSize)
{
var message = GetMessage();
m_MessageManager.NonFragmentedMessageMaxSize = maxMessageSize;
var size = UnsafeUtility.SizeOf<TestMessage>() + 2; // MessageHeader packed with this message will be 2 bytes
for (var i = 0; i < ((1300 - UnsafeUtility.SizeOf<BatchHeader>()) / size) + 1; ++i)
for (var i = 0; i < ((m_MessageManager.NonFragmentedMessageMaxSize - UnsafeUtility.SizeOf<NetworkBatchHeader>()) / size) + 1; ++i)
{
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, m_Clients);
}
m_MessagingSystem.ProcessSendQueues();
m_MessageManager.ProcessSendQueues();
Assert.AreEqual(1, m_MessageSender.MessageQueue.Count);
}
@@ -196,11 +200,11 @@ namespace Unity.Netcode.EditorTests
public void WhenSwitchingDelivery_NewBatchesAreCreated()
{
var message = GetMessage();
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Unreliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Unreliable, m_Clients);
m_MessagingSystem.ProcessSendQueues();
m_MessageManager.ProcessSendQueues();
Assert.AreEqual(2, m_MessageSender.MessageQueue.Count);
}
@@ -208,11 +212,11 @@ namespace Unity.Netcode.EditorTests
public void WhenSwitchingChannel_NewBatchesAreNotCreated()
{
var message = GetMessage();
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessagingSystem.ProcessSendQueues();
m_MessageManager.ProcessSendQueues();
Assert.AreEqual(1, m_MessageSender.MessageQueue.Count);
}
@@ -221,22 +225,22 @@ namespace Unity.Netcode.EditorTests
{
var message = GetMessage();
var message2 = GetMessage();
m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessagingSystem.SendMessage(ref message2, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
m_MessageManager.SendMessage(ref message2, NetworkDelivery.Reliable, m_Clients);
m_MessagingSystem.ProcessSendQueues();
m_MessageManager.ProcessSendQueues();
var reader = new FastBufferReader(m_MessageSender.MessageQueue[0], Allocator.Temp);
using (reader)
{
reader.ReadValueSafe(out BatchHeader header);
reader.ReadValueSafe(out NetworkBatchHeader header);
Assert.AreEqual(2, header.BatchCount);
MessageHeader messageHeader;
NetworkMessageHeader messageHeader;
ByteUnpacker.ReadValueBitPacked(reader, out messageHeader.MessageType);
ByteUnpacker.ReadValueBitPacked(reader, out messageHeader.MessageSize);
Assert.AreEqual(m_MessagingSystem.GetMessageType(typeof(TestMessage)), messageHeader.MessageType);
Assert.AreEqual(m_MessageManager.GetMessageType(typeof(TestMessage)), messageHeader.MessageType);
Assert.AreEqual(UnsafeUtility.SizeOf<TestMessage>(), messageHeader.MessageSize);
reader.ReadValueSafe(out TestMessage receivedMessage);
Assert.AreEqual(message, receivedMessage);
@@ -244,24 +248,24 @@ namespace Unity.Netcode.EditorTests
ByteUnpacker.ReadValueBitPacked(reader, out messageHeader.MessageType);
ByteUnpacker.ReadValueBitPacked(reader, out messageHeader.MessageSize);
Assert.AreEqual(m_MessagingSystem.GetMessageType(typeof(TestMessage)), messageHeader.MessageType);
Assert.AreEqual(m_MessageManager.GetMessageType(typeof(TestMessage)), messageHeader.MessageType);
Assert.AreEqual(UnsafeUtility.SizeOf<TestMessage>(), messageHeader.MessageSize);
reader.ReadValueSafe(out TestMessage receivedMessage2);
Assert.AreEqual(message2, receivedMessage2);
}
}
private class TestNoHandlerMessageProvider : IMessageProvider
private class TestNoHandlerMessageProvider : INetworkMessageProvider
{
public List<MessagingSystem.MessageWithHandler> GetMessages()
public List<NetworkMessageManager.MessageWithHandler> GetMessages()
{
return new List<MessagingSystem.MessageWithHandler>
return new List<NetworkMessageManager.MessageWithHandler>
{
new MessagingSystem.MessageWithHandler
new NetworkMessageManager.MessageWithHandler
{
MessageType = typeof(TestMessage),
Handler = null,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessage>
GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessage>
}
};
}
@@ -270,25 +274,26 @@ namespace Unity.Netcode.EditorTests
[Test]
public void WhenReceivingAMessageWithoutAHandler_ExceptionIsLogged()
{
// If a MessagingSystem already exists then dispose of it before creating a new MessagingSystem (otherwise memory leak)
if (m_MessagingSystem != null)
// If a NetworkMessageManager already exists then dispose of it before creating a new NetworkMessageManager (otherwise memory leak)
if (m_MessageManager != null)
{
m_MessagingSystem.Dispose();
m_MessagingSystem = null;
m_MessageManager.Dispose();
m_MessageManager = null;
}
// Since m_MessagingSystem is disposed during teardown we don't need to worry about that here.
m_MessagingSystem = new MessagingSystem(new NopMessageSender(), this, new TestNoHandlerMessageProvider());
m_MessagingSystem.ClientConnected(0);
// Since m_MessageManager is disposed during teardown we don't need to worry about that here.
m_MessageManager = new NetworkMessageManager(new NopMessageSender(), this, new TestNoHandlerMessageProvider());
m_MessageManager.ClientConnected(0);
var messageHeader = new MessageHeader
var messageHeader = new NetworkMessageHeader
{
MessageSize = (ushort)UnsafeUtility.SizeOf<TestMessage>(),
MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)),
MessageType = m_MessageManager.GetMessageType(typeof(TestMessage)),
};
var message = GetMessage();
var writer = new FastBufferWriter(1300, Allocator.Temp);
var writer = new FastBufferWriter(m_MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp);
using (writer)
{
writer.TryBeginWrite(FastBufferWriter.GetWriteSize(message));
@@ -297,7 +302,7 @@ namespace Unity.Netcode.EditorTests
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
m_MessagingSystem.HandleMessage(messageHeader, reader, 0, 0, 0);
m_MessageManager.HandleMessage(messageHeader, reader, 0, 0, 0);
LogAssert.Expect(LogType.Exception, new Regex(".*HandlerNotRegisteredException.*"));
}
}

166
Tests/Editor/Messaging/MessageVersioningTests.cs
View File

@@ -15,7 +15,7 @@ namespace Unity.Netcode.EditorTests
private const int k_DefaultD = 15;
private const long k_DefaultE = 20;
private struct VersionedTestMessage_v0 : INetworkMessage, INetworkSerializeByMemcpy
private struct VersionedTestMessageV0 : INetworkMessage, INetworkSerializeByMemcpy
{
public int A;
public int B;
@@ -23,7 +23,7 @@ namespace Unity.Netcode.EditorTests
public static bool Serialized;
public static bool Deserialized;
public static bool Handled;
public static List<VersionedTestMessage_v0> DeserializedValues = new List<VersionedTestMessage_v0>();
public static List<VersionedTestMessageV0> DeserializedValues = new List<VersionedTestMessageV0>();
public void Serialize(FastBufferWriter writer, int targetVersion)
{
@@ -53,7 +53,7 @@ namespace Unity.Netcode.EditorTests
public int Version => 0;
}
private struct VersionedTestMessage_v1 : INetworkMessage, INetworkSerializeByMemcpy
private struct VersionedTestMessageV1 : INetworkMessage, INetworkSerializeByMemcpy
{
public int A;
public int B;
@@ -64,14 +64,14 @@ namespace Unity.Netcode.EditorTests
public static bool Downgraded;
public static bool Upgraded;
public static bool Handled;
public static List<VersionedTestMessage_v1> DeserializedValues = new List<VersionedTestMessage_v1>();
public static List<VersionedTestMessageV1> DeserializedValues = new List<VersionedTestMessageV1>();
public void Serialize(FastBufferWriter writer, int targetVersion)
{
if (targetVersion < Version)
{
Downgraded = true;
var v0 = new VersionedTestMessage_v0 { A = A, B = B, C = C };
var v0 = new VersionedTestMessageV0 { A = A, B = B, C = C };
v0.Serialize(writer, targetVersion);
return;
}
@@ -87,7 +87,7 @@ namespace Unity.Netcode.EditorTests
{
if (receivedMessageVersion < Version)
{
var v0 = new VersionedTestMessage_v0();
var v0 = new VersionedTestMessageV0();
v0.Deserialize(reader, ref context, receivedMessageVersion);
A = v0.A;
B = v0.B;
@@ -131,7 +131,7 @@ namespace Unity.Netcode.EditorTests
if (targetVersion < Version)
{
Downgraded = true;
var v1 = new VersionedTestMessage_v1 { A = A, B = k_DefaultB, C = k_DefaultC, D = (int)D };
var v1 = new VersionedTestMessageV1 { A = A, B = k_DefaultB, C = k_DefaultC, D = (int)D };
v1.Serialize(writer, targetVersion);
return;
}
@@ -146,7 +146,7 @@ namespace Unity.Netcode.EditorTests
{
if (receivedMessageVersion < Version)
{
var v1 = new VersionedTestMessage_v1();
var v1 = new VersionedTestMessageV1();
v1.Deserialize(reader, ref context, receivedMessageVersion);
A = v1.A;
D = v1.D;
@@ -171,55 +171,55 @@ namespace Unity.Netcode.EditorTests
public int Version => 2;
}
private class TestMessageProvider_v0 : IMessageProvider
private class TestMessageProviderV0 : INetworkMessageProvider
{
public List<MessagingSystem.MessageWithHandler> GetMessages()
public List<NetworkMessageManager.MessageWithHandler> GetMessages()
{
return new List<MessagingSystem.MessageWithHandler>
return new List<NetworkMessageManager.MessageWithHandler>
{
new MessagingSystem.MessageWithHandler
new NetworkMessageManager.MessageWithHandler
{
MessageType = typeof(VersionedTestMessage_v0),
Handler = MessagingSystem.ReceiveMessage<VersionedTestMessage_v0>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<VersionedTestMessage_v0>
MessageType = typeof(VersionedTestMessageV0),
Handler = NetworkMessageManager.ReceiveMessage<VersionedTestMessageV0>,
GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<VersionedTestMessageV0>
}
};
}
}
private class TestMessageProvider_v1 : IMessageProvider
private class TestMessageProviderV1 : INetworkMessageProvider
{
public List<MessagingSystem.MessageWithHandler> GetMessages()
public List<NetworkMessageManager.MessageWithHandler> GetMessages()
{
return new List<MessagingSystem.MessageWithHandler>
return new List<NetworkMessageManager.MessageWithHandler>
{
new MessagingSystem.MessageWithHandler
new NetworkMessageManager.MessageWithHandler
{
MessageType = typeof(VersionedTestMessage_v1),
Handler = MessagingSystem.ReceiveMessage<VersionedTestMessage_v1>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<VersionedTestMessage_v1>
MessageType = typeof(VersionedTestMessageV1),
Handler = NetworkMessageManager.ReceiveMessage<VersionedTestMessageV1>,
GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<VersionedTestMessageV1>
}
};
}
}
private class TestMessageProvider_v2 : IMessageProvider
private class TestMessageProviderV2 : INetworkMessageProvider
{
public List<MessagingSystem.MessageWithHandler> GetMessages()
public List<NetworkMessageManager.MessageWithHandler> GetMessages()
{
return new List<MessagingSystem.MessageWithHandler>
return new List<NetworkMessageManager.MessageWithHandler>
{
new MessagingSystem.MessageWithHandler
new NetworkMessageManager.MessageWithHandler
{
MessageType = typeof(VersionedTestMessage),
Handler = MessagingSystem.ReceiveMessage<VersionedTestMessage>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<VersionedTestMessage>
Handler = NetworkMessageManager.ReceiveMessage<VersionedTestMessage>,
GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<VersionedTestMessage>
}
};
}
}
private class TestMessageSender : IMessageSender
private class TestMessageSender : INetworkMessageSender
{
public List<byte[]> MessageQueue = new List<byte[]>();
@@ -229,14 +229,14 @@ namespace Unity.Netcode.EditorTests
}
}
private MessagingSystem m_MessagingSystem_v0;
private MessagingSystem m_MessagingSystem_v1;
private MessagingSystem m_MessagingSystem_v2;
private NetworkMessageManager m_MessageManagerV0;
private NetworkMessageManager m_MessageManagerV1;
private NetworkMessageManager m_MessageManagerV2;
private TestMessageSender m_MessageSender;
private void CreateFakeClients(MessagingSystem system, uint hash)
private void CreateFakeClients(NetworkMessageManager system, uint hash)
{
// Create three fake clients for each messaging system
// Create three fake clients for each NetworkMessageManager
// client 0 has version 0, client 1 has version 1, and client 2 has version 2
system.ClientConnected(0);
system.ClientConnected(1);
@@ -249,16 +249,16 @@ namespace Unity.Netcode.EditorTests
[SetUp]
public void SetUp()
{
VersionedTestMessage_v0.Serialized = false;
VersionedTestMessage_v0.Deserialized = false;
VersionedTestMessage_v0.Handled = false;
VersionedTestMessage_v0.DeserializedValues.Clear();
VersionedTestMessage_v1.Serialized = false;
VersionedTestMessage_v1.Deserialized = false;
VersionedTestMessage_v1.Downgraded = false;
VersionedTestMessage_v1.Upgraded = false;
VersionedTestMessage_v1.Handled = false;
VersionedTestMessage_v1.DeserializedValues.Clear();
VersionedTestMessageV0.Serialized = false;
VersionedTestMessageV0.Deserialized = false;
VersionedTestMessageV0.Handled = false;
VersionedTestMessageV0.DeserializedValues.Clear();
VersionedTestMessageV1.Serialized = false;
VersionedTestMessageV1.Deserialized = false;
VersionedTestMessageV1.Downgraded = false;
VersionedTestMessageV1.Upgraded = false;
VersionedTestMessageV1.Handled = false;
VersionedTestMessageV1.DeserializedValues.Clear();
VersionedTestMessage.Serialized = false;
VersionedTestMessage.Deserialized = false;
VersionedTestMessage.Downgraded = false;
@@ -267,35 +267,35 @@ namespace Unity.Netcode.EditorTests
VersionedTestMessage.DeserializedValues.Clear();
m_MessageSender = new TestMessageSender();
m_MessagingSystem_v0 = new MessagingSystem(m_MessageSender, this, new TestMessageProvider_v0());
m_MessagingSystem_v1 = new MessagingSystem(m_MessageSender, this, new TestMessageProvider_v1());
m_MessagingSystem_v2 = new MessagingSystem(m_MessageSender, this, new TestMessageProvider_v2());
m_MessageManagerV0 = new NetworkMessageManager(m_MessageSender, this, new TestMessageProviderV0());
m_MessageManagerV1 = new NetworkMessageManager(m_MessageSender, this, new TestMessageProviderV1());
m_MessageManagerV2 = new NetworkMessageManager(m_MessageSender, this, new TestMessageProviderV2());
CreateFakeClients(m_MessagingSystem_v0, XXHash.Hash32(typeof(VersionedTestMessage_v0).FullName));
CreateFakeClients(m_MessagingSystem_v1, XXHash.Hash32(typeof(VersionedTestMessage_v1).FullName));
CreateFakeClients(m_MessagingSystem_v2, XXHash.Hash32(typeof(VersionedTestMessage).FullName));
CreateFakeClients(m_MessageManagerV0, XXHash.Hash32(typeof(VersionedTestMessageV0).FullName));
CreateFakeClients(m_MessageManagerV1, XXHash.Hash32(typeof(VersionedTestMessageV1).FullName));
CreateFakeClients(m_MessageManagerV2, XXHash.Hash32(typeof(VersionedTestMessage).FullName));
// Make sure that all three messages got the same IDs...
Assert.AreEqual(
m_MessagingSystem_v0.GetMessageType(typeof(VersionedTestMessage_v0)),
m_MessagingSystem_v1.GetMessageType(typeof(VersionedTestMessage_v1)));
m_MessageManagerV0.GetMessageType(typeof(VersionedTestMessageV0)),
m_MessageManagerV1.GetMessageType(typeof(VersionedTestMessageV1)));
Assert.AreEqual(
m_MessagingSystem_v0.GetMessageType(typeof(VersionedTestMessage_v0)),
m_MessagingSystem_v2.GetMessageType(typeof(VersionedTestMessage)));
m_MessageManagerV0.GetMessageType(typeof(VersionedTestMessageV0)),
m_MessageManagerV2.GetMessageType(typeof(VersionedTestMessage)));
}
[TearDown]
public void TearDown()
{
m_MessagingSystem_v0.Dispose();
m_MessagingSystem_v1.Dispose();
m_MessagingSystem_v2.Dispose();
m_MessageManagerV0.Dispose();
m_MessageManagerV1.Dispose();
m_MessageManagerV2.Dispose();
}
private VersionedTestMessage_v0 GetMessage_v0()
private VersionedTestMessageV0 GetMessage_v0()
{
var random = new Random();
return new VersionedTestMessage_v0
return new VersionedTestMessageV0
{
A = random.Next(),
B = random.Next(),
@@ -303,10 +303,10 @@ namespace Unity.Netcode.EditorTests
};
}
private VersionedTestMessage_v1 GetMessage_v1()
private VersionedTestMessageV1 GetMessage_v1()
{
var random = new Random();
return new VersionedTestMessage_v1
return new VersionedTestMessageV1
{
A = random.Next(),
B = random.Next(),
@@ -328,10 +328,10 @@ namespace Unity.Netcode.EditorTests
public void CheckPostSendExpectations(int sourceLocalVersion, int remoteVersion)
{
Assert.AreEqual(Math.Min(sourceLocalVersion, remoteVersion) == 0, VersionedTestMessage_v0.Serialized);
Assert.AreEqual(Math.Min(sourceLocalVersion, remoteVersion) == 1, VersionedTestMessage_v1.Serialized);
Assert.AreEqual(Math.Min(sourceLocalVersion, remoteVersion) == 0, VersionedTestMessageV0.Serialized);
Assert.AreEqual(Math.Min(sourceLocalVersion, remoteVersion) == 1, VersionedTestMessageV1.Serialized);
Assert.AreEqual(Math.Min(sourceLocalVersion, remoteVersion) == 2, VersionedTestMessage.Serialized);
Assert.AreEqual(sourceLocalVersion >= 1 && remoteVersion < 1, VersionedTestMessage_v1.Downgraded);
Assert.AreEqual(sourceLocalVersion >= 1 && remoteVersion < 1, VersionedTestMessageV1.Downgraded);
Assert.AreEqual(sourceLocalVersion >= 2 && remoteVersion < 2, VersionedTestMessage.Downgraded);
Assert.AreEqual(1, m_MessageSender.MessageQueue.Count);
@@ -340,14 +340,14 @@ namespace Unity.Netcode.EditorTests
public void CheckPostReceiveExpectations(int sourceLocalVersion, int remoteVersion)
{
Assert.AreEqual(SentVersion == 0, VersionedTestMessage_v0.Deserialized);
Assert.AreEqual(SentVersion == 1, VersionedTestMessage_v1.Deserialized);
Assert.AreEqual(SentVersion == 0, VersionedTestMessageV0.Deserialized);
Assert.AreEqual(SentVersion == 1, VersionedTestMessageV1.Deserialized);
Assert.AreEqual(SentVersion == 2, VersionedTestMessage.Deserialized);
Assert.AreEqual(remoteVersion >= 1 && sourceLocalVersion < 1, VersionedTestMessage_v1.Upgraded);
Assert.AreEqual(remoteVersion >= 1 && sourceLocalVersion < 1, VersionedTestMessageV1.Upgraded);
Assert.AreEqual(remoteVersion >= 2 && sourceLocalVersion < 2, VersionedTestMessage.Upgraded);
Assert.AreEqual((remoteVersion == 0 ? 1 : 0), VersionedTestMessage_v0.DeserializedValues.Count);
Assert.AreEqual((remoteVersion == 1 ? 1 : 0), VersionedTestMessage_v1.DeserializedValues.Count);
Assert.AreEqual((remoteVersion == 0 ? 1 : 0), VersionedTestMessageV0.DeserializedValues.Count);
Assert.AreEqual((remoteVersion == 1 ? 1 : 0), VersionedTestMessageV1.DeserializedValues.Count);
Assert.AreEqual((remoteVersion == 2 ? 1 : 0), VersionedTestMessage.DeserializedValues.Count);
Assert.AreEqual(SentVersion, ReceivedVersion);
@@ -355,23 +355,23 @@ namespace Unity.Netcode.EditorTests
private void SendMessageWithVersions<T>(T message, int fromVersion, int toVersion) where T : unmanaged, INetworkMessage
{
MessagingSystem sendSystem;
NetworkMessageManager sendSystem;
switch (fromVersion)
{
case 0: sendSystem = m_MessagingSystem_v0; break;
case 1: sendSystem = m_MessagingSystem_v1; break;
default: sendSystem = m_MessagingSystem_v2; break;
case 0: sendSystem = m_MessageManagerV0; break;
case 1: sendSystem = m_MessageManagerV1; break;
default: sendSystem = m_MessageManagerV2; break;
}
sendSystem.SendMessage(ref message, NetworkDelivery.Reliable, (ulong)toVersion);
sendSystem.ProcessSendQueues();
CheckPostSendExpectations(fromVersion, toVersion);
MessagingSystem receiveSystem;
NetworkMessageManager receiveSystem;
switch (toVersion)
{
case 0: receiveSystem = m_MessagingSystem_v0; break;
case 1: receiveSystem = m_MessagingSystem_v1; break;
default: receiveSystem = m_MessagingSystem_v2; break;
case 0: receiveSystem = m_MessageManagerV0; break;
case 1: receiveSystem = m_MessageManagerV1; break;
default: receiveSystem = m_MessageManagerV2; break;
}
receiveSystem.HandleIncomingData((ulong)fromVersion, new ArraySegment<byte>(m_MessageSender.MessageQueue[0]), 0.0f);
receiveSystem.ProcessIncomingMessageQueue();
@@ -387,7 +387,7 @@ namespace Unity.Netcode.EditorTests
SendMessageWithVersions(message, 0, 0);
var receivedMessage = VersionedTestMessage_v0.DeserializedValues[0];
var receivedMessage = VersionedTestMessageV0.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual(message.B, receivedMessage.B);
Assert.AreEqual(message.C, receivedMessage.C);
@@ -400,7 +400,7 @@ namespace Unity.Netcode.EditorTests
SendMessageWithVersions(message, 0, 1);
var receivedMessage = VersionedTestMessage_v1.DeserializedValues[0];
var receivedMessage = VersionedTestMessageV1.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual(message.B, receivedMessage.B);
Assert.AreEqual(message.C, receivedMessage.C);
@@ -427,7 +427,7 @@ namespace Unity.Netcode.EditorTests
SendMessageWithVersions(message, 1, 0);
var receivedMessage = VersionedTestMessage_v0.DeserializedValues[0];
var receivedMessage = VersionedTestMessageV0.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual(message.B, receivedMessage.B);
Assert.AreEqual(message.C, receivedMessage.C);
@@ -440,7 +440,7 @@ namespace Unity.Netcode.EditorTests
SendMessageWithVersions(message, 1, 1);
var receivedMessage = VersionedTestMessage_v1.DeserializedValues[0];
var receivedMessage = VersionedTestMessageV1.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual(message.B, receivedMessage.B);
Assert.AreEqual(message.C, receivedMessage.C);
@@ -467,7 +467,7 @@ namespace Unity.Netcode.EditorTests
SendMessageWithVersions(message, 2, 0);
var receivedMessage = VersionedTestMessage_v0.DeserializedValues[0];
var receivedMessage = VersionedTestMessageV0.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual(k_DefaultB, receivedMessage.B);
Assert.AreEqual(k_DefaultC, receivedMessage.C);
@@ -480,7 +480,7 @@ namespace Unity.Netcode.EditorTests
SendMessageWithVersions(message, 2, 1);
var receivedMessage = VersionedTestMessage_v1.DeserializedValues[0];
var receivedMessage = VersionedTestMessageV1.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual(k_DefaultB, receivedMessage.B);
Assert.AreEqual(k_DefaultC, receivedMessage.C);

2
Tests/Editor/Messaging/NopMessageSender.cs
View File

@@ -1,6 +1,6 @@
namespace Unity.Netcode.EditorTests
{
internal class NopMessageSender : IMessageSender
internal class NopMessageSender : INetworkMessageSender
{
public void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData)
{

161
Tests/Editor/NetworkManagerConfigurationTests.cs
View File

@@ -107,7 +107,7 @@ namespace Unity.Netcode.EditorTests
networkManager.OnValidate();
// Expect a warning
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)");
LogAssert.Expect(LogType.Warning, $"[Netcode] {NetworkPrefabHandler.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);
@@ -305,5 +305,164 @@ namespace Unity.Netcode.EditorTests
Assert.IsTrue(sharedList.Contains(object2.gameObject));
Assert.IsTrue(sharedList.Contains(object3.gameObject));
}
[Test]
public void WhenCallingInitializeAfterAddingAPrefabUsingPrefabsAPI_ThePrefabStillExists()
{
// Setup
var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
var networkManager = networkManagerObject.AddComponent<NetworkManager>();
networkManager.NetworkConfig = new NetworkConfig
{
NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
};
var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
var networkManager2 = networkManagerObject2.AddComponent<NetworkManager>();
networkManager2.NetworkConfig = new 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.NetworkConfig.Prefabs.Add(new NetworkPrefab { Prefab = object2.gameObject });
networkManager2.NetworkConfig.Prefabs.Add(new NetworkPrefab { Prefab = object3.gameObject });
networkManager.Initialize(true);
networkManager2.Initialize(false);
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 WhenShuttingDownAndReinitializingPrefabs_RuntimeAddedPrefabsStillExists()
{
// Setup
var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
var networkManager = networkManagerObject.AddComponent<NetworkManager>();
networkManager.NetworkConfig = new NetworkConfig
{
NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
};
var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
var networkManager2 = networkManagerObject2.AddComponent<NetworkManager>();
networkManager2.NetworkConfig = new 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 });
networkManager.ShutdownInternal();
networkManager2.ShutdownInternal();
networkManager.Initialize(true);
networkManager2.Initialize(false);
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 WhenCallingInitializeMultipleTimes_NothingBreaks()
{
// Setup
var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
var networkManager = networkManagerObject.AddComponent<NetworkManager>();
networkManager.NetworkConfig = new NetworkConfig
{
NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
};
var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
var networkManager2 = networkManagerObject2.AddComponent<NetworkManager>();
networkManager2.NetworkConfig = new 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 });
networkManager.NetworkConfig.Prefabs.Initialize();
networkManager2.NetworkConfig.Prefabs.Initialize();
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));
}
}
}

754
Tests/Editor/Serialization/BaseFastBufferReaderWriterTest.cs
View File

@@ -1,5 +1,6 @@
using System;
using NUnit.Framework;
using Unity.Collections;
using UnityEngine;
using Random = System.Random;
@@ -11,50 +12,50 @@ namespace Unity.Netcode.EditorTests
{
A,
B,
C
};
C = byte.MaxValue
}
protected enum SByteEnum : sbyte
{
A,
B,
C
};
C = sbyte.MaxValue
}
protected enum ShortEnum : short
{
A,
B,
C
};
C = short.MaxValue
}
protected enum UShortEnum : ushort
{
A,
B,
C
};
C = ushort.MaxValue
}
protected enum IntEnum : int
{
A,
B,
C
};
C = int.MaxValue
}
protected enum UIntEnum : uint
{
A,
B,
C
};
C = uint.MaxValue
}
protected enum LongEnum : long
{
A,
B,
C
};
C = long.MaxValue
}
protected enum ULongEnum : ulong
{
A,
B,
C
};
C = ulong.MaxValue
}
protected struct TestStruct : INetworkSerializeByMemcpy
{
@@ -85,23 +86,32 @@ namespace Unity.Netcode.EditorTests
protected abstract void RunTypeArrayTestSafe<T>(T[] valueToTest) where T : unmanaged;
protected abstract void RunTypeNativeArrayTest<T>(NativeArray<T> valueToTest) where T : unmanaged;
protected abstract void RunTypeNativeArrayTestSafe<T>(NativeArray<T> valueToTest) where T : unmanaged;
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
protected abstract void RunTypeNativeListTest<T>(NativeList<T> valueToTest) where T : unmanaged;
protected abstract void RunTypeNativeListTestSafe<T>(NativeList<T> valueToTest) where T : unmanaged;
#endif
private Random m_Random = new Random();
protected TestStruct GetTestStruct()
{
var random = new Random();
var testStruct = new TestStruct
{
A = (byte)random.Next(),
B = (short)random.Next(),
C = (ushort)random.Next(),
D = random.Next(),
E = (uint)random.Next(),
F = ((long)random.Next() << 32) + random.Next(),
G = ((ulong)random.Next() << 32) + (ulong)random.Next(),
A = (byte)m_Random.Next(),
B = (short)m_Random.Next(),
C = (ushort)m_Random.Next(),
D = m_Random.Next(),
E = (uint)m_Random.Next(),
F = ((long)m_Random.Next() << 32) + m_Random.Next(),
G = ((ulong)m_Random.Next() << 32) + (ulong)m_Random.Next(),
H = true,
I = '\u263a',
J = (float)random.NextDouble(),
K = random.NextDouble(),
J = (float)m_Random.NextDouble(),
K = m_Random.NextDouble(),
};
return testStruct;
@@ -600,5 +610,695 @@ namespace Unity.Netcode.EditorTests
Assert.Fail("No type handler was provided for this type in the test!");
}
}
public void BaseNativeArrayTypeTest(Type testType, WriteType writeType)
{
var random = new Random();
void RunTypeTestLocal<T>(NativeArray<T> val, WriteType wt) where T : unmanaged
{
switch (wt)
{
case WriteType.WriteDirect:
RunTypeNativeArrayTest(val);
break;
case WriteType.WriteSafe:
RunTypeNativeArrayTestSafe(val);
break;
}
}
if (testType == typeof(byte))
{
RunTypeTestLocal(new NativeArray<byte>(new[]{
(byte) random.Next(),
(byte) random.Next(),
(byte) random.Next(),
(byte) random.Next(),
(byte) random.Next(),
(byte) random.Next(),
(byte) random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(sbyte))
{
RunTypeTestLocal(new NativeArray<sbyte>(new[]{
(sbyte) random.Next(),
(sbyte) random.Next(),
(sbyte) random.Next(),
(sbyte) random.Next(),
(sbyte) random.Next(),
(sbyte) random.Next(),
(sbyte) random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(short))
{
RunTypeTestLocal(new NativeArray<short>(new[]{
(short) random.Next(),
(short) random.Next(),
(short) random.Next(),
(short) random.Next(),
(short) random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(ushort))
{
RunTypeTestLocal(new NativeArray<ushort>(new[]{
(ushort) random.Next(),
(ushort) random.Next(),
(ushort) random.Next(),
(ushort) random.Next(),
(ushort) random.Next(),
(ushort) random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(int))
{
RunTypeTestLocal(new NativeArray<int>(new[]{
random.Next(),
random.Next(),
random.Next(),
random.Next(),
random.Next(),
random.Next(),
random.Next(),
random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(uint))
{
RunTypeTestLocal(new NativeArray<uint>(new[]{
(uint) random.Next(),
(uint) random.Next(),
(uint) random.Next(),
(uint) random.Next(),
(uint) random.Next(),
(uint) random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(long))
{
RunTypeTestLocal(new NativeArray<long>(new[]{
((long)random.Next() << 32) + random.Next(),
((long)random.Next() << 32) + random.Next(),
((long)random.Next() << 32) + random.Next(),
((long)random.Next() << 32) + random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(ulong))
{
RunTypeTestLocal(new NativeArray<ulong>(new[]{
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(bool))
{
RunTypeTestLocal(new NativeArray<bool>(new[]{
true,
false,
true,
true,
false,
false,
true,
false,
true
}, Allocator.Temp), writeType);
}
else if (testType == typeof(char))
{
RunTypeTestLocal(new NativeArray<char>(new[]{
'a',
'\u263a'
}, Allocator.Temp), writeType);
}
else if (testType == typeof(float))
{
RunTypeTestLocal(new NativeArray<float>(new[]{
(float)random.NextDouble(),
(float)random.NextDouble(),
(float)random.NextDouble(),
(float)random.NextDouble(),
(float)random.NextDouble(),
(float)random.NextDouble(),
(float)random.NextDouble(),
(float)random.NextDouble(),
(float)random.NextDouble()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(double))
{
RunTypeTestLocal(new NativeArray<double>(new[]{
random.NextDouble(),
random.NextDouble(),
random.NextDouble(),
random.NextDouble(),
random.NextDouble(),
random.NextDouble(),
random.NextDouble(),
random.NextDouble(),
random.NextDouble()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(ByteEnum))
{
RunTypeTestLocal(new NativeArray<ByteEnum>(new[]{
ByteEnum.C,
ByteEnum.A,
ByteEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(SByteEnum))
{
RunTypeTestLocal(new NativeArray<SByteEnum>(new[]{
SByteEnum.C,
SByteEnum.A,
SByteEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(ShortEnum))
{
RunTypeTestLocal(new NativeArray<ShortEnum>(new[]{
ShortEnum.C,
ShortEnum.A,
ShortEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(UShortEnum))
{
RunTypeTestLocal(new NativeArray<UShortEnum>(new[]{
UShortEnum.C,
UShortEnum.A,
UShortEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(IntEnum))
{
RunTypeTestLocal(new NativeArray<IntEnum>(new[]{
IntEnum.C,
IntEnum.A,
IntEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(UIntEnum))
{
RunTypeTestLocal(new NativeArray<UIntEnum>(new[]{
UIntEnum.C,
UIntEnum.A,
UIntEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(LongEnum))
{
RunTypeTestLocal(new NativeArray<LongEnum>(new[]{
LongEnum.C,
LongEnum.A,
LongEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(ULongEnum))
{
RunTypeTestLocal(new NativeArray<ULongEnum>(new[]{
ULongEnum.C,
ULongEnum.A,
ULongEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Vector2))
{
RunTypeTestLocal(new NativeArray<Vector2>(new[]{
new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Vector3))
{
RunTypeTestLocal(new NativeArray<Vector3>(new[]{
new Vector3((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble()),
new Vector3((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble()),
new Vector3((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Vector2Int))
{
RunTypeTestLocal(new NativeArray<Vector2Int>(new[]{
new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Vector3Int))
{
RunTypeTestLocal(new NativeArray<Vector3Int>(new[]{
new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Vector4))
{
RunTypeTestLocal(new NativeArray<Vector4>(new[]{
new Vector4((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
new Vector4((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
new Vector4((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Quaternion))
{
RunTypeTestLocal(new NativeArray<Quaternion>(new[]{
new Quaternion((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble(), (float) random.NextDouble()),
new Quaternion((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble(), (float) random.NextDouble()),
new Quaternion((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble(), (float) random.NextDouble()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Color))
{
RunTypeTestLocal(new NativeArray<Color>(new[]{
new Color((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
new Color((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
new Color((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Color32))
{
RunTypeTestLocal(new NativeArray<Color32>(new[]{
new Color32((byte) random.Next(), (byte) random.Next(), (byte) random.Next(), (byte) random.Next()),
new Color32((byte) random.Next(), (byte) random.Next(), (byte) random.Next(), (byte) random.Next()),
new Color32((byte) random.Next(), (byte) random.Next(), (byte) random.Next(), (byte) random.Next()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Ray))
{
RunTypeTestLocal(new NativeArray<Ray>(new[]{
new Ray(
new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble())),
new Ray(
new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble())),
new Ray(
new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble())),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Ray2D))
{
RunTypeTestLocal(new NativeArray<Ray2D>(new[]{
new Ray2D(
new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
new Vector2((float) random.NextDouble(), (float) random.NextDouble())),
new Ray2D(
new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
new Vector2((float) random.NextDouble(), (float) random.NextDouble())),
new Ray2D(
new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
new Vector2((float) random.NextDouble(), (float) random.NextDouble())),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(TestStruct))
{
RunTypeTestLocal(new NativeArray<TestStruct>(new[] {
GetTestStruct(),
GetTestStruct(),
GetTestStruct(),
}, Allocator.Temp), writeType);
}
else
{
Assert.Fail("No type handler was provided for this type in the test!");
}
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
public void BaseNativeListTypeTest(Type testType, WriteType writeType)
{
var random = new Random();
void RunTypeTestLocal<T>(NativeArray<T> val, WriteType wt) where T : unmanaged
{
var lst = new NativeList<T>(val.Length, Allocator.Temp);
foreach (var item in val)
{
lst.Add(item);
}
switch (wt)
{
case WriteType.WriteDirect:
RunTypeNativeListTest(lst);
break;
case WriteType.WriteSafe:
RunTypeNativeListTestSafe(lst);
break;
}
}
if (testType == typeof(byte))
{
RunTypeTestLocal(new NativeArray<byte>(new[]{
(byte) random.Next(),
(byte) random.Next(),
(byte) random.Next(),
(byte) random.Next(),
(byte) random.Next(),
(byte) random.Next(),
(byte) random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(sbyte))
{
RunTypeTestLocal(new NativeArray<sbyte>(new[]{
(sbyte) random.Next(),
(sbyte) random.Next(),
(sbyte) random.Next(),
(sbyte) random.Next(),
(sbyte) random.Next(),
(sbyte) random.Next(),
(sbyte) random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(short))
{
RunTypeTestLocal(new NativeArray<short>(new[]{
(short) random.Next(),
(short) random.Next(),
(short) random.Next(),
(short) random.Next(),
(short) random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(ushort))
{
RunTypeTestLocal(new NativeArray<ushort>(new[]{
(ushort) random.Next(),
(ushort) random.Next(),
(ushort) random.Next(),
(ushort) random.Next(),
(ushort) random.Next(),
(ushort) random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(int))
{
RunTypeTestLocal(new NativeArray<int>(new[]{
random.Next(),
random.Next(),
random.Next(),
random.Next(),
random.Next(),
random.Next(),
random.Next(),
random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(uint))
{
RunTypeTestLocal(new NativeArray<uint>(new[]{
(uint) random.Next(),
(uint) random.Next(),
(uint) random.Next(),
(uint) random.Next(),
(uint) random.Next(),
(uint) random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(long))
{
RunTypeTestLocal(new NativeArray<long>(new[]{
((long)random.Next() << 32) + random.Next(),
((long)random.Next() << 32) + random.Next(),
((long)random.Next() << 32) + random.Next(),
((long)random.Next() << 32) + random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(ulong))
{
RunTypeTestLocal(new NativeArray<ulong>(new[]{
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next(),
((ulong)random.Next() << 32) + (ulong)random.Next()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(bool))
{
RunTypeTestLocal(new NativeArray<bool>(new[]{
true,
false,
true,
true,
false,
false,
true,
false,
true
}, Allocator.Temp), writeType);
}
else if (testType == typeof(char))
{
RunTypeTestLocal(new NativeArray<char>(new[]{
'a',
'\u263a'
}, Allocator.Temp), writeType);
}
else if (testType == typeof(float))
{
RunTypeTestLocal(new NativeArray<float>(new[]{
(float)random.NextDouble(),
(float)random.NextDouble(),
(float)random.NextDouble(),
(float)random.NextDouble(),
(float)random.NextDouble(),
(float)random.NextDouble(),
(float)random.NextDouble(),
(float)random.NextDouble(),
(float)random.NextDouble()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(double))
{
RunTypeTestLocal(new NativeArray<double>(new[]{
random.NextDouble(),
random.NextDouble(),
random.NextDouble(),
random.NextDouble(),
random.NextDouble(),
random.NextDouble(),
random.NextDouble(),
random.NextDouble(),
random.NextDouble()
}, Allocator.Temp), writeType);
}
else if (testType == typeof(ByteEnum))
{
RunTypeTestLocal(new NativeArray<ByteEnum>(new[]{
ByteEnum.C,
ByteEnum.A,
ByteEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(SByteEnum))
{
RunTypeTestLocal(new NativeArray<SByteEnum>(new[]{
SByteEnum.C,
SByteEnum.A,
SByteEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(ShortEnum))
{
RunTypeTestLocal(new NativeArray<ShortEnum>(new[]{
ShortEnum.C,
ShortEnum.A,
ShortEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(UShortEnum))
{
RunTypeTestLocal(new NativeArray<UShortEnum>(new[]{
UShortEnum.C,
UShortEnum.A,
UShortEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(IntEnum))
{
RunTypeTestLocal(new NativeArray<IntEnum>(new[]{
IntEnum.C,
IntEnum.A,
IntEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(UIntEnum))
{
RunTypeTestLocal(new NativeArray<UIntEnum>(new[]{
UIntEnum.C,
UIntEnum.A,
UIntEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(LongEnum))
{
RunTypeTestLocal(new NativeArray<LongEnum>(new[]{
LongEnum.C,
LongEnum.A,
LongEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(ULongEnum))
{
RunTypeTestLocal(new NativeArray<ULongEnum>(new[]{
ULongEnum.C,
ULongEnum.A,
ULongEnum.B
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Vector2))
{
RunTypeTestLocal(new NativeArray<Vector2>(new[]{
new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Vector3))
{
RunTypeTestLocal(new NativeArray<Vector3>(new[]{
new Vector3((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble()),
new Vector3((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble()),
new Vector3((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Vector2Int))
{
RunTypeTestLocal(new NativeArray<Vector2Int>(new[]{
new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Vector3Int))
{
RunTypeTestLocal(new NativeArray<Vector3Int>(new[]{
new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Vector4))
{
RunTypeTestLocal(new NativeArray<Vector4>(new[]{
new Vector4((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
new Vector4((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
new Vector4((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Quaternion))
{
RunTypeTestLocal(new NativeArray<Quaternion>(new[]{
new Quaternion((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble(), (float) random.NextDouble()),
new Quaternion((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble(), (float) random.NextDouble()),
new Quaternion((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble(), (float) random.NextDouble()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Color))
{
RunTypeTestLocal(new NativeArray<Color>(new[]{
new Color((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
new Color((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
new Color((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Color32))
{
RunTypeTestLocal(new NativeArray<Color32>(new[]{
new Color32((byte) random.Next(), (byte) random.Next(), (byte) random.Next(), (byte) random.Next()),
new Color32((byte) random.Next(), (byte) random.Next(), (byte) random.Next(), (byte) random.Next()),
new Color32((byte) random.Next(), (byte) random.Next(), (byte) random.Next(), (byte) random.Next()),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Ray))
{
RunTypeTestLocal(new NativeArray<Ray>(new[]{
new Ray(
new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble())),
new Ray(
new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble())),
new Ray(
new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble()),
new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
(float) random.NextDouble())),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(Ray2D))
{
RunTypeTestLocal(new NativeArray<Ray2D>(new[]{
new Ray2D(
new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
new Vector2((float) random.NextDouble(), (float) random.NextDouble())),
new Ray2D(
new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
new Vector2((float) random.NextDouble(), (float) random.NextDouble())),
new Ray2D(
new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
new Vector2((float) random.NextDouble(), (float) random.NextDouble())),
}, Allocator.Temp), writeType);
}
else if (testType == typeof(TestStruct))
{
RunTypeTestLocal(new NativeArray<TestStruct>(new[] {
GetTestStruct(),
GetTestStruct(),
GetTestStruct(),
}, Allocator.Temp), writeType);
}
else
{
Assert.Fail("No type handler was provided for this type in the test!");
}
}
#endif
}
}

365
Tests/Editor/Serialization/FastBufferReaderTests.cs
View File

@@ -69,6 +69,10 @@ namespace Unity.Netcode.EditorTests
{
continue;
}
if (candidateMethod.GetParameters()[0].ParameterType.IsGenericType)
{
continue;
}
try
{
method = candidateMethod.MakeGenericMethod(typeof(T));
@@ -110,6 +114,10 @@ namespace Unity.Netcode.EditorTests
{
continue;
}
if (candidateMethod.GetParameters()[0].ParameterType.IsGenericType)
{
continue;
}
try
{
method = candidateMethod.MakeGenericMethod(typeof(T));
@@ -134,6 +142,90 @@ namespace Unity.Netcode.EditorTests
method.Invoke(writer, args);
}
private void RunWriteMethod<T>(string methodName, FastBufferWriter writer, in NativeArray<T> value) where T : unmanaged
{
MethodInfo method = typeof(FastBufferWriter).GetMethod(methodName, new[] { typeof(NativeArray<T>) });
if (method == null)
{
foreach (var candidateMethod in typeof(FastBufferWriter).GetMethods())
{
if (candidateMethod.Name == methodName && candidateMethod.IsGenericMethodDefinition)
{
if (candidateMethod.GetParameters().Length == 0 || (candidateMethod.GetParameters().Length > 1 && !candidateMethod.GetParameters()[1].HasDefaultValue))
{
continue;
}
if (!candidateMethod.GetParameters()[0].ParameterType.Name.Contains("NativeArray"))
{
continue;
}
try
{
method = candidateMethod.MakeGenericMethod(typeof(T));
break;
}
catch (ArgumentException)
{
continue;
}
}
}
}
Assert.NotNull(method);
object[] args = new object[method.GetParameters().Length];
args[0] = value;
for (var i = 1; i < args.Length; ++i)
{
args[i] = method.GetParameters()[i].DefaultValue;
}
method.Invoke(writer, args);
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
private void RunWriteMethod<T>(string methodName, FastBufferWriter writer, in NativeList<T> value) where T : unmanaged
{
MethodInfo method = typeof(FastBufferWriter).GetMethod(methodName, new[] { typeof(NativeList<T>) });
if (method == null)
{
foreach (var candidateMethod in typeof(FastBufferWriter).GetMethods())
{
if (candidateMethod.Name == methodName && candidateMethod.IsGenericMethodDefinition)
{
if (candidateMethod.GetParameters().Length == 0 || (candidateMethod.GetParameters().Length > 1 && !candidateMethod.GetParameters()[1].HasDefaultValue))
{
continue;
}
if (!candidateMethod.GetParameters()[0].ParameterType.Name.Contains("NativeList"))
{
continue;
}
try
{
method = candidateMethod.MakeGenericMethod(typeof(T));
break;
}
catch (ArgumentException)
{
continue;
}
}
}
}
Assert.NotNull(method);
object[] args = new object[method.GetParameters().Length];
args[0] = value;
for (var i = 1; i < args.Length; ++i)
{
args[i] = method.GetParameters()[i].DefaultValue;
}
method.Invoke(writer, args);
}
#endif
private void RunReadMethod<T>(string methodName, FastBufferReader reader, out T value) where T : unmanaged
{
MethodInfo method = typeof(FastBufferReader).GetMethod(methodName, new[] { typeof(T).MakeByRefType() });
@@ -151,6 +243,10 @@ namespace Unity.Netcode.EditorTests
{
continue;
}
if (candidateMethod.GetParameters()[0].ParameterType.IsGenericType)
{
continue;
}
try
{
method = candidateMethod.MakeGenericMethod(typeof(T));
@@ -203,6 +299,10 @@ namespace Unity.Netcode.EditorTests
{
continue;
}
if (candidateMethod.GetParameters()[0].ParameterType.IsGenericType)
{
continue;
}
try
{
method = candidateMethod.MakeGenericMethod(typeof(T));
@@ -230,6 +330,112 @@ namespace Unity.Netcode.EditorTests
value = (T[])args[0];
}
private void RunReadMethod<T>(string methodName, FastBufferReader reader, out NativeArray<T> value) where T : unmanaged
{
MethodInfo method = null;
try
{
method = typeof(FastBufferReader).GetMethod(methodName, new[] { typeof(NativeArray<T>).MakeByRefType(), typeof(Allocator) });
}
catch (AmbiguousMatchException)
{
// skip.
}
if (method == null)
{
foreach (var candidateMethod in typeof(FastBufferReader).GetMethods())
{
if (candidateMethod.Name == methodName && candidateMethod.IsGenericMethodDefinition)
{
if (candidateMethod.GetParameters().Length < 2 || (candidateMethod.GetParameters().Length > 2 && !candidateMethod.GetParameters()[2].HasDefaultValue))
{
continue;
}
if (!candidateMethod.GetParameters()[0].ParameterType.Name.Contains("NativeArray"))
{
continue;
}
try
{
method = candidateMethod.MakeGenericMethod(typeof(T));
break;
}
catch (ArgumentException)
{
continue;
}
}
}
}
Assert.NotNull(method);
value = new NativeArray<T>();
object[] args = new object[method.GetParameters().Length];
args[0] = value;
args[1] = Allocator.Temp;
for (var i = 2; i < args.Length; ++i)
{
args[i] = method.GetParameters()[i].DefaultValue;
}
method.Invoke(reader, args);
value = (NativeArray<T>)args[0];
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
private void RunReadMethod<T>(string methodName, FastBufferReader reader, ref NativeList<T> value) where T : unmanaged
{
MethodInfo method = null;
try
{
method = typeof(FastBufferReader).GetMethod(methodName, new[] { typeof(NativeList<T>).MakeByRefType() });
}
catch (AmbiguousMatchException)
{
// skip.
}
if (method == null)
{
foreach (var candidateMethod in typeof(FastBufferReader).GetMethods())
{
if (candidateMethod.Name == methodName && candidateMethod.IsGenericMethodDefinition)
{
if (candidateMethod.GetParameters().Length == 0 || (candidateMethod.GetParameters().Length > 1 && !candidateMethod.GetParameters()[1].HasDefaultValue))
{
continue;
}
if (!candidateMethod.GetParameters()[0].ParameterType.Name.Contains("NativeList"))
{
continue;
}
try
{
method = candidateMethod.MakeGenericMethod(typeof(T));
break;
}
catch (ArgumentException)
{
continue;
}
}
}
}
Assert.NotNull(method);
object[] args = new object[method.GetParameters().Length];
args[0] = value;
for (var i = 1; i < args.Length; ++i)
{
args[i] = method.GetParameters()[i].DefaultValue;
}
method.Invoke(reader, args);
}
#endif
protected override unsafe void RunTypeTest<T>(T valueToTest)
{
var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
@@ -288,6 +494,28 @@ namespace Unity.Netcode.EditorTests
}
}
private void VerifyArrayEquality<T>(NativeArray<T> value, NativeArray<T> compareValue, int offset) where T : unmanaged
{
Assert.AreEqual(value.Length, compareValue.Length);
for (var i = 0; i < value.Length; ++i)
{
Assert.AreEqual(value[i], compareValue[i]);
}
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
private void VerifyArrayEquality<T>(NativeList<T> value, NativeList<T> compareValue, int offset) where T : unmanaged
{
Assert.AreEqual(value.Length, compareValue.Length);
for (var i = 0; i < value.Length; ++i)
{
Assert.AreEqual(value[i], compareValue[i]);
}
}
#endif
protected override unsafe void RunTypeArrayTest<T>(T[] valueToTest)
{
var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
@@ -340,6 +568,114 @@ namespace Unity.Netcode.EditorTests
}
}
protected override unsafe void RunTypeNativeArrayTest<T>(NativeArray<T> valueToTest)
{
var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
using (writer)
{
Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
Assert.IsTrue(writer.TryBeginWrite(writeSize + 2), "Writer denied write permission");
RunWriteMethod(nameof(FastBufferWriter.WriteValue), writer, valueToTest);
WriteCheckBytes(writer, writeSize);
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
VerifyPositionAndLength(reader, writer.Length);
Assert.IsTrue(reader.TryBeginRead(writeSize));
RunReadMethod(nameof(FastBufferReader.ReadValue), reader, out NativeArray<T> result);
VerifyArrayEquality(valueToTest, result, 0);
VerifyCheckBytes(reader, writeSize);
}
}
}
protected override unsafe void RunTypeNativeArrayTestSafe<T>(NativeArray<T> valueToTest)
{
var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
using (writer)
{
Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
RunWriteMethod(nameof(FastBufferWriter.WriteValueSafe), writer, valueToTest);
WriteCheckBytes(writer, writeSize);
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
VerifyPositionAndLength(reader, writer.Length);
RunReadMethod(nameof(FastBufferReader.ReadValueSafe), reader, out NativeArray<T> result);
VerifyArrayEquality(valueToTest, result, 0);
VerifyCheckBytes(reader, writeSize);
}
}
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
protected override unsafe void RunTypeNativeListTest<T>(NativeList<T> valueToTest)
{
var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
using (writer)
{
Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
Assert.IsTrue(writer.TryBeginWrite(writeSize + 2), "Writer denied write permission");
RunWriteMethod(nameof(FastBufferWriter.WriteValue), writer, valueToTest);
WriteCheckBytes(writer, writeSize);
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
VerifyPositionAndLength(reader, writer.Length);
Assert.IsTrue(reader.TryBeginRead(writeSize));
var result = new NativeList<T>(Allocator.Temp);
RunReadMethod(nameof(FastBufferReader.ReadValueInPlace), reader, ref result);
VerifyArrayEquality(valueToTest, result, 0);
VerifyCheckBytes(reader, writeSize);
}
}
}
protected override unsafe void RunTypeNativeListTestSafe<T>(NativeList<T> valueToTest)
{
var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
using (writer)
{
Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
RunWriteMethod(nameof(FastBufferWriter.WriteValueSafe), writer, valueToTest);
WriteCheckBytes(writer, writeSize);
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
VerifyPositionAndLength(reader, writer.Length);
var result = new NativeList<T>(Allocator.Temp);
RunReadMethod(nameof(FastBufferReader.ReadValueSafeInPlace), reader, ref result);
VerifyArrayEquality(valueToTest, result, 0);
VerifyCheckBytes(reader, writeSize);
}
}
}
#endif
[Test]
public void GivenFastBufferWriterContainingValue_WhenReadingUnmanagedType_ValueMatchesWhatWasWritten(
[Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
@@ -368,6 +704,35 @@ namespace Unity.Netcode.EditorTests
BaseArrayTypeTest(testType, writeType);
}
[Test]
public void GivenFastBufferWriterContainingValue_WhenReadingNativeArrayOfUnmanagedElementType_ValueMatchesWhatWasWritten(
[Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
typeof(long), typeof(ulong), typeof(bool), typeof(char), typeof(float), typeof(double),
typeof(ByteEnum), typeof(SByteEnum), typeof(ShortEnum), typeof(UShortEnum), typeof(IntEnum),
typeof(UIntEnum), typeof(LongEnum), typeof(ULongEnum), typeof(Vector2), typeof(Vector3),
typeof(Vector2Int), typeof(Vector3Int), typeof(Vector4), typeof(Quaternion), typeof(Color),
typeof(Color32), typeof(Ray), typeof(Ray2D), typeof(TestStruct))]
Type testType,
[Values] WriteType writeType)
{
BaseNativeArrayTypeTest(testType, writeType);
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
[Test]
public void GivenFastBufferWriterContainingValue_WhenReadingNativeListOfUnmanagedElementType_ValueMatchesWhatWasWritten(
[Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
typeof(long), typeof(ulong), typeof(bool), typeof(char), typeof(float), typeof(double),
typeof(ByteEnum), typeof(SByteEnum), typeof(ShortEnum), typeof(UShortEnum), typeof(IntEnum),
typeof(UIntEnum), typeof(LongEnum), typeof(ULongEnum), typeof(Vector2), typeof(Vector3),
typeof(Vector2Int), typeof(Vector3Int), typeof(Vector4), typeof(Quaternion), typeof(Color),
typeof(Color32), typeof(Ray), typeof(Ray2D), typeof(TestStruct))]
Type testType,
[Values] WriteType writeType)
{
BaseNativeListTypeTest(testType, writeType);
}
#endif
public unsafe void RunFixedStringTest<T>(T fixedStringValue, int numBytesWritten, WriteType writeType) where T : unmanaged, INativeList<byte>, IUTF8Bytes
{

242
Tests/Editor/Serialization/FastBufferWriterTests.cs
View File

@@ -2,6 +2,7 @@ using System;
using System.Reflection;
using NUnit.Framework;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using UnityEngine;
using Random = System.Random;
@@ -80,6 +81,11 @@ namespace Unity.Netcode.EditorTests
{
continue;
}
if (candidateMethod.GetParameters()[0].ParameterType.IsGenericType)
{
continue;
}
try
{
method = candidateMethod.MakeGenericMethod(typeof(T));
@@ -121,6 +127,10 @@ namespace Unity.Netcode.EditorTests
{
continue;
}
if (candidateMethod.GetParameters()[0].ParameterType.IsGenericType)
{
continue;
}
try
{
method = candidateMethod.MakeGenericMethod(typeof(T));
@@ -145,6 +155,90 @@ namespace Unity.Netcode.EditorTests
method.Invoke(writer, args);
}
private void RunMethod<T>(string methodName, FastBufferWriter writer, in NativeArray<T> value) where T : unmanaged
{
MethodInfo method = typeof(FastBufferWriter).GetMethod(methodName, new[] { typeof(NativeArray<T>) });
if (method == null)
{
foreach (var candidateMethod in typeof(FastBufferWriter).GetMethods())
{
if (candidateMethod.Name == methodName && candidateMethod.IsGenericMethodDefinition)
{
if (candidateMethod.GetParameters().Length == 0 || (candidateMethod.GetParameters().Length > 1 && !candidateMethod.GetParameters()[1].HasDefaultValue))
{
continue;
}
if (!candidateMethod.GetParameters()[0].ParameterType.Name.Contains("NativeArray"))
{
continue;
}
try
{
method = candidateMethod.MakeGenericMethod(typeof(T));
break;
}
catch (ArgumentException)
{
continue;
}
}
}
}
Assert.NotNull(method);
object[] args = new object[method.GetParameters().Length];
args[0] = value;
for (var i = 1; i < args.Length; ++i)
{
args[i] = method.GetParameters()[i].DefaultValue;
}
method.Invoke(writer, args);
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
private void RunMethod<T>(string methodName, FastBufferWriter writer, in NativeList<T> value) where T : unmanaged
{
MethodInfo method = typeof(FastBufferWriter).GetMethod(methodName, new[] { typeof(NativeList<T>) });
if (method == null)
{
foreach (var candidateMethod in typeof(FastBufferWriter).GetMethods())
{
if (candidateMethod.Name == methodName && candidateMethod.IsGenericMethodDefinition)
{
if (candidateMethod.GetParameters().Length == 0 || (candidateMethod.GetParameters().Length > 1 && !candidateMethod.GetParameters()[1].HasDefaultValue))
{
continue;
}
if (!candidateMethod.GetParameters()[0].ParameterType.Name.Contains("NativeList"))
{
continue;
}
try
{
method = candidateMethod.MakeGenericMethod(typeof(T));
break;
}
catch (ArgumentException)
{
continue;
}
}
}
}
Assert.NotNull(method);
object[] args = new object[method.GetParameters().Length];
args[0] = value;
for (var i = 1; i < args.Length; ++i)
{
args[i] = method.GetParameters()[i].DefaultValue;
}
method.Invoke(writer, args);
}
#endif
protected override unsafe void RunTypeTest<T>(T valueToTest)
{
@@ -199,6 +293,34 @@ namespace Unity.Netcode.EditorTests
}
}
private unsafe void VerifyArrayEquality<T>(NativeArray<T> value, byte* unsafePtr, int offset) where T : unmanaged
{
int* sizeValue = (int*)(unsafePtr + offset);
Assert.AreEqual(value.Length, *sizeValue);
var asTPointer = (T*)value.GetUnsafePtr();
var underlyingTArray = (T*)(unsafePtr + sizeof(int) + offset);
for (var i = 0; i < value.Length; ++i)
{
Assert.AreEqual(asTPointer[i], underlyingTArray[i]);
}
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
private unsafe void VerifyArrayEquality<T>(NativeList<T> value, byte* unsafePtr, int offset) where T : unmanaged
{
int* sizeValue = (int*)(unsafePtr + offset);
Assert.AreEqual(value.Length, *sizeValue);
var asTPointer = (T*)value.GetUnsafePtr();
var underlyingTArray = (T*)(unsafePtr + sizeof(int) + offset);
for (var i = 0; i < value.Length; ++i)
{
Assert.AreEqual(asTPointer[i], underlyingTArray[i]);
}
}
#endif
protected override unsafe void RunTypeArrayTest<T>(T[] valueToTest)
{
var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
@@ -242,6 +364,96 @@ namespace Unity.Netcode.EditorTests
}
}
protected override unsafe void RunTypeNativeArrayTest<T>(NativeArray<T> valueToTest)
{
var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
using (writer)
{
Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
Assert.IsTrue(writer.TryBeginWrite(writeSize + 2), "Writer denied write permission");
RunMethod(nameof(FastBufferWriter.WriteValue), writer, valueToTest);
VerifyPositionAndLength(writer, writeSize);
WriteCheckBytes(writer, writeSize);
VerifyArrayEquality(valueToTest, writer.GetUnsafePtr(), 0);
var underlyingArray = writer.ToArray();
VerifyCheckBytes(underlyingArray, writeSize);
}
}
protected override unsafe void RunTypeNativeArrayTestSafe<T>(NativeArray<T> valueToTest)
{
var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
using (writer)
{
Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
RunMethod(nameof(FastBufferWriter.WriteValueSafe), writer, valueToTest);
VerifyPositionAndLength(writer, writeSize);
WriteCheckBytes(writer, writeSize);
VerifyArrayEquality(valueToTest, writer.GetUnsafePtr(), 0);
var underlyingArray = writer.ToArray();
VerifyCheckBytes(underlyingArray, writeSize);
}
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
protected override unsafe void RunTypeNativeListTest<T>(NativeList<T> valueToTest)
{
var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
using (writer)
{
Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
Assert.IsTrue(writer.TryBeginWrite(writeSize + 2), "Writer denied write permission");
RunMethod(nameof(FastBufferWriter.WriteValue), writer, valueToTest);
VerifyPositionAndLength(writer, writeSize);
WriteCheckBytes(writer, writeSize);
VerifyArrayEquality(valueToTest, writer.GetUnsafePtr(), 0);
var underlyingArray = writer.ToArray();
VerifyCheckBytes(underlyingArray, writeSize);
}
}
protected override unsafe void RunTypeNativeListTestSafe<T>(NativeList<T> valueToTest)
{
var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
using (writer)
{
Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
RunMethod(nameof(FastBufferWriter.WriteValueSafe), writer, valueToTest);
VerifyPositionAndLength(writer, writeSize);
WriteCheckBytes(writer, writeSize);
VerifyArrayEquality(valueToTest, writer.GetUnsafePtr(), 0);
var underlyingArray = writer.ToArray();
VerifyCheckBytes(underlyingArray, writeSize);
}
}
#endif
[Test, Description("Tests")]
public void WhenWritingUnmanagedType_ValueIsWrittenCorrectly(
[Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
@@ -270,6 +482,36 @@ namespace Unity.Netcode.EditorTests
BaseArrayTypeTest(testType, writeType);
}
[Test]
public void WhenWritingNativeArrayOfUnmanagedElementType_NativeArrayIsWrittenCorrectly(
[Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
typeof(long), typeof(ulong), typeof(bool), typeof(char), typeof(float), typeof(double),
typeof(ByteEnum), typeof(SByteEnum), typeof(ShortEnum), typeof(UShortEnum), typeof(IntEnum),
typeof(UIntEnum), typeof(LongEnum), typeof(ULongEnum), typeof(Vector2), typeof(Vector3),
typeof(Vector2Int), typeof(Vector3Int), typeof(Vector4), typeof(Quaternion), typeof(Color),
typeof(Color32), typeof(Ray), typeof(Ray2D), typeof(TestStruct))]
Type testType,
[Values] WriteType writeType)
{
BaseNativeArrayTypeTest(testType, writeType);
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
[Test]
public void WhenWritingNativeListOfUnmanagedElementType_NativeListIsWrittenCorrectly(
[Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
typeof(long), typeof(ulong), typeof(bool), typeof(char), typeof(float), typeof(double),
typeof(ByteEnum), typeof(SByteEnum), typeof(ShortEnum), typeof(UShortEnum), typeof(IntEnum),
typeof(UIntEnum), typeof(LongEnum), typeof(ULongEnum), typeof(Vector2), typeof(Vector3),
typeof(Vector2Int), typeof(Vector3Int), typeof(Vector4), typeof(Quaternion), typeof(Color),
typeof(Color32), typeof(Ray), typeof(Ray2D), typeof(TestStruct))]
Type testType,
[Values] WriteType writeType)
{
BaseNativeListTypeTest(testType, writeType);
}
#endif
[TestCase(false, WriteType.WriteDirect)]
[TestCase(false, WriteType.WriteSafe)]
[TestCase(true, WriteType.WriteDirect)]

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

@@ -116,14 +116,14 @@ namespace Unity.Netcode.EditorTests
transport.Initialize();
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, "Network listen address (127.0.0.) is Invalid!");
#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, "127.0.0.1");
Assert.True(transport.StartServer());
@@ -143,6 +143,22 @@ namespace Unity.Netcode.EditorTests
transport.Shutdown();
}
// Check that StartClient returns false with bad connection data.
[Test]
public void UnityTransport_StartClientFailsWithBadAddress()
{
UnityTransport transport = new GameObject().AddComponent<UnityTransport>();
transport.Initialize();
transport.SetConnectionData("foobar", 4242);
Assert.False(transport.StartClient());
LogAssert.Expect(LogType.Error, "Invalid network endpoint: foobar:4242.");
LogAssert.Expect(LogType.Error, "Target server network address (foobar) is Invalid!");
transport.Shutdown();
}
#if UTP_TRANSPORT_2_0_ABOVE
[Test]
public void UnityTransport_EmptySecurityStringsShouldThrow([Values("", null)] string cert, [Values("", null)] string secret)

72
Tests/Runtime/ClientApprovalDenied.cs Normal file
View File

@@ -0,0 +1,72 @@
using System.Collections;
using System.Collections.Generic;
using NUnit.Framework;
using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests
{
public class ClientApprovalDenied : NetcodeIntegrationTest
{
protected override int NumberOfClients => 2;
private bool m_ApproveConnection = true;
private ulong m_PendingClientId = 0;
private ulong m_DisconnectedClientId = 0;
private List<ulong> m_DisconnectedClientIdentifiers = new List<ulong>();
private void ConnectionApproval(NetworkManager.ConnectionApprovalRequest connectionApprovalRequest, NetworkManager.ConnectionApprovalResponse connectionApprovalResponse)
{
connectionApprovalResponse.Approved = m_ApproveConnection;
connectionApprovalResponse.CreatePlayerObject = true;
// When denied, store the client identifier to use for validating the client disconnected notification identifier matches
if (!m_ApproveConnection)
{
m_PendingClientId = connectionApprovalRequest.ClientNetworkId;
}
}
protected override void OnNewClientCreated(NetworkManager networkManager)
{
networkManager.NetworkConfig.ConnectionApproval = true;
base.OnNewClientCreated(networkManager);
}
protected override bool ShouldWaitForNewClientToConnect(NetworkManager networkManager)
{
return false;
}
/// <summary>
/// Validates that when a pending client is denied approval the server-host
/// OnClientDisconnected method will return the valid pending client identifier.
/// </summary>
[UnityTest]
public IEnumerator ClientDeniedAndDisconnectionNotificationTest()
{
m_ServerNetworkManager.NetworkConfig.ConnectionApproval = true;
m_ServerNetworkManager.ConnectionApprovalCallback = ConnectionApproval;
m_ApproveConnection = false;
m_ServerNetworkManager.OnClientDisconnectCallback += OnClientDisconnectCallback;
yield return CreateAndStartNewClient();
yield return WaitForConditionOrTimeOut(() => m_PendingClientId == m_DisconnectedClientId);
AssertOnTimeout($"Timed out waiting for disconnect notification for pending Client-{m_PendingClientId}!");
// Validate that we don't get multiple disconnect notifications for clients being disconnected
// Have a client disconnect remotely
m_ClientNetworkManagers[0].Shutdown();
// Have the server disconnect a client
m_ServerNetworkManager.DisconnectClient(m_ClientNetworkManagers[1].LocalClientId);
m_ServerNetworkManager.OnClientDisconnectCallback -= OnClientDisconnectCallback;
}
private void OnClientDisconnectCallback(ulong clientId)
{
Assert.False(m_DisconnectedClientIdentifiers.Contains(clientId), $"Received two disconnect notifications from Client-{clientId}!");
m_DisconnectedClientIdentifiers.Add(clientId);
m_DisconnectedClientId = clientId;
}
}
}

11
Tests/Runtime/ClientApprovalDenied.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: e46e2cb14a6d49c48bc8c33094467961
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

25
Tests/Runtime/Components/NetworkVariableTestComponent.cs
View File

@@ -6,10 +6,19 @@ using UnityEngine;
namespace Unity.Netcode.RuntimeTests
{
public class EmbeddedManagedNetworkSerializableType : INetworkSerializable
{
public int Int;
public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
{
serializer.SerializeValue(ref Int);
}
}
public class ManagedNetworkSerializableType : INetworkSerializable, IEquatable<ManagedNetworkSerializableType>
{
public string Str = "";
public int[] Ints = Array.Empty<int>();
public EmbeddedManagedNetworkSerializableType Embedded = new EmbeddedManagedNetworkSerializableType();
public int InMemoryValue;
public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
@@ -28,6 +37,8 @@ namespace Unity.Netcode.RuntimeTests
serializer.SerializeValue(ref val);
Ints[i] = val;
}
serializer.SerializeValue(ref Embedded);
}
public bool Equals(ManagedNetworkSerializableType other)
@@ -60,6 +71,11 @@ namespace Unity.Netcode.RuntimeTests
}
}
if (Embedded.Int != other.Embedded.Int)
{
return false;
}
return true;
}
@@ -280,7 +296,8 @@ namespace Unity.Netcode.RuntimeTests
m_NetworkVariableManaged = new NetworkVariable<ManagedNetworkSerializableType>(new ManagedNetworkSerializableType
{
Str = "1234567890",
Ints = new[] { 1, 2, 3, 4, 5 }
Ints = new[] { 1, 2, 3, 4, 5 },
Embedded = new EmbeddedManagedNetworkSerializableType { Int = 6 }
});
// Use this nifty class: NetworkVariableHelper
@@ -386,7 +403,8 @@ namespace Unity.Netcode.RuntimeTests
Assert.IsTrue(m_NetworkVariableManaged.Value.Equals(new ManagedNetworkSerializableType
{
Str = "ManagedNetworkSerializableType",
Ints = new[] { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000 }
Ints = new[] { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000 },
Embedded = new EmbeddedManagedNetworkSerializableType { Int = 20000 }
}));
}
@@ -433,7 +451,8 @@ namespace Unity.Netcode.RuntimeTests
m_NetworkVariableManaged.Value = new ManagedNetworkSerializableType
{
Str = "ManagedNetworkSerializableType",
Ints = new[] { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000 }
Ints = new[] { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000 },
Embedded = new EmbeddedManagedNetworkSerializableType { Int = 20000 }
};
//Set the timeout (i.e. how long we will wait for all NetworkVariables to have registered their changes)

14
Tests/Runtime/ConnectionApprovalTimeoutTests.cs
View File

@@ -60,7 +60,7 @@ namespace Unity.Netcode.RuntimeTests
if (m_ApprovalFailureType == ApprovalTimedOutTypes.ServerDoesNotRespond)
{
// We catch (don't process) the incoming approval message to simulate the server not sending the approved message in time
m_ClientNetworkManagers[0].MessagingSystem.Hook(new MessageCatcher<ConnectionApprovedMessage>(m_ClientNetworkManagers[0]));
m_ClientNetworkManagers[0].ConnectionManager.MessageManager.Hook(new MessageCatcher<ConnectionApprovedMessage>(m_ClientNetworkManagers[0]));
m_ExpectedLogMessage = new Regex("Timed out waiting for the server to approve the connection request.");
m_LogType = LogType.Log;
}
@@ -68,7 +68,7 @@ namespace Unity.Netcode.RuntimeTests
{
// We catch (don't process) the incoming connection request message to simulate a transport connection but the client never
// sends (or takes too long to send) the connection request.
m_ServerNetworkManager.MessagingSystem.Hook(new MessageCatcher<ConnectionRequestMessage>(m_ServerNetworkManager));
m_ServerNetworkManager.ConnectionManager.MessageManager.Hook(new MessageCatcher<ConnectionRequestMessage>(m_ServerNetworkManager));
// For this test, we know the timed out client will be Client-1
m_ExpectedLogMessage = new Regex("Server detected a transport connection from Client-1, but timed out waiting for the connection request message.");
@@ -86,16 +86,18 @@ namespace Unity.Netcode.RuntimeTests
// Verify we haven't received the time out message yet
NetcodeLogAssert.LogWasNotReceived(LogType.Log, m_ExpectedLogMessage);
// Wait for 3/4s of the time out period to pass (totaling 1.25x the wait period)
yield return new WaitForSeconds(k_TestTimeoutPeriod * 0.75f);
yield return new WaitForSeconds(k_TestTimeoutPeriod * 1.5f);
// We should have the test relative log message by this time.
NetcodeLogAssert.LogWasReceived(m_LogType, m_ExpectedLogMessage);
Debug.Log("Checking connected client count");
// It should only have the host client connected
Assert.AreEqual(1, m_ServerNetworkManager.ConnectedClients.Count, $"Expected only one client when there were {m_ServerNetworkManager.ConnectedClients.Count} clients connected!");
Assert.AreEqual(0, m_ServerNetworkManager.PendingClients.Count, $"Expected no pending clients when there were {m_ServerNetworkManager.PendingClients.Count} pending clients!");
Assert.True(!m_ClientNetworkManagers[0].IsApproved, $"Expected the client to not have been approved, but it was!");
Assert.AreEqual(0, m_ServerNetworkManager.ConnectionManager.PendingClients.Count, $"Expected no pending clients when there were {m_ServerNetworkManager.ConnectionManager.PendingClients.Count} pending clients!");
Assert.True(!m_ClientNetworkManagers[0].LocalClient.IsApproved, $"Expected the client to not have been approved, but it was!");
}
}
}

110
Tests/Runtime/DeferredMessagingTests.cs
View File

@@ -50,7 +50,7 @@ namespace Unity.Netcode.RuntimeTests
return ret;
}
public int DeferredMessageCountForType(IDeferredMessageManager.TriggerType trigger)
public int DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType trigger)
{
var count = 0;
if (m_Triggers.TryGetValue(trigger, out var dict))
@@ -68,7 +68,7 @@ namespace Unity.Netcode.RuntimeTests
return count;
}
public int DeferredMessageCountForKey(IDeferredMessageManager.TriggerType trigger, ulong key)
public int DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType trigger, ulong key)
{
if (m_PurgedKeys.Contains(key))
{
@@ -85,20 +85,20 @@ namespace Unity.Netcode.RuntimeTests
return 0;
}
public override void DeferMessage(IDeferredMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context)
public override void DeferMessage(IDeferredNetworkMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context)
{
OnBeforeDefer?.Invoke(this, key);
DeferMessageCalled = true;
base.DeferMessage(trigger, key, reader, ref context);
}
public override void ProcessTriggers(IDeferredMessageManager.TriggerType trigger, ulong key)
public override void ProcessTriggers(IDeferredNetworkMessageManager.TriggerType trigger, ulong key)
{
ProcessTriggersCalled = true;
base.ProcessTriggers(trigger, key);
}
protected override void PurgeTrigger(IDeferredMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
protected override void PurgeTrigger(IDeferredNetworkMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
{
OnBeforePurge?.Invoke(this, key);
base.PurgeTrigger(triggerType, key, triggerInfo);
@@ -207,13 +207,13 @@ namespace Unity.Netcode.RuntimeTests
m_UseHost = false;
// Replace the IDeferredMessageManager component with our test one in the component factory
ComponentFactory.Register<IDeferredMessageManager>(networkManager => new TestDeferredMessageManager(networkManager));
ComponentFactory.Register<IDeferredNetworkMessageManager>(networkManager => new TestDeferredMessageManager(networkManager));
}
protected override void OnInlineTearDown()
{
// Revert the IDeferredMessageManager component to its default (DeferredMessageManager)
ComponentFactory.Deregister<IDeferredMessageManager>();
ComponentFactory.Deregister<IDeferredNetworkMessageManager>();
m_ClientSpawnCatchers.Clear();
}
@@ -294,7 +294,7 @@ namespace Unity.Netcode.RuntimeTests
{
var catcher = new MessageCatcher<CreateObjectMessage>(client);
m_ClientSpawnCatchers.Add(catcher);
client.MessagingSystem.Hook(catcher);
client.ConnectionManager.MessageManager.Hook(catcher);
}
}
@@ -303,7 +303,7 @@ namespace Unity.Netcode.RuntimeTests
for (var i = 0; i < m_ClientNetworkManagers.Length; ++i)
{
// Unhook first so the spawn catcher stops catching spawns
m_ClientNetworkManagers[i].MessagingSystem.Unhook(m_ClientSpawnCatchers[i]);
m_ClientNetworkManagers[i].ConnectionManager.MessageManager.Unhook(m_ClientSpawnCatchers[i]);
m_ClientSpawnCatchers[i].ReleaseMessages();
}
m_ClientSpawnCatchers.Clear();
@@ -343,9 +343,9 @@ namespace Unity.Netcode.RuntimeTests
private void AssertSpawnTriggerCountForObject(TestDeferredMessageManager manager, GameObject serverObject, int expectedCount = 1)
{
Assert.AreEqual(expectedCount, manager.DeferredMessageCountTotal());
Assert.AreEqual(expectedCount, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(expectedCount, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnAddPrefab));
Assert.AreEqual(expectedCount, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(expectedCount, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab));
}
private void WaitForAllClientsToReceive<T>() where T : INetworkMessage
@@ -505,9 +505,9 @@ namespace Unity.Netcode.RuntimeTests
Assert.IsTrue(manager.DeferMessageCalled);
Assert.IsFalse(manager.ProcessTriggersCalled);
Assert.AreEqual(1, manager.DeferredMessageCountTotal());
Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnAddPrefab));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnAddPrefab, serverObject.GetComponent<NetworkObject>().GlobalObjectIdHash));
Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, serverObject.GetComponent<NetworkObject>().GlobalObjectIdHash));
var component = GetComponentForClient<DeferredMessageTestRpcComponent>(client.LocalClientId);
Assert.IsNull(component);
@@ -672,9 +672,9 @@ namespace Unity.Netcode.RuntimeTests
Assert.IsFalse(manager.ProcessTriggersCalled);
Assert.AreEqual(4, manager.DeferredMessageCountTotal());
Assert.AreEqual(4, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(4, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnAddPrefab));
Assert.AreEqual(4, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(4, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab));
AddPrefabsToClient(client);
}
@@ -731,9 +731,9 @@ namespace Unity.Netcode.RuntimeTests
Assert.IsFalse(manager.ProcessTriggersCalled);
Assert.AreEqual(2, manager.DeferredMessageCountTotal());
Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnAddPrefab));
Assert.AreEqual(2, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnAddPrefab, serverObject.GetComponent<NetworkObject>().GlobalObjectIdHash));
Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab));
Assert.AreEqual(2, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, serverObject.GetComponent<NetworkObject>().GlobalObjectIdHash));
AddPrefabsToClient(client);
}
@@ -816,10 +816,10 @@ namespace Unity.Netcode.RuntimeTests
Assert.AreEqual(5, manager.DeferredMessageCountTotal());
Assert.AreEqual(4, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(4, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnAddPrefab));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnAddPrefab, serverObject.GetComponent<NetworkObject>().GlobalObjectIdHash));
Assert.AreEqual(4, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(4, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, serverObject.GetComponent<NetworkObject>().GlobalObjectIdHash));
AddPrefabsToClient(client);
}
@@ -890,7 +890,7 @@ namespace Unity.Netcode.RuntimeTests
foreach (var unused in m_ClientNetworkManagers)
{
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
}
int purgeCount = 0;
@@ -903,8 +903,8 @@ namespace Unity.Netcode.RuntimeTests
Debug.Log(client.RealTimeProvider.GetType().FullName);
Assert.GreaterOrEqual(elapsed, timeout);
Assert.AreEqual(1, manager.DeferredMessageCountTotal());
Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, key));
Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, key));
Assert.AreEqual(serverObject.GetComponent<NetworkObject>().NetworkObjectId, key);
};
var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
@@ -986,7 +986,7 @@ namespace Unity.Netcode.RuntimeTests
foreach (var unused in m_ClientNetworkManagers)
{
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
}
int purgeCount = 0;
@@ -998,8 +998,8 @@ namespace Unity.Netcode.RuntimeTests
var elapsed = client.RealTimeProvider.RealTimeSinceStartup - start;
Assert.GreaterOrEqual(elapsed, timeout);
Assert.AreEqual(3, manager.DeferredMessageCountTotal());
Assert.AreEqual(3, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(3, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, key));
Assert.AreEqual(3, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(3, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, key));
Assert.AreEqual(serverObject.GetComponent<NetworkObject>().NetworkObjectId, key);
};
var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
@@ -1092,8 +1092,8 @@ namespace Unity.Netcode.RuntimeTests
foreach (var unused in m_ClientNetworkManagers)
{
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredMessageManager.TriggerType.OnSpawn} with key {serverObject2.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject2.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
}
int purgeCount = 0;
@@ -1106,8 +1106,8 @@ namespace Unity.Netcode.RuntimeTests
var elapsed = client.RealTimeProvider.RealTimeSinceStartup - start;
Assert.GreaterOrEqual(elapsed, timeout - 0.25f);
Assert.AreEqual(remainingMessagesTotalThisClient, manager.DeferredMessageCountTotal());
Assert.AreEqual(remainingMessagesTotalThisClient, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(3, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, key));
Assert.AreEqual(remainingMessagesTotalThisClient, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(3, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, key));
remainingMessagesTotalThisClient -= 3;
};
var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
@@ -1167,8 +1167,8 @@ namespace Unity.Netcode.RuntimeTests
{
var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
Assert.AreEqual(1, manager.DeferredMessageCountTotal());
Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
}
serverObject.GetComponent<NetworkObject>().ChangeOwnership(m_ServerNetworkManager.LocalClientId);
@@ -1178,13 +1178,13 @@ namespace Unity.Netcode.RuntimeTests
{
var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
Assert.AreEqual(2, manager.DeferredMessageCountTotal());
Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(2, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(2, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
}
foreach (var unused in m_ClientNetworkManagers)
{
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
}
int purgeCount = 0;
@@ -1196,8 +1196,8 @@ namespace Unity.Netcode.RuntimeTests
var elapsed = client.RealTimeProvider.RealTimeSinceStartup - start;
Assert.GreaterOrEqual(elapsed, timeout - 0.05f);
Assert.AreEqual(2, manager.DeferredMessageCountTotal());
Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(2, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, key));
Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(2, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, key));
Assert.AreEqual(serverObject.GetComponent<NetworkObject>().NetworkObjectId, key);
};
var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
@@ -1262,9 +1262,9 @@ namespace Unity.Netcode.RuntimeTests
{
var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
Assert.AreEqual(1, manager.DeferredMessageCountTotal());
Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(0, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(0, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
}
serverObject2.GetComponent<NetworkObject>().ChangeOwnership(m_ServerNetworkManager.LocalClientId);
@@ -1274,14 +1274,14 @@ namespace Unity.Netcode.RuntimeTests
{
var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
Assert.AreEqual(2, manager.DeferredMessageCountTotal());
Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
}
foreach (var unused in m_ClientNetworkManagers)
{
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
}
int purgeCount = 0;
@@ -1293,10 +1293,10 @@ namespace Unity.Netcode.RuntimeTests
var elapsed = client.RealTimeProvider.RealTimeSinceStartup - start;
Assert.GreaterOrEqual(elapsed, timeout - 0.05f);
Assert.AreEqual(2, manager.DeferredMessageCountTotal());
Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(serverObject.GetComponent<NetworkObject>().NetworkObjectId, key);
};
@@ -1316,9 +1316,9 @@ namespace Unity.Netcode.RuntimeTests
{
var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
Assert.AreEqual(1, manager.DeferredMessageCountTotal());
Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(0, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
Assert.AreEqual(0, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
}
foreach (var client in m_ClientNetworkManagers)
{

212
Tests/Runtime/DisconnectTests.cs
View File

@@ -2,111 +2,165 @@ using System.Collections;
using System.Linq;
using NUnit.Framework;
using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine;
using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests
{
public class DisconnectTests
/// <summary>
/// Validates the client disconnection process.
/// This assures that:
/// - When a client disconnects from the server that the server:
/// -- Detects the client disconnected.
/// -- Cleans up the transport to NGO client (and vice versa) mappings.
/// - When a server disconnects a client that:
/// -- The client detects this disconnection.
/// -- The server cleans up the transport to NGO client (and vice versa) mappings.
/// - When <see cref="OwnerPersistence.DestroyWithOwner"/> the server-side player object is destroyed
/// - When <see cref="OwnerPersistence.DontDestroyWithOwner"/> the server-side player object ownership is transferred back to the server
/// </summary>
[TestFixture(OwnerPersistence.DestroyWithOwner)]
[TestFixture(OwnerPersistence.DontDestroyWithOwner)]
public class DisconnectTests : NetcodeIntegrationTest
{
private bool m_ClientDisconnected;
[UnityTest]
public IEnumerator RemoteDisconnectPlayerObjectCleanup()
public enum OwnerPersistence
{
// create server and client instances
NetcodeIntegrationTestHelpers.Create(1, out NetworkManager server, out NetworkManager[] clients);
// create prefab
var gameObject = new GameObject("PlayerObject");
var networkObject = gameObject.AddComponent<NetworkObject>();
networkObject.DontDestroyWithOwner = true;
NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject);
server.NetworkConfig.PlayerPrefab = gameObject;
for (int i = 0; i < clients.Length; i++)
{
clients[i].NetworkConfig.PlayerPrefab = gameObject;
}
// start server and connect clients
NetcodeIntegrationTestHelpers.Start(false, server, clients);
// wait for connection on client side
yield return NetcodeIntegrationTestHelpers.WaitForClientsConnected(clients);
// wait for connection on server side
yield return NetcodeIntegrationTestHelpers.WaitForClientConnectedToServer(server);
// disconnect the remote client
m_ClientDisconnected = false;
server.DisconnectClient(clients[0].LocalClientId);
clients[0].OnClientDisconnectCallback += OnClientDisconnectCallback;
var timeoutHelper = new TimeoutHelper();
yield return NetcodeIntegrationTest.WaitForConditionOrTimeOut(() => m_ClientDisconnected, timeoutHelper);
// We need to do this to remove other associated client properties/values from NetcodeIntegrationTestHelpers
NetcodeIntegrationTestHelpers.StopOneClient(clients[0]);
// ensure the object was destroyed
Assert.False(server.SpawnManager.SpawnedObjects.Any(x => x.Value.IsPlayerObject && x.Value.OwnerClientId == clients[0].LocalClientId));
// cleanup
NetcodeIntegrationTestHelpers.Destroy();
DestroyWithOwner,
DontDestroyWithOwner
}
public enum ClientDisconnectType
{
ServerDisconnectsClient,
ClientDisconnectsFromServer
}
protected override int NumberOfClients => 1;
private OwnerPersistence m_OwnerPersistence;
private bool m_ClientDisconnected;
private ulong m_TransportClientId;
private ulong m_ClientId;
public DisconnectTests(OwnerPersistence ownerPersistence)
{
m_OwnerPersistence = ownerPersistence;
}
protected override void OnCreatePlayerPrefab()
{
m_PlayerPrefab.GetComponent<NetworkObject>().DontDestroyWithOwner = m_OwnerPersistence == OwnerPersistence.DontDestroyWithOwner;
base.OnCreatePlayerPrefab();
}
protected override void OnServerAndClientsCreated()
{
// Adjusting client and server timeout periods to reduce test time
// Get the tick frequency in milliseconds and triple it for the heartbeat timeout
var heartBeatTimeout = (int)(300 * (1.0f / m_ServerNetworkManager.NetworkConfig.TickRate));
var unityTransport = m_ServerNetworkManager.NetworkConfig.NetworkTransport as Transports.UTP.UnityTransport;
if (unityTransport != null)
{
unityTransport.HeartbeatTimeoutMS = heartBeatTimeout;
}
unityTransport = m_ClientNetworkManagers[0].NetworkConfig.NetworkTransport as Transports.UTP.UnityTransport;
if (unityTransport != null)
{
unityTransport.HeartbeatTimeoutMS = heartBeatTimeout;
}
base.OnServerAndClientsCreated();
}
protected override IEnumerator OnSetup()
{
m_ClientDisconnected = false;
m_ClientId = 0;
m_TransportClientId = 0;
return base.OnSetup();
}
/// <summary>
/// Used to detect the client disconnected on the server side
/// </summary>
private void OnClientDisconnectCallback(ulong obj)
{
m_ClientDisconnected = true;
}
[UnityTest]
public IEnumerator ClientDisconnectPlayerObjectCleanup()
/// <summary>
/// Conditional check to assure the transport to client (and vice versa) mappings are cleaned up
/// </summary>
private bool TransportIdCleanedUp()
{
// create server and client instances
NetcodeIntegrationTestHelpers.Create(1, out NetworkManager server, out NetworkManager[] clients);
// create prefab
var gameObject = new GameObject("PlayerObject");
var networkObject = gameObject.AddComponent<NetworkObject>();
networkObject.DontDestroyWithOwner = true;
NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject);
server.NetworkConfig.PlayerPrefab = gameObject;
for (int i = 0; i < clients.Length; i++)
if (m_ServerNetworkManager.ConnectionManager.TransportIdToClientId(m_TransportClientId) == m_ClientId)
{
clients[i].NetworkConfig.PlayerPrefab = gameObject;
return false;
}
// start server and connect clients
NetcodeIntegrationTestHelpers.Start(false, server, clients);
if (m_ServerNetworkManager.ConnectionManager.ClientIdToTransportId(m_ClientId) == m_TransportClientId)
{
return false;
}
return true;
}
// wait for connection on client side
yield return NetcodeIntegrationTestHelpers.WaitForClientsConnected(clients);
/// <summary>
/// Conditional check to make sure the client player object no longer exists on the server side
/// </summary>
private bool DoesServerStillHaveSpawnedPlayerObject()
{
if (m_PlayerNetworkObjects[m_ServerNetworkManager.LocalClientId].ContainsKey(m_ClientId))
{
var playerObject = m_PlayerNetworkObjects[m_ServerNetworkManager.LocalClientId][m_ClientId];
if (playerObject != null && playerObject.IsSpawned)
{
return false;
}
}
return !m_ServerNetworkManager.SpawnManager.SpawnedObjects.Any(x => x.Value.IsPlayerObject && x.Value.OwnerClientId == m_ClientId);
}
// wait for connection on server side
yield return NetcodeIntegrationTestHelpers.WaitForClientConnectedToServer(server);
[UnityTest]
public IEnumerator ClientPlayerDisconnected([Values] ClientDisconnectType clientDisconnectType)
{
m_ClientId = m_ClientNetworkManagers[0].LocalClientId;
// disconnect the remote client
m_ClientDisconnected = false;
var serverSideClientPlayer = m_ServerNetworkManager.ConnectionManager.ConnectedClients[m_ClientId].PlayerObject;
server.OnClientDisconnectCallback += OnClientDisconnectCallback;
m_TransportClientId = m_ServerNetworkManager.ConnectionManager.ClientIdToTransportId(m_ClientId);
var serverSideClientPlayer = server.ConnectedClients[clients[0].LocalClientId].PlayerObject;
if (clientDisconnectType == ClientDisconnectType.ServerDisconnectsClient)
{
m_ClientNetworkManagers[0].OnClientDisconnectCallback += OnClientDisconnectCallback;
m_ServerNetworkManager.DisconnectClient(m_ClientId);
}
else
{
m_ServerNetworkManager.OnClientDisconnectCallback += OnClientDisconnectCallback;
// Stopping the client is the same as the client disconnecting
NetcodeIntegrationTestHelpers.StopOneClient(clients[0]);
yield return StopOneClient(m_ClientNetworkManagers[0]);
}
var timeoutHelper = new TimeoutHelper();
yield return NetcodeIntegrationTest.WaitForConditionOrTimeOut(() => m_ClientDisconnected, timeoutHelper);
yield return WaitForConditionOrTimeOut(() => m_ClientDisconnected);
AssertOnTimeout("Timed out waiting for client to disconnect!");
// ensure the object was destroyed
Assert.True(serverSideClientPlayer.IsOwnedByServer, $"The client's player object's ownership was not transferred back to the server!");
if (m_OwnerPersistence == OwnerPersistence.DestroyWithOwner)
{
// When we are destroying with the owner, validate the player object is destroyed on the server side
yield return WaitForConditionOrTimeOut(DoesServerStillHaveSpawnedPlayerObject);
AssertOnTimeout("Timed out waiting for client's player object to be destroyed!");
}
else
{
// When we are not destroying with the owner, ensure the player object's ownership was transferred back to the server
yield return WaitForConditionOrTimeOut(() => serverSideClientPlayer.IsOwnedByServer);
AssertOnTimeout("The client's player object's ownership was not transferred back to the server!");
}
// cleanup
NetcodeIntegrationTestHelpers.Destroy();
yield return WaitForConditionOrTimeOut(TransportIdCleanedUp);
AssertOnTimeout("Timed out waiting for transport and client id mappings to be cleaned up!");
}
}
}

16
Tests/Runtime/InvalidConnectionEventsTest.cs
View File

@@ -80,7 +80,7 @@ namespace Unity.Netcode.RuntimeTests
public IEnumerator WhenSendingConnectionApprovedToAlreadyConnectedClient_ConnectionApprovedMessageIsRejected()
{
var message = new ConnectionApprovedMessage();
m_ServerNetworkManager.SendMessage(ref message, NetworkDelivery.Reliable, m_ClientNetworkManagers[0].LocalClientId);
m_ServerNetworkManager.ConnectionManager.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.
@@ -91,7 +91,7 @@ namespace Unity.Netcode.RuntimeTests
m_ServerNetworkManager.CustomMessagingManager.SendUnnamedMessage(m_ClientNetworkManagers[0].LocalClientId, writer);
}
m_ClientNetworkManagers[0].MessagingSystem.Hook(new Hooks<ConnectionApprovedMessage>());
m_ClientNetworkManagers[0].ConnectionManager.MessageManager.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\\."));
@@ -102,7 +102,7 @@ namespace Unity.Netcode.RuntimeTests
public IEnumerator WhenSendingConnectionRequestToAnyClient_ConnectionRequestMessageIsRejected()
{
var message = new ConnectionRequestMessage();
m_ServerNetworkManager.SendMessage(ref message, NetworkDelivery.Reliable, m_ClientNetworkManagers[0].LocalClientId);
m_ServerNetworkManager.ConnectionManager.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.
@@ -113,7 +113,7 @@ namespace Unity.Netcode.RuntimeTests
m_ServerNetworkManager.CustomMessagingManager.SendUnnamedMessage(m_ClientNetworkManagers[0].LocalClientId, writer);
}
m_ClientNetworkManagers[0].MessagingSystem.Hook(new Hooks<ConnectionRequestMessage>());
m_ClientNetworkManagers[0].ConnectionManager.MessageManager.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\\."));
@@ -124,7 +124,7 @@ namespace Unity.Netcode.RuntimeTests
public IEnumerator WhenSendingConnectionRequestFromAlreadyConnectedClient_ConnectionRequestMessageIsRejected()
{
var message = new ConnectionRequestMessage();
m_ClientNetworkManagers[0].SendMessage(ref message, NetworkDelivery.Reliable, m_ServerNetworkManager.LocalClientId);
m_ClientNetworkManagers[0].ConnectionManager.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.
@@ -135,7 +135,7 @@ namespace Unity.Netcode.RuntimeTests
m_ClientNetworkManagers[0].CustomMessagingManager.SendUnnamedMessage(m_ServerNetworkManager.LocalClientId, writer);
}
m_ServerNetworkManager.MessagingSystem.Hook(new Hooks<ConnectionRequestMessage>());
m_ServerNetworkManager.ConnectionManager.MessageManager.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\\."));
@@ -146,7 +146,7 @@ namespace Unity.Netcode.RuntimeTests
public IEnumerator WhenSendingConnectionApprovedFromAnyClient_ConnectionApprovedMessageIsRejected()
{
var message = new ConnectionApprovedMessage();
m_ClientNetworkManagers[0].SendMessage(ref message, NetworkDelivery.Reliable, m_ServerNetworkManager.LocalClientId);
m_ClientNetworkManagers[0].ConnectionManager.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.
@@ -157,7 +157,7 @@ namespace Unity.Netcode.RuntimeTests
m_ClientNetworkManagers[0].CustomMessagingManager.SendUnnamedMessage(m_ServerNetworkManager.LocalClientId, writer);
}
m_ServerNetworkManager.MessagingSystem.Hook(new Hooks<ConnectionApprovedMessage>());
m_ServerNetworkManager.ConnectionManager.MessageManager.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\\."));

8
Tests/Runtime/Metrics/ServerLogsMetricTests.cs
View File

@@ -37,6 +37,8 @@ namespace Unity.Netcode.RuntimeTests.Metrics
[UnityTest]
public IEnumerator TrackServerLogSentMetric()
{
// Set the client NetworkManager to assure the log is sent
NetworkLog.NetworkManagerOverride = Client;
var waitForSentMetric = new WaitForEventMetricValues<ServerLogEvent>(ClientMetrics.Dispatcher, NetworkMetricTypes.ServerLogSent);
var message = Guid.NewGuid().ToString();
@@ -82,6 +84,12 @@ namespace Unity.Netcode.RuntimeTests.Metrics
var serializedLength = GetWriteSizeForLog(NetworkLog.LogType.Warning, message);
Assert.AreEqual(serializedLength, receivedMetric.BytesCount);
}
protected override IEnumerator OnTearDown()
{
NetworkLog.NetworkManagerOverride = null;
return base.OnTearDown();
}
}
}
#endif

2
Tests/Runtime/Metrics/TransportBytesMetricsTests.cs
View File

@@ -14,7 +14,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
{
// Header is dynamically sized due to packing, will be 2 bytes for all test messages.
private const int k_MessageHeaderSize = 2;
private static readonly long k_MessageOverhead = 8 + FastBufferWriter.GetWriteSize<BatchHeader>() + k_MessageHeaderSize;
private static readonly long k_MessageOverhead = 8 + FastBufferWriter.GetWriteSize<NetworkBatchHeader>() + k_MessageHeaderSize;
[UnityTest]
public IEnumerator TrackTotalNumberOfBytesSent()

2
Tests/Runtime/NetworkBehaviourUpdaterTests.cs
View File

@@ -312,7 +312,7 @@ namespace Unity.Netcode.RuntimeTests
}
// Update the NetworkBehaviours to make sure all network variables are no longer marked as dirty
m_ServerNetworkManager.BehaviourUpdater.NetworkBehaviourUpdate(m_ServerNetworkManager);
m_ServerNetworkManager.BehaviourUpdater.NetworkBehaviourUpdate();
// Verify that all network variables are no longer dirty on server side only if we have clients (including host)
foreach (var serverSpawnedObject in spawnedPrefabs)

24
Tests/Runtime/NetworkManagerEventsTests.cs
View File

@@ -27,10 +27,6 @@ namespace Unity.Netcode.RuntimeTests
{
callbackInvoked = true;
Assert.IsFalse(wasAlsoClient);
if (m_ServerManager.IsServer)
{
Assert.Fail("OnServerStopped called when the server is still active");
}
};
// Start server to cause initialization process
@@ -57,10 +53,6 @@ namespace Unity.Netcode.RuntimeTests
{
callbackInvoked = true;
Assert.IsFalse(wasAlsoServer);
if (m_ClientManager.IsClient)
{
Assert.Fail("onClientStopped called when the client is still active");
}
};
m_ClientManager.OnClientStopped += onClientStopped;
@@ -85,20 +77,12 @@ namespace Unity.Netcode.RuntimeTests
{
callbacksInvoked++;
Assert.IsTrue(wasAlsoServer);
if (m_ServerManager.IsClient)
{
Assert.Fail("onClientStopped called when the client is still active");
}
};
Action<bool> onServerStopped = (bool wasAlsoClient) =>
{
callbacksInvoked++;
Assert.IsTrue(wasAlsoClient);
if (m_ServerManager.IsServer)
{
Assert.Fail("OnServerStopped called when the server is still active");
}
};
// Start server to cause initialization process
@@ -179,19 +163,11 @@ namespace Unity.Netcode.RuntimeTests
Action onClientStarted = () =>
{
callbacksInvoked++;
if (!m_ServerManager.IsClient)
{
Assert.Fail("OnClientStarted called when the client is not active yet");
}
};
Action onServerStarted = () =>
{
callbacksInvoked++;
if (!m_ServerManager.IsServer)
{
Assert.Fail("OnServerStarted called when the server is not active yet");
}
};
m_ServerManager.OnServerStarted += onServerStarted;

8
Tests/Runtime/NetworkManagerTransportTests.cs
View File

@@ -22,7 +22,7 @@ namespace Unity.Netcode.RuntimeTests
manager.NetworkConfig = new NetworkConfig() { NetworkTransport = transport };
LogAssert.Expect(LogType.Error, $"Client is shutting down due to network transport start failure of {transport.GetType().Name}!");
LogAssert.Expect(LogType.Error, $"[Netcode] Client is shutting down due to network transport start failure of {transport.GetType().Name}!");
Assert.False(manager.StartClient());
Assert.False(manager.IsListening);
@@ -45,7 +45,7 @@ namespace Unity.Netcode.RuntimeTests
manager.NetworkConfig = new NetworkConfig() { NetworkTransport = transport };
LogAssert.Expect(LogType.Error, $"Server is shutting down due to network transport start failure of {transport.GetType().Name}!");
LogAssert.Expect(LogType.Error, $"[Netcode] Host is shutting down due to network transport start failure of {transport.GetType().Name}!");
Assert.False(manager.StartHost());
Assert.False(manager.IsListening);
@@ -67,7 +67,7 @@ namespace Unity.Netcode.RuntimeTests
manager.NetworkConfig = new NetworkConfig() { NetworkTransport = transport };
LogAssert.Expect(LogType.Error, $"Server is shutting down due to network transport start failure of {transport.GetType().Name}!");
LogAssert.Expect(LogType.Error, $"[Netcode] Server is shutting down due to network transport start failure of {transport.GetType().Name}!");
Assert.False(manager.StartServer());
Assert.False(manager.IsListening);
@@ -92,7 +92,7 @@ namespace Unity.Netcode.RuntimeTests
Assert.True(manager.StartServer());
Assert.True(manager.IsListening);
LogAssert.Expect(LogType.Error, $"Shutting down due to network transport failure of {transport.GetType().Name}!");
LogAssert.Expect(LogType.Error, $"[Netcode] Server is shutting down due to network transport failure of {transport.GetType().Name}!");
// Need two updates to actually shut down. First one to see the transport failing, which
// marks the NetworkManager as shutting down. Second one where actual shutdown occurs.

69
Tests/Runtime/NetworkObject/NetworkObjectDestroyTests.cs
View File

@@ -52,24 +52,63 @@ namespace Unity.Netcode.RuntimeTests
Assert.IsTrue(go == null);
}
/// <summary>
/// Tests that a client cannot destroy a spawned networkobject.
/// </summary>
/// <returns></returns>
[UnityTest]
public IEnumerator TestNetworkObjectClientDestroy()
public enum ClientDestroyObject
{
// This is the *SERVER VERSION* of the *CLIENT PLAYER*
var serverClientPlayerResult = new NetcodeIntegrationTestHelpers.ResultWrapper<NetworkObject>();
yield return NetcodeIntegrationTestHelpers.GetNetworkObjectByRepresentation(x => x.IsPlayerObject && x.OwnerClientId == m_ClientNetworkManagers[0].LocalClientId, m_ServerNetworkManager, serverClientPlayerResult);
ShuttingDown,
ActiveSession
}
/// <summary>
/// Validates the expected behavior when the client-side destroys a <see cref="NetworkObject"/>
/// </summary>
[UnityTest]
public IEnumerator TestNetworkObjectClientDestroy([Values] ClientDestroyObject clientDestroyObject)
{
var isShuttingDown = clientDestroyObject == ClientDestroyObject.ShuttingDown;
var clientPlayer = m_ClientNetworkManagers[0].LocalClient.PlayerObject;
var clientId = clientPlayer.OwnerClientId;
// This is the *CLIENT VERSION* of the *CLIENT PLAYER*
var clientClientPlayerResult = new NetcodeIntegrationTestHelpers.ResultWrapper<NetworkObject>();
yield return NetcodeIntegrationTestHelpers.GetNetworkObjectByRepresentation(x => x.IsPlayerObject && x.OwnerClientId == m_ClientNetworkManagers[0].LocalClientId, m_ClientNetworkManagers[0], clientClientPlayerResult);
//destroying a NetworkObject while shutting down is allowed
if (isShuttingDown)
{
m_ClientNetworkManagers[0].Shutdown();
}
else
{
LogAssert.ignoreFailingMessages = true;
NetworkLog.NetworkManagerOverride = m_ClientNetworkManagers[0];
}
// destroy the client player, this is not allowed
LogAssert.Expect(LogType.Exception, "NotServerException: Destroy a spawned NetworkObject on a non-host client is not valid. Call Destroy or Despawn on the server/host instead.");
Object.DestroyImmediate(clientClientPlayerResult.Result.gameObject);
Object.DestroyImmediate(clientPlayer.gameObject);
// destroying a NetworkObject while a session is active is not allowed
if (!isShuttingDown)
{
yield return WaitForConditionOrTimeOut(HaveLogsBeenReceived);
AssertOnTimeout($"Not all expected logs were received when destroying a {nameof(NetworkObject)} on the client side during an active session!");
}
}
private bool HaveLogsBeenReceived()
{
if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, "[Netcode] Destroy a spawned NetworkObject on a non-host client is not valid. Call Destroy or Despawn on the server/host instead."))
{
return false;
}
if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, $"[Netcode-Server Sender={m_ClientNetworkManagers[0].LocalClientId}] Destroy a spawned NetworkObject on a non-host client is not valid. Call Destroy or Despawn on the server/host instead."))
{
return false;
}
return true;
}
protected override IEnumerator OnTearDown()
{
NetworkLog.NetworkManagerOverride = null;
LogAssert.ignoreFailingMessages = false;
return base.OnTearDown();
}
}
}

85
Tests/Runtime/NetworkObject/NetworkObjectOnSpawnTests.cs
View File

@@ -14,6 +14,86 @@ namespace Unity.Netcode.RuntimeTests
protected override int NumberOfClients => 2;
public enum ObserverTestTypes
{
WithObservers,
WithoutObservers
}
private GameObject m_ObserverPrefab;
private NetworkObject m_ObserverTestNetworkObject;
private ObserverTestTypes m_ObserverTestType;
private const string k_ObserverTestObjName = "ObsObj";
private const string k_WithObserversError = "Not all clients spawned the";
private const string k_WithoutObserversError = "A client spawned the";
protected override void OnServerAndClientsCreated()
{
m_ObserverPrefab = CreateNetworkObjectPrefab(k_ObserverTestObjName);
base.OnServerAndClientsCreated();
}
private bool CheckClientsSideObserverTestObj()
{
foreach (var client in m_ClientNetworkManagers)
{
if (!s_GlobalNetworkObjects.ContainsKey(client.LocalClientId))
{
// When no observers there shouldn't be any client spawned NetworkObjects
// (players are held in a different list)
return !(m_ObserverTestType == ObserverTestTypes.WithObservers);
}
var clientObjects = s_GlobalNetworkObjects[client.LocalClientId];
// Make sure they did spawn the object
if (m_ObserverTestType == ObserverTestTypes.WithObservers)
{
if (!clientObjects.ContainsKey(m_ObserverTestNetworkObject.NetworkObjectId))
{
return false;
}
if (!clientObjects[m_ObserverTestNetworkObject.NetworkObjectId].IsSpawned)
{
return false;
}
}
}
return true;
}
[UnityTest]
public IEnumerator ObserverSpawnTests([Values] ObserverTestTypes observerTestTypes)
{
m_ObserverTestType = observerTestTypes;
var prefabNetworkObject = m_ObserverPrefab.GetComponent<NetworkObject>();
prefabNetworkObject.SpawnWithObservers = observerTestTypes == ObserverTestTypes.WithObservers;
var instance = SpawnObject(m_ObserverPrefab, m_ServerNetworkManager);
m_ObserverTestNetworkObject = instance.GetComponent<NetworkObject>();
var withoutObservers = m_ObserverTestType == ObserverTestTypes.WithoutObservers;
if (withoutObservers)
{
// Just give a little time to make sure nothing spawned
yield return s_DefaultWaitForTick;
}
yield return WaitForConditionOrTimeOut(CheckClientsSideObserverTestObj);
AssertOnTimeout($"{(withoutObservers ? k_WithoutObserversError : k_WithObserversError)} {k_ObserverTestObjName} object!");
// If we spawned without observers
if (withoutObservers)
{
// Make each client an observer
foreach (var client in m_ClientNetworkManagers)
{
m_ObserverTestNetworkObject.NetworkShow(client.LocalClientId);
}
// Validate the clients spawned the NetworkObject
m_ObserverTestType = ObserverTestTypes.WithObservers;
yield return WaitForConditionOrTimeOut(CheckClientsSideObserverTestObj);
AssertOnTimeout($"{k_WithObserversError} {k_ObserverTestObjName} object!");
}
}
/// <summary>
/// Tests that instantiating a <see cref="NetworkObject"/> and destroying without spawning it
/// does not run <see cref="NetworkBehaviour.OnNetworkSpawn"/> or <see cref="NetworkBehaviour.OnNetworkSpawn"/>.
@@ -52,6 +132,11 @@ namespace Unity.Netcode.RuntimeTests
protected override IEnumerator OnTearDown()
{
if (m_ObserverPrefab != null)
{
Object.Destroy(m_ObserverPrefab);
}
if (m_TestNetworkObjectPrefab != null)
{
Object.Destroy(m_TestNetworkObjectPrefab);

30
Tests/Runtime/NetworkShowHideTests.cs
View File

@@ -286,6 +286,36 @@ namespace Unity.Netcode.RuntimeTests
}
}
[UnityTest]
public IEnumerator ConcurrentShowAndHideOnDifferentObjects()
{
m_ClientId0 = m_ClientNetworkManagers[0].LocalClientId;
ShowHideObject.ClientTargetedNetworkObjects.Clear();
ShowHideObject.ClientIdToTarget = m_ClientId0;
// create 3 objects
var spawnedObject1 = SpawnObject(m_PrefabToSpawn, m_ServerNetworkManager);
var spawnedObject2 = SpawnObject(m_PrefabToSpawn, m_ServerNetworkManager);
var spawnedObject3 = SpawnObject(m_PrefabToSpawn, m_ServerNetworkManager);
m_NetSpawnedObject1 = spawnedObject1.GetComponent<NetworkObject>();
m_NetSpawnedObject2 = spawnedObject2.GetComponent<NetworkObject>();
m_NetSpawnedObject3 = spawnedObject3.GetComponent<NetworkObject>();
// get the NetworkObject on a client instance
yield return WaitForConditionOrTimeOut(RefreshNetworkObjects);
AssertOnTimeout($"Could not refresh all NetworkObjects!");
m_NetSpawnedObject1.NetworkHide(m_ClientId0);
yield return WaitForTicks(m_ServerNetworkManager, 5);
m_NetSpawnedObject1.NetworkShow(m_ClientId0);
m_NetSpawnedObject2.NetworkHide(m_ClientId0);
yield return WaitForTicks(m_ServerNetworkManager, 5);
}
[UnityTest]
public IEnumerator NetworkShowHideQuickTest()
{

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

@@ -37,10 +37,17 @@ namespace Unity.Netcode.RuntimeTests
return ServerAuthority;
}
public static NetworkTransformTestComponent AuthorityInstance;
public override void OnNetworkSpawn()
{
base.OnNetworkSpawn();
if (CanCommitToTransform)
{
AuthorityInstance = this;
}
ReadyToReceivePositionUpdate = true;
}
@@ -59,31 +66,38 @@ namespace Unity.Netcode.RuntimeTests
/// <summary>
/// Helper component for NetworkTransform parenting tests
/// </summary>
public class ChildObjectComponent : NetworkBehaviour
public class ChildObjectComponent : NetworkTransform
{
public static readonly List<ChildObjectComponent> Instances = new List<ChildObjectComponent>();
public static ChildObjectComponent ServerInstance { get; internal set; }
public static ChildObjectComponent AuthorityInstance { get; internal set; }
public static readonly Dictionary<ulong, NetworkObject> ClientInstances = new Dictionary<ulong, NetworkObject>();
public static void Reset()
{
ServerInstance = null;
AuthorityInstance = null;
ClientInstances.Clear();
Instances.Clear();
}
public bool ServerAuthority;
protected override bool OnIsServerAuthoritative()
{
return ServerAuthority;
}
public override void OnNetworkSpawn()
{
if (IsServer)
base.OnNetworkSpawn();
if (CanCommitToTransform)
{
ServerInstance = this;
AuthorityInstance = this;
}
else
{
ClientInstances.Add(NetworkManager.LocalClientId, NetworkObject);
Instances.Add(this);
}
Instances.Add(this);
base.OnNetworkSpawn();
ClientInstances.Add(NetworkManager.LocalClientId, NetworkObject);
}
}
@@ -101,7 +115,8 @@ namespace Unity.Netcode.RuntimeTests
{
private NetworkObject m_AuthoritativePlayer;
private NetworkObject m_NonAuthoritativePlayer;
private NetworkObject m_ChildObjectToBeParented;
private NetworkObject m_ChildObject;
private NetworkObject m_ParentObject;
private NetworkTransformTestComponent m_AuthoritativeTransform;
private NetworkTransformTestComponent m_NonAuthoritativeTransform;
@@ -133,6 +148,13 @@ namespace Unity.Netcode.RuntimeTests
Quaternion
}
public enum RotationCompression
{
None,
QuaternionCompress
}
public enum TransformSpace
{
World,
@@ -190,6 +212,7 @@ namespace Unity.Netcode.RuntimeTests
protected override void OnInlineSetup()
{
NetworkTransformTestComponent.AuthorityInstance = null;
m_Precision = Precision.Full;
ChildObjectComponent.Reset();
}
@@ -209,17 +232,22 @@ namespace Unity.Netcode.RuntimeTests
protected override void OnServerAndClientsCreated()
{
var childObject = CreateNetworkObjectPrefab("ChildObject");
childObject.AddComponent<ChildObjectComponent>();
var childNetworkTransform = childObject.AddComponent<NetworkTransform>();
childNetworkTransform.InLocalSpace = true;
m_ChildObjectToBeParented = childObject.GetComponent<NetworkObject>();
var childNetworkTransform = childObject.AddComponent<ChildObjectComponent>();
childNetworkTransform.ServerAuthority = m_Authority == Authority.ServerAuthority;
m_ChildObject = childObject.GetComponent<NetworkObject>();
var parentObject = CreateNetworkObjectPrefab("ParentObject");
var parentNetworkTransform = parentObject.AddComponent<NetworkTransformTestComponent>();
parentNetworkTransform.ServerAuthority = m_Authority == Authority.ServerAuthority;
m_ParentObject = parentObject.GetComponent<NetworkObject>();
// Now apply local transform values
m_ChildObjectToBeParented.transform.position = m_ChildObjectLocalPosition;
var childRotation = m_ChildObjectToBeParented.transform.rotation;
m_ChildObject.transform.position = m_ChildObjectLocalPosition;
var childRotation = m_ChildObject.transform.rotation;
childRotation.eulerAngles = m_ChildObjectLocalRotation;
m_ChildObjectToBeParented.transform.rotation = childRotation;
m_ChildObjectToBeParented.transform.localScale = m_ChildObjectLocalScale;
m_ChildObject.transform.rotation = childRotation;
m_ChildObject.transform.localScale = m_ChildObjectLocalScale;
if (m_EnableVerboseDebug)
{
m_ServerNetworkManager.LogLevel = LogLevel.Developer;
@@ -268,7 +296,7 @@ namespace Unity.Netcode.RuntimeTests
/// <returns></returns>
private bool AllChildObjectInstancesAreSpawned()
{
if (ChildObjectComponent.ServerInstance == null)
if (ChildObjectComponent.AuthorityInstance == null)
{
return false;
}
@@ -306,21 +334,34 @@ namespace Unity.Netcode.RuntimeTests
/// </summary>
private bool AllInstancesKeptLocalTransformValues()
{
var authorityObjectLocalPosition = m_AuthorityChildObject.transform.localPosition;
var authorityObjectLocalRotation = m_AuthorityChildObject.transform.localRotation.eulerAngles;
var authorityObjectLocalScale = m_AuthorityChildObject.transform.localScale;
foreach (var childInstance in ChildObjectComponent.Instances)
{
var childLocalPosition = childInstance.transform.localPosition;
var childLocalRotation = childInstance.transform.localRotation.eulerAngles;
var childLocalScale = childInstance.transform.localScale;
if (!Approximately(childLocalPosition, m_ChildObjectLocalPosition))
// Adjust approximation based on precision
if (m_Precision == Precision.Half)
{
m_CurrentHalfPrecision = k_HalfPrecisionPosScale;
}
if (!Approximately(childLocalPosition, authorityObjectLocalPosition))
{
return false;
}
if (!ApproximatelyEuler(childLocalRotation, m_ChildObjectLocalRotation))
if (!Approximately(childLocalScale, authorityObjectLocalScale))
{
return false;
}
if (!Approximately(childLocalScale, m_ChildObjectLocalScale))
// Adjust approximation based on precision
if (m_Precision == Precision.Half)
{
m_CurrentHalfPrecision = k_HalfPrecisionRot;
}
if (!ApproximatelyEuler(childLocalRotation, authorityObjectLocalRotation))
{
return false;
}
@@ -333,68 +374,133 @@ namespace Unity.Netcode.RuntimeTests
/// If not, it generates a message containing the axial values that did not match
/// the target/start local space values.
/// </summary>
private void WaitForAllChildrenLocalTransformValuesToMatch()
private void AllChildrenLocalTransformValuesMatch()
{
var success = WaitForConditionOrTimeOutWithTimeTravel(AllInstancesKeptLocalTransformValues);
var infoMessage = string.Empty;
if (s_GlobalTimeoutHelper.TimedOut)
//TimeTravelToNextTick();
var infoMessage = new System.Text.StringBuilder($"Timed out waiting for all children to have the correct local space values:\n");
var authorityObjectLocalPosition = m_AuthorityChildObject.transform.localPosition;
var authorityObjectLocalRotation = m_AuthorityChildObject.transform.localRotation.eulerAngles;
var authorityObjectLocalScale = m_AuthorityChildObject.transform.localScale;
if (s_GlobalTimeoutHelper.TimedOut || !success)
{
foreach (var childInstance in ChildObjectComponent.Instances)
{
var childLocalPosition = childInstance.transform.localPosition;
var childLocalRotation = childInstance.transform.localRotation.eulerAngles;
var childLocalScale = childInstance.transform.localScale;
// Adjust approximation based on precision
if (m_Precision == Precision.Half)
{
m_CurrentHalfPrecision = k_HalfPrecisionPosScale;
}
if (!Approximately(childLocalPosition, authorityObjectLocalPosition))
{
infoMessage.AppendLine($"[{childInstance.name}] Child's Local Position ({childLocalPosition}) | Authority Local Position ({authorityObjectLocalPosition})");
success = false;
}
if (!Approximately(childLocalScale, authorityObjectLocalScale))
{
infoMessage.AppendLine($"[{childInstance.name}] Child's Local Scale ({childLocalScale}) | Authority Local Scale ({authorityObjectLocalScale})");
success = false;
}
if (!Approximately(childLocalPosition, m_ChildObjectLocalPosition))
// Adjust approximation based on precision
if (m_Precision == Precision.Half)
{
infoMessage += $"[{childInstance.name}] Child's Local Position ({childLocalPosition}) | Original Local Position ({m_ChildObjectLocalPosition})\n";
m_CurrentHalfPrecision = k_HalfPrecisionRot;
}
if (!ApproximatelyEuler(childLocalRotation, m_ChildObjectLocalRotation))
if (!ApproximatelyEuler(childLocalRotation, authorityObjectLocalRotation))
{
infoMessage += $"[{childInstance.name}] Child's Local Rotation ({childLocalRotation}) | Original Local Rotation ({m_ChildObjectLocalRotation})\n";
}
if (!Approximately(childLocalScale, m_ChildObjectLocalScale))
{
infoMessage += $"[{childInstance.name}] Child's Local Scale ({childLocalScale}) | Original Local Rotation ({m_ChildObjectLocalScale})\n";
infoMessage.AppendLine($"[{childInstance.name}] Child's Local Rotation ({childLocalRotation}) | Authority Local Rotation ({authorityObjectLocalRotation})");
success = false;
}
}
Assert.True(success, $"Timed out waiting for all children to have the correct local space values:\n {infoMessage}");
if (!success)
{
Assert.True(success, infoMessage.ToString());
}
}
}
private NetworkObject m_AuthorityParentObject;
private NetworkTransformTestComponent m_AuthorityParentNetworkTransform;
private NetworkObject m_AuthorityChildObject;
private ChildObjectComponent m_AuthorityChildNetworkTransform;
/// <summary>
/// Validates that local space transform values remain the same when a NetworkTransform is
/// parented under another NetworkTransform
/// Validates that transform values remain the same when a NetworkTransform is
/// parented under another NetworkTransform under all of the possible axial conditions
/// as well as when the parent has a varying scale.
/// </summary>
[Test]
public void NetworkTransformParentedLocalSpaceTest([Values] Interpolation interpolation)
public void ParentedNetworkTransformTest([Values] Precision precision, [Values] Rotation rotation,
[Values] RotationCompression rotationCompression, [Values] Interpolation interpolation, [Values] bool worldPositionStays,
[Values(0.5f, 1.0f, 5.0f)] float scale)
{
m_AuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
m_NonAuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
var authoritativeChildObject = SpawnObject(m_ChildObjectToBeParented.gameObject, m_AuthoritativeTransform.NetworkManager);
// Set the precision being used for threshold adjustments
m_Precision = precision;
// Assure all of the child object instances are spawned
// Get the NetworkManager that will have authority in order to spawn with the correct authority
var isServerAuthority = m_Authority == Authority.ServerAuthority;
var authorityNetworkManager = m_ServerNetworkManager;
if (!isServerAuthority)
{
authorityNetworkManager = m_ClientNetworkManagers[0];
}
// Spawn a parent and child object
var serverSideParent = SpawnObject(m_ParentObject.gameObject, authorityNetworkManager).GetComponent<NetworkObject>();
var serverSideChild = SpawnObject(m_ChildObject.gameObject, authorityNetworkManager).GetComponent<NetworkObject>();
// Assure all of the child object instances are spawned before proceeding to parenting
var success = WaitForConditionOrTimeOutWithTimeTravel(AllChildObjectInstancesAreSpawned);
Assert.True(success, "Timed out waiting for all child instances to be spawned!");
// Just a sanity check as it should have timed out before this check
Assert.IsNotNull(ChildObjectComponent.ServerInstance, $"The server-side {nameof(ChildObjectComponent)} instance is null!");
// This determines which parent on the server side should be the parent
if (m_AuthoritativeTransform.IsServerAuthoritative())
{
Assert.True(ChildObjectComponent.ServerInstance.NetworkObject.TrySetParent(m_AuthoritativeTransform.transform, false), "[Authoritative] Failed to parent the child object!");
}
else
{
Assert.True(ChildObjectComponent.ServerInstance.NetworkObject.TrySetParent(m_NonAuthoritativeTransform.transform, false), "[Non-Authoritative] Failed to parent the child object!");
}
// Get the authority parent and child instances
m_AuthorityParentObject = NetworkTransformTestComponent.AuthorityInstance.NetworkObject;
m_AuthorityChildObject = ChildObjectComponent.AuthorityInstance.NetworkObject;
// The child NetworkTransform will use world space when world position stays and
// local space when world position does not stay when parenting.
ChildObjectComponent.AuthorityInstance.InLocalSpace = !worldPositionStays;
ChildObjectComponent.AuthorityInstance.UseHalfFloatPrecision = precision == Precision.Half;
ChildObjectComponent.AuthorityInstance.UseQuaternionSynchronization = rotation == Rotation.Quaternion;
ChildObjectComponent.AuthorityInstance.UseQuaternionCompression = rotationCompression == RotationCompression.QuaternionCompress;
// Set whether we are interpolating or not
m_AuthorityParentNetworkTransform = m_AuthorityParentObject.GetComponent<NetworkTransformTestComponent>();
m_AuthorityParentNetworkTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
m_AuthorityChildNetworkTransform = m_AuthorityChildObject.GetComponent<ChildObjectComponent>();
m_AuthorityChildNetworkTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
// Apply a scale to the parent object to make sure the scale on the child is properly updated on
// non-authority instances.
m_AuthorityParentObject.transform.localScale = new Vector3(scale, scale, scale);
// Allow one tick for authority to update these changes
TimeTravelToNextTick();
// Parent the child under the parent with the current world position stays setting
Assert.True(serverSideChild.TrySetParent(serverSideParent.transform, worldPositionStays), "[Server-Side Child] Failed to set child's parent!");
// This waits for all child instances to be parented
success = WaitForConditionOrTimeOutWithTimeTravel(AllChildObjectInstancesHaveChild);
Assert.True(success, "Timed out waiting for all instances to have parented a child!");
// This validates each child instance has preserved their local space values
WaitForAllChildrenLocalTransformValuesToMatch();
AllChildrenLocalTransformValuesMatch();
// Verify that a late joining client will synchronize to the parented NetworkObjects properly
CreateAndStartNewClientWithTimeTravel();
// Assure all of the child object instances are spawned (basically for the newly connected client)
success = WaitForConditionOrTimeOutWithTimeTravel(AllChildObjectInstancesAreSpawned);
Assert.True(success, "Timed out waiting for all child instances to be spawned!");
// Assure the newly connected client's child object's transform values are correct
AllChildrenLocalTransformValuesMatch();
}
/// <summary>

1275
Tests/Runtime/NetworkVariableTests.cs
View File

File diff suppressed because it is too large Load Diff

8
Tests/Runtime/NetworkVariableUserSerializableTypesTests.cs
View File

@@ -143,6 +143,10 @@ namespace Unity.Netcode.RuntimeTests
value = new MyTypeOne();
reader.ReadValueSafe(out value.Value);
};
UserNetworkVariableSerialization<MyTypeOne>.DuplicateValue = (in MyTypeOne value, ref MyTypeOne duplicatedValue) =>
{
duplicatedValue = value;
};
var serverObject = SpawnObject(m_WorkingPrefab, m_ServerNetworkManager);
var serverNetworkObject = serverObject.GetComponent<NetworkObject>();
@@ -172,6 +176,10 @@ namespace Unity.Netcode.RuntimeTests
{
UserNetworkVariableSerialization<MyTypeTwo>.WriteValue = NetworkVariableUserSerializableTypesTestsExtensionMethods.WriteValueSafe;
UserNetworkVariableSerialization<MyTypeTwo>.ReadValue = NetworkVariableUserSerializableTypesTestsExtensionMethods.ReadValueSafe;
UserNetworkVariableSerialization<MyTypeTwo>.DuplicateValue = (in MyTypeTwo value, ref MyTypeTwo duplicatedValue) =>
{
duplicatedValue = value;
};
var serverObject = SpawnObject(m_ExtensionMethodPrefab, m_ServerNetworkManager);
var serverNetworkObject = serverObject.GetComponent<NetworkObject>();

63
Tests/Runtime/RpcTests.cs
View File

@@ -4,9 +4,9 @@ using System.Collections.Generic;
using NUnit.Framework;
using Unity.Collections;
using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine;
using UnityEngine.TestTools;
using Debug = UnityEngine.Debug;
using Vector3 = UnityEngine.Vector3;
namespace Unity.Netcode.RuntimeTests
{
@@ -15,7 +15,15 @@ namespace Unity.Netcode.RuntimeTests
public class RpcTestNB : NetworkBehaviour
{
public event Action<ulong, ServerRpcParams> OnServer_Rpc;
public event Action<Vector3, Vector3[], FixedString32Bytes> OnTypedServer_Rpc;
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
public event Action<NativeList<ulong>, ServerRpcParams> OnNativeListServer_Rpc;
#endif
public event Action<Vector3, Vector3[],
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
NativeList<Vector3>,
#endif
FixedString32Bytes> OnTypedServer_Rpc;
public event Action OnClient_Rpc;
[ServerRpc]
@@ -24,6 +32,15 @@ namespace Unity.Netcode.RuntimeTests
OnServer_Rpc(clientId, param);
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
[ServerRpc]
public void MyNativeListServerRpc(NativeList<ulong> clientId, ServerRpcParams param = default)
{
OnNativeListServer_Rpc(clientId, param);
}
#endif
[ClientRpc]
public void MyClientRpc()
{
@@ -31,9 +48,17 @@ namespace Unity.Netcode.RuntimeTests
}
[ServerRpc]
public void MyTypedServerRpc(Vector3 param1, Vector3[] param2, FixedString32Bytes param3)
public void MyTypedServerRpc(Vector3 param1, Vector3[] param2,
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
NativeList<Vector3> param3,
#endif
FixedString32Bytes param4)
{
OnTypedServer_Rpc(param1, param2, param3);
OnTypedServer_Rpc(param1, param2,
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
param3,
#endif
param4);
}
}
@@ -61,6 +86,13 @@ namespace Unity.Netcode.RuntimeTests
var vector3 = new Vector3(1, 2, 3);
Vector3[] vector3s = new[] { new Vector3(4, 5, 6), new Vector3(7, 8, 9) };
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
using var vector3sNativeList = new NativeList<Vector3>(Allocator.Persistent)
{
new Vector3(10, 11, 12),
new Vector3(13, 14, 15)
};
#endif
localClienRpcTestNB.OnClient_Rpc += () =>
{
@@ -90,14 +122,24 @@ namespace Unity.Netcode.RuntimeTests
var str = new FixedString32Bytes("abcdefg");
serverClientRpcTestNB.OnTypedServer_Rpc += (param1, param2, param3) =>
serverClientRpcTestNB.OnTypedServer_Rpc += (param1, param2,
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
param3,
#endif
param4) =>
{
Debug.Log("TypedServerRpc received on server object");
Assert.AreEqual(param1, vector3);
Assert.AreEqual(param2.Length, vector3s.Length);
Assert.AreEqual(param2[0], vector3s[0]);
Assert.AreEqual(param2[1], vector3s[1]);
Assert.AreEqual(param3, str);
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
Assert.AreEqual(param3.Length, vector3s.Length);
Assert.AreEqual(param3[0], vector3sNativeList[0]);
Assert.AreEqual(param3[1], vector3sNativeList[1]);
#endif
Assert.AreEqual(param4, str);
hasReceivedTypedServerRpc = true;
};
@@ -105,12 +147,16 @@ namespace Unity.Netcode.RuntimeTests
localClienRpcTestNB.MyServerRpc(m_ClientNetworkManagers[0].LocalClientId);
// Send TypedServerRpc
localClienRpcTestNB.MyTypedServerRpc(vector3, vector3s, str);
localClienRpcTestNB.MyTypedServerRpc(vector3, vector3s,
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
vector3sNativeList,
#endif
str);
// Send ClientRpc
serverClientRpcTestNB.MyClientRpc();
// Validate each NetworkManager relative MessagingSystem received each respective RPC
// Validate each NetworkManager relative NetworkMessageManager received each respective RPC
var messageHookList = new List<MessageHookEntry>();
var serverMessageHookEntry = new MessageHookEntry(m_ServerNetworkManager);
serverMessageHookEntry.AssignMessageType<ServerRpcMessage>();
@@ -126,6 +172,7 @@ namespace Unity.Netcode.RuntimeTests
clientMessageHookEntry.AssignMessageType<ClientRpcMessage>();
messageHookList.Add(clientMessageHookEntry);
}
var rpcMessageHooks = new MessageHooksConditional(messageHookList);
yield return WaitForConditionOrTimeOut(rpcMessageHooks);
Assert.False(s_GlobalTimeoutHelper.TimedOut, $"Timed out waiting for messages: {rpcMessageHooks.GetHooksStillWaiting()}");

1987
Tests/Runtime/RpcTypeSerializationTests.cs Normal file
View File

File diff suppressed because it is too large Load Diff

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

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: fd1b9e10285844d48c86d1930652d22c
timeCreated: 1672959718

4
Tests/Runtime/TestHelpers/MessageCatcher.cs
View File

@@ -16,7 +16,7 @@ namespace Unity.Netcode.RuntimeTests
private struct TriggerData
{
public FastBufferReader Reader;
public MessageHeader Header;
public NetworkMessageHeader Header;
public ulong SenderId;
public float Timestamp;
public int SerializedHeaderSize;
@@ -29,7 +29,7 @@ namespace Unity.Netcode.RuntimeTests
foreach (var caughtSpawn in m_CaughtMessages)
{
// Reader will be disposed within HandleMessage
m_OwnerNetworkManager.MessagingSystem.HandleMessage(caughtSpawn.Header, caughtSpawn.Reader, caughtSpawn.SenderId, caughtSpawn.Timestamp, caughtSpawn.SerializedHeaderSize);
m_OwnerNetworkManager.ConnectionManager.MessageManager.HandleMessage(caughtSpawn.Header, caughtSpawn.Reader, caughtSpawn.SenderId, caughtSpawn.Timestamp, caughtSpawn.SerializedHeaderSize);
}
}

16
Tests/Runtime/Transports/UnityTransportConnectionTests.cs
View File

@@ -45,6 +45,22 @@ namespace Unity.Netcode.RuntimeTests
yield return null;
}
// Check that invalid endpoint addresses are detected and return false if detected
[Test]
public void DetectInvalidEndpoint()
{
using var netcodeLogAssert = new NetcodeLogAssert(true);
InitializeTransport(out m_Server, out m_ServerEvents);
InitializeTransport(out m_Clients[0], out m_ClientsEvents[0]);
m_Server.ConnectionData.Address = "Fubar";
m_Server.ConnectionData.ServerListenAddress = "Fubar";
m_Clients[0].ConnectionData.Address = "MoreFubar";
Assert.False(m_Server.StartServer(), "Server failed to detect invalid endpoint!");
Assert.False(m_Clients[0].StartClient(), "Client failed to detect invalid endpoint!");
netcodeLogAssert.LogWasReceived(LogType.Error, $"Network listen address ({m_Server.ConnectionData.Address}) is Invalid!");
netcodeLogAssert.LogWasReceived(LogType.Error, $"Target server network address ({m_Clients[0].ConnectionData.Address}) is Invalid!");
}
// Check connection with a single client.
[UnityTest]
public IEnumerator ConnectSingleClient()