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)
{