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)