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.2.0

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.2.0] - 2022-11-21

### Added

- Added protected method `NetworkBehaviour.OnSynchronize` which is invoked during the initial `NetworkObject` synchronization process. This provides users the ability to include custom serialization information that will be applied to the `NetworkBehaviour` prior to the `NetworkObject` being spawned. (#2298)
- Added support for different versions of the SDK to talk to each other in circumstances where changes permit it. Starting with this version and into future versions, patch versions should be compatible as long as the minor version is the same. (#2290)
- Added `NetworkObject` auto-add helper and Multiplayer Tools install reminder settings to Project Settings. (#2285)
- Added `public string DisconnectReason` getter to `NetworkManager` and `string Reason` to `ConnectionApprovalResponse`. Allows connection approval to communicate back a reason. Also added `public void DisconnectClient(ulong clientId, string reason)` allowing setting a disconnection reason, when explicitly disconnecting a client. (#2280)

### Changed

- Changed 3rd-party `XXHash` (32 & 64) implementation with an in-house reimplementation (#2310)
- When `NetworkConfig.EnsureNetworkVariableLengthSafety` is disabled `NetworkVariable` fields do not write the additional `ushort` size value (_which helps to reduce the total synchronization message size_), but when enabled it still writes the additional `ushort` value. (#2298)
- Optimized bandwidth usage by encoding most integer fields using variable-length encoding. (#2276)

### Fixed

- Fixed issue where `NetworkTransform` components nested under a parent with a `NetworkObject` component  (i.e. network prefab) would not have their associated `GameObject`'s transform synchronized. (#2298)
- Fixed issue where `NetworkObject`s that failed to instantiate could cause the entire synchronization pipeline to be disrupted/halted for a connecting client. (#2298)
- Fixed issue where in-scene placed `NetworkObject`s nested under a `GameObject` would be added to the orphaned children list causing continual console warning log messages. (#2298)
- Custom messages are now properly received by the local client when they're sent while running in host mode. (#2296)
- Fixed issue where the host would receive more than one event completed notification when loading or unloading a scene only when no clients were connected. (#2292)
- Fixed an issue in `UnityTransport` where an error would be logged if the 'Use Encryption' flag was enabled with a Relay configuration that used a secure protocol. (#2289)
- Fixed issue where in-scene placed `NetworkObjects` were not honoring the `AutoObjectParentSync` property. (#2281)
- Fixed the issue where `NetworkManager.OnClientConnectedCallback` was being invoked before in-scene placed `NetworkObject`s had been spawned when starting `NetworkManager` as a host. (#2277)
- Creating a `FastBufferReader` with `Allocator.None` will not result in extra memory being allocated for the buffer (since it's owned externally in that scenario). (#2265)

### Removed

- Removed the `NetworkObject` auto-add and Multiplayer Tools install reminder settings from the Menu interface. (#2285)
This commit is contained in:
Unity Technologies
2022-11-21 00:00:00 +00:00
parent 1e7078c160
commit fe02ca682e
96 changed files with 4522 additions and 2088 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

56
Tests/Editor/DisconnectMessageTests.cs Normal file
View File

@@ -0,0 +1,56 @@
using NUnit.Framework;
using Unity.Collections;
namespace Unity.Netcode.EditorTests
{
public class DisconnectMessageTests
{
[Test]
public void EmptyDisconnectReason()
{
var networkContext = new NetworkContext();
var writer = new FastBufferWriter(20, Allocator.Temp, 20);
var msg = new DisconnectReasonMessage();
msg.Reason = string.Empty;
msg.Serialize(writer, msg.Version);
var fbr = new FastBufferReader(writer, Allocator.Temp);
var recvMsg = new DisconnectReasonMessage();
recvMsg.Deserialize(fbr, ref networkContext, msg.Version);
Assert.IsEmpty(recvMsg.Reason);
}
[Test]
public void DisconnectReason()
{
var networkContext = new NetworkContext();
var writer = new FastBufferWriter(20, Allocator.Temp, 20);
var msg = new DisconnectReasonMessage();
msg.Reason = "Foo";
msg.Serialize(writer, msg.Version);
var fbr = new FastBufferReader(writer, Allocator.Temp);
var recvMsg = new DisconnectReasonMessage();
recvMsg.Deserialize(fbr, ref networkContext, msg.Version);
Assert.AreEqual("Foo", recvMsg.Reason);
}
[Test]
public void DisconnectReasonTooLong()
{
var networkContext = new NetworkContext();
var writer = new FastBufferWriter(20, Allocator.Temp, 20);
var msg = new DisconnectReasonMessage();
msg.Reason = "ThisStringIsWayLongerThanTwentyBytes";
msg.Serialize(writer, msg.Version);
var fbr = new FastBufferReader(writer, Allocator.Temp);
var recvMsg = new DisconnectReasonMessage();
recvMsg.Deserialize(fbr, ref networkContext, msg.Version);
Assert.IsEmpty(recvMsg.Reason);
}
}
}

11
Tests/Editor/DisconnectMessageTests.cs.meta Normal file
View File

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

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

@@ -18,12 +18,12 @@ namespace Unity.Netcode.EditorTests
public static bool Handled;
public static List<TestMessage> DeserializedValues = new List<TestMessage>();
public void Serialize(FastBufferWriter writer)
public void Serialize(FastBufferWriter writer, int targetVersion)
{
writer.WriteValueSafe(this);
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
Deserialized = true;
reader.ReadValueSafe(out this);
@@ -35,6 +35,8 @@ namespace Unity.Netcode.EditorTests
Handled = true;
DeserializedValues.Add(this);
}
public int Version => 0;
}
private class TestMessageProvider : IMessageProvider
@@ -46,7 +48,8 @@ namespace Unity.Netcode.EditorTests
new MessagingSystem.MessageWithHandler
{
MessageType = typeof(TestMessage),
Handler = MessagingSystem.ReceiveMessage<TestMessage>
Handler = MessagingSystem.ReceiveMessage<TestMessage>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessage>
}
};
}
@@ -62,6 +65,7 @@ namespace Unity.Netcode.EditorTests
TestMessage.DeserializedValues.Clear();
m_MessagingSystem = new MessagingSystem(new NopMessageSender(), this, new TestMessageProvider());
m_MessagingSystem.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
}
[TearDown]

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

@@ -1,4 +1,3 @@
using System;
using System.Collections.Generic;
using NUnit.Framework;
@@ -11,12 +10,12 @@ namespace Unity.Netcode.EditorTests
public int A;
public int B;
public int C;
public void Serialize(FastBufferWriter writer)
public void Serialize(FastBufferWriter writer, int targetVersion)
{
writer.WriteValue(this);
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
return true;
}
@@ -24,6 +23,8 @@ namespace Unity.Netcode.EditorTests
public void Handle(ref NetworkContext context)
{
}
public int Version => 0;
}
private struct TestMessageTwo : INetworkMessage, INetworkSerializeByMemcpy
@@ -31,12 +32,12 @@ namespace Unity.Netcode.EditorTests
public int A;
public int B;
public int C;
public void Serialize(FastBufferWriter writer)
public void Serialize(FastBufferWriter writer, int targetVersion)
{
writer.WriteValue(this);
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
return true;
}
@@ -44,6 +45,8 @@ namespace Unity.Netcode.EditorTests
public void Handle(ref NetworkContext context)
{
}
public int Version => 0;
}
private class TestMessageProviderOne : IMessageProvider
{
@@ -54,12 +57,14 @@ namespace Unity.Netcode.EditorTests
new MessagingSystem.MessageWithHandler
{
MessageType = typeof(TestMessageOne),
Handler = MessagingSystem.ReceiveMessage<TestMessageOne>
Handler = MessagingSystem.ReceiveMessage<TestMessageOne>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessageOne>
},
new MessagingSystem.MessageWithHandler
{
MessageType = typeof(TestMessageTwo),
Handler = MessagingSystem.ReceiveMessage<TestMessageTwo>
Handler = MessagingSystem.ReceiveMessage<TestMessageTwo>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessageTwo>
}
};
}
@@ -70,12 +75,12 @@ namespace Unity.Netcode.EditorTests
public int A;
public int B;
public int C;
public void Serialize(FastBufferWriter writer)
public void Serialize(FastBufferWriter writer, int targetVersion)
{
writer.WriteValue(this);
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
return true;
}
@@ -83,6 +88,8 @@ namespace Unity.Netcode.EditorTests
public void Handle(ref NetworkContext context)
{
}
public int Version => 0;
}
private class TestMessageProviderTwo : IMessageProvider
{
@@ -93,7 +100,8 @@ namespace Unity.Netcode.EditorTests
new MessagingSystem.MessageWithHandler
{
MessageType = typeof(TestMessageThree),
Handler = MessagingSystem.ReceiveMessage<TestMessageThree>
Handler = MessagingSystem.ReceiveMessage<TestMessageThree>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessageThree>
}
};
}
@@ -103,12 +111,12 @@ namespace Unity.Netcode.EditorTests
public int A;
public int B;
public int C;
public void Serialize(FastBufferWriter writer)
public void Serialize(FastBufferWriter writer, int targetVersion)
{
writer.WriteValue(this);
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
return true;
}
@@ -116,6 +124,8 @@ namespace Unity.Netcode.EditorTests
public void Handle(ref NetworkContext context)
{
}
public int Version => 0;
}
private class TestMessageProviderThree : IMessageProvider
{
@@ -126,7 +136,8 @@ namespace Unity.Netcode.EditorTests
new MessagingSystem.MessageWithHandler
{
MessageType = typeof(TestMessageFour),
Handler = MessagingSystem.ReceiveMessage<TestMessageFour>
Handler = MessagingSystem.ReceiveMessage<TestMessageFour>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessageFour>
}
};
}
@@ -183,11 +194,11 @@ namespace Unity.Netcode.EditorTests
internal class AAAEarlyLexicographicNetworkMessage : INetworkMessage
{
public void Serialize(FastBufferWriter writer)
public void Serialize(FastBufferWriter writer, int targetVersion)
{
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
return true;
}
@@ -195,6 +206,8 @@ namespace Unity.Netcode.EditorTests
public void Handle(ref NetworkContext context)
{
}
public int Version => 0;
}
#pragma warning disable IDE1006
@@ -212,18 +225,19 @@ namespace Unity.Netcode.EditorTests
var messageWithHandler = new MessagingSystem.MessageWithHandler();
messageWithHandler.MessageType = typeof(zzzLateLexicographicNetworkMessage);
messageWithHandler.GetVersion = MessagingSystem.CreateMessageAndGetVersion<zzzLateLexicographicNetworkMessage>;
listMessages.Add(messageWithHandler);
messageWithHandler.MessageType = typeof(ConnectionRequestMessage);
messageWithHandler.GetVersion = MessagingSystem.CreateMessageAndGetVersion<ConnectionRequestMessage>;
listMessages.Add(messageWithHandler);
messageWithHandler.MessageType = typeof(ConnectionApprovedMessage);
listMessages.Add(messageWithHandler);
messageWithHandler.MessageType = typeof(OrderingMessage);
messageWithHandler.GetVersion = MessagingSystem.CreateMessageAndGetVersion<ConnectionApprovedMessage>;
listMessages.Add(messageWithHandler);
messageWithHandler.MessageType = typeof(AAAEarlyLexicographicNetworkMessage);
messageWithHandler.GetVersion = MessagingSystem.CreateMessageAndGetVersion<AAAEarlyLexicographicNetworkMessage>;
listMessages.Add(messageWithHandler);
return listMessages;
@@ -237,65 +251,16 @@ namespace Unity.Netcode.EditorTests
var provider = new OrderingMessageProvider();
using var messagingSystem = new MessagingSystem(sender, null, provider);
// the 3 priority messages should appear first, in lexicographic order
// 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(messagingSystem.MessageTypes[2], typeof(OrderingMessage));
// the other should follow after
Assert.AreEqual(messagingSystem.MessageTypes[3], typeof(AAAEarlyLexicographicNetworkMessage));
Assert.AreEqual(messagingSystem.MessageTypes[4], typeof(zzzLateLexicographicNetworkMessage));
Assert.AreEqual(messagingSystem.MessageTypes[2], typeof(AAAEarlyLexicographicNetworkMessage));
Assert.AreEqual(messagingSystem.MessageTypes[3], typeof(zzzLateLexicographicNetworkMessage));
// there should not be any extras
Assert.AreEqual(messagingSystem.MessageHandlerCount, 5);
// reorder the zzz one to position 3
messagingSystem.ReorderMessage(3, XXHash.Hash32(typeof(zzzLateLexicographicNetworkMessage).FullName));
// the 3 priority messages should still appear first, in lexicographic order
Assert.AreEqual(messagingSystem.MessageTypes[0], typeof(ConnectionApprovedMessage));
Assert.AreEqual(messagingSystem.MessageTypes[1], typeof(ConnectionRequestMessage));
Assert.AreEqual(messagingSystem.MessageTypes[2], typeof(OrderingMessage));
// the other should follow after, but reordered
Assert.AreEqual(messagingSystem.MessageTypes[3], typeof(zzzLateLexicographicNetworkMessage));
Assert.AreEqual(messagingSystem.MessageTypes[4], typeof(AAAEarlyLexicographicNetworkMessage));
// there should still not be any extras
Assert.AreEqual(messagingSystem.MessageHandlerCount, 5);
// verify we get an exception when asking for an invalid position
try
{
messagingSystem.ReorderMessage(-1, XXHash.Hash32(typeof(zzzLateLexicographicNetworkMessage).FullName));
Assert.Fail();
}
catch (ArgumentException)
{
}
// reorder the zzz one to position 3, again, to check nothing bad happens
messagingSystem.ReorderMessage(3, XXHash.Hash32(typeof(zzzLateLexicographicNetworkMessage).FullName));
// the two non-priority should not have moved
Assert.AreEqual(messagingSystem.MessageTypes[3], typeof(zzzLateLexicographicNetworkMessage));
Assert.AreEqual(messagingSystem.MessageTypes[4], typeof(AAAEarlyLexicographicNetworkMessage));
// there should still not be any extras
Assert.AreEqual(messagingSystem.MessageHandlerCount, 5);
// 4242 is a random hash that should not match anything
messagingSystem.ReorderMessage(3, 4242);
// that should result in an extra entry
Assert.AreEqual(messagingSystem.MessageHandlerCount, 6);
// with a null handler
Assert.AreEqual(messagingSystem.MessageHandlers[3], null);
// and it should have bumped the previous messages down
Assert.AreEqual(messagingSystem.MessageTypes[4], typeof(zzzLateLexicographicNetworkMessage));
Assert.AreEqual(messagingSystem.MessageTypes[5], typeof(AAAEarlyLexicographicNetworkMessage));
Assert.AreEqual(messagingSystem.MessageHandlerCount, 4);
}
}
}

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

@@ -18,13 +18,13 @@ namespace Unity.Netcode.EditorTests
public int B;
public int C;
public static bool Serialized;
public void Serialize(FastBufferWriter writer)
public void Serialize(FastBufferWriter writer, int targetVersion)
{
Serialized = true;
writer.WriteValueSafe(this);
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
return true;
}
@@ -32,6 +32,8 @@ namespace Unity.Netcode.EditorTests
public void Handle(ref NetworkContext context)
{
}
public int Version => 0;
}
private class TestMessageSender : IMessageSender
@@ -66,7 +68,8 @@ namespace Unity.Netcode.EditorTests
new MessagingSystem.MessageWithHandler
{
MessageType = typeof(TestMessage),
Handler = MessagingSystem.ReceiveMessage<TestMessage>
Handler = MessagingSystem.ReceiveMessage<TestMessage>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessage>
}
};
// Track messages sent
@@ -88,6 +91,7 @@ namespace Unity.Netcode.EditorTests
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);
}
[TearDown]
@@ -256,7 +260,8 @@ namespace Unity.Netcode.EditorTests
new MessagingSystem.MessageWithHandler
{
MessageType = typeof(TestMessage),
Handler = null
Handler = null,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessage>
}
};
}

503
Tests/Editor/Messaging/MessageVersioningTests.cs Normal file
View File

@@ -0,0 +1,503 @@
using System;
using System.Collections.Generic;
using NUnit.Framework;
using NUnit.Framework.Internal;
namespace Unity.Netcode.EditorTests
{
public class MessageVersioningTests
{
public static int SentVersion;
public static int ReceivedVersion;
private const int k_DefaultB = 5;
private const int k_DefaultC = 10;
private const int k_DefaultD = 15;
private const long k_DefaultE = 20;
private struct VersionedTestMessage_v0 : INetworkMessage, INetworkSerializeByMemcpy
{
public int A;
public int B;
public int C;
public static bool Serialized;
public static bool Deserialized;
public static bool Handled;
public static List<VersionedTestMessage_v0> DeserializedValues = new List<VersionedTestMessage_v0>();
public void Serialize(FastBufferWriter writer, int targetVersion)
{
SentVersion = Version;
Serialized = true;
writer.WriteValueSafe(A);
writer.WriteValueSafe(B);
writer.WriteValueSafe(C);
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
ReceivedVersion = Version;
Deserialized = true;
reader.ReadValueSafe(out A);
reader.ReadValueSafe(out B);
reader.ReadValueSafe(out C);
return true;
}
public void Handle(ref NetworkContext context)
{
Handled = true;
DeserializedValues.Add(this);
}
public int Version => 0;
}
private struct VersionedTestMessage_v1 : INetworkMessage, INetworkSerializeByMemcpy
{
public int A;
public int B;
public int C;
public int D;
public static bool Serialized;
public static bool Deserialized;
public static bool Downgraded;
public static bool Upgraded;
public static bool Handled;
public static List<VersionedTestMessage_v1> DeserializedValues = new List<VersionedTestMessage_v1>();
public void Serialize(FastBufferWriter writer, int targetVersion)
{
if (targetVersion < Version)
{
Downgraded = true;
var v0 = new VersionedTestMessage_v0 { A = A, B = B, C = C };
v0.Serialize(writer, targetVersion);
return;
}
SentVersion = Version;
Serialized = true;
writer.WriteValueSafe(C);
writer.WriteValueSafe(D);
writer.WriteValueSafe(A);
writer.WriteValueSafe(B);
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
if (receivedMessageVersion < Version)
{
var v0 = new VersionedTestMessage_v0();
v0.Deserialize(reader, ref context, receivedMessageVersion);
A = v0.A;
B = v0.B;
C = v0.C;
D = k_DefaultD;
Upgraded = true;
return true;
}
ReceivedVersion = Version;
Deserialized = true;
reader.ReadValueSafe(out C);
reader.ReadValueSafe(out D);
reader.ReadValueSafe(out A);
reader.ReadValueSafe(out B);
return true;
}
public void Handle(ref NetworkContext context)
{
Handled = true;
DeserializedValues.Add(this);
}
public int Version => 1;
}
private struct VersionedTestMessage : INetworkMessage, INetworkSerializeByMemcpy
{
public int A;
public float D;
public long E;
public static bool Serialized;
public static bool Deserialized;
public static bool Downgraded;
public static bool Upgraded;
public static bool Handled;
public static List<VersionedTestMessage> DeserializedValues = new List<VersionedTestMessage>();
public void Serialize(FastBufferWriter writer, int targetVersion)
{
if (targetVersion < Version)
{
Downgraded = true;
var v1 = new VersionedTestMessage_v1 { A = A, B = k_DefaultB, C = k_DefaultC, D = (int)D };
v1.Serialize(writer, targetVersion);
return;
}
SentVersion = Version;
Serialized = true;
writer.WriteValueSafe(D);
writer.WriteValueSafe(A);
writer.WriteValueSafe(E);
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
if (receivedMessageVersion < Version)
{
var v1 = new VersionedTestMessage_v1();
v1.Deserialize(reader, ref context, receivedMessageVersion);
A = v1.A;
D = (float)v1.D;
E = k_DefaultE;
Upgraded = true;
return true;
}
ReceivedVersion = Version;
Deserialized = true;
reader.ReadValueSafe(out D);
reader.ReadValueSafe(out A);
reader.ReadValueSafe(out E);
return true;
}
public void Handle(ref NetworkContext context)
{
Handled = true;
DeserializedValues.Add(this);
}
public int Version => 2;
}
private class TestMessageProvider_v0 : IMessageProvider
{
public List<MessagingSystem.MessageWithHandler> GetMessages()
{
return new List<MessagingSystem.MessageWithHandler>
{
new MessagingSystem.MessageWithHandler
{
MessageType = typeof(VersionedTestMessage_v0),
Handler = MessagingSystem.ReceiveMessage<VersionedTestMessage_v0>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<VersionedTestMessage_v0>
}
};
}
}
private class TestMessageProvider_v1 : IMessageProvider
{
public List<MessagingSystem.MessageWithHandler> GetMessages()
{
return new List<MessagingSystem.MessageWithHandler>
{
new MessagingSystem.MessageWithHandler
{
MessageType = typeof(VersionedTestMessage_v1),
Handler = MessagingSystem.ReceiveMessage<VersionedTestMessage_v1>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<VersionedTestMessage_v1>
}
};
}
}
private class TestMessageProvider_v2 : IMessageProvider
{
public List<MessagingSystem.MessageWithHandler> GetMessages()
{
return new List<MessagingSystem.MessageWithHandler>
{
new MessagingSystem.MessageWithHandler
{
MessageType = typeof(VersionedTestMessage),
Handler = MessagingSystem.ReceiveMessage<VersionedTestMessage>,
GetVersion = MessagingSystem.CreateMessageAndGetVersion<VersionedTestMessage>
}
};
}
}
private class TestMessageSender : IMessageSender
{
public List<byte[]> MessageQueue = new List<byte[]>();
public void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData)
{
MessageQueue.Add(batchData.ToArray());
}
}
private MessagingSystem m_MessagingSystem_v0;
private MessagingSystem m_MessagingSystem_v1;
private MessagingSystem m_MessagingSystem_v2;
private TestMessageSender m_MessageSender;
private void CreateFakeClients(MessagingSystem system, uint hash)
{
// Create three fake clients for each messaging system
// client 0 has version 0, client 1 has version 1, and client 2 has version 2
system.ClientConnected(0);
system.ClientConnected(1);
system.ClientConnected(2);
system.SetVersion(0, hash, 0);
system.SetVersion(1, hash, 1);
system.SetVersion(2, hash, 2);
}
[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();
VersionedTestMessage.Serialized = false;
VersionedTestMessage.Deserialized = false;
VersionedTestMessage.Downgraded = false;
VersionedTestMessage.Upgraded = false;
VersionedTestMessage.Handled = false;
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());
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));
// 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)));
Assert.AreEqual(
m_MessagingSystem_v0.GetMessageType(typeof(VersionedTestMessage_v0)),
m_MessagingSystem_v2.GetMessageType(typeof(VersionedTestMessage)));
}
[TearDown]
public void TearDown()
{
m_MessagingSystem_v0.Dispose();
m_MessagingSystem_v1.Dispose();
m_MessagingSystem_v2.Dispose();
}
private VersionedTestMessage_v0 GetMessage_v0()
{
var random = new Random();
return new VersionedTestMessage_v0
{
A = random.Next(),
B = random.Next(),
C = random.Next(),
};
}
private VersionedTestMessage_v1 GetMessage_v1()
{
var random = new Random();
return new VersionedTestMessage_v1
{
A = random.Next(),
B = random.Next(),
C = random.Next(),
D = random.Next(),
};
}
private VersionedTestMessage GetMessage_v2()
{
var random = new Random();
return new VersionedTestMessage
{
A = random.Next(),
D = (float)(random.NextDouble() * 10000),
E = ((long)random.Next() << 32) + random.Next()
};
}
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) == 2, VersionedTestMessage.Serialized);
Assert.AreEqual(sourceLocalVersion >= 1 && remoteVersion < 1, VersionedTestMessage_v1.Downgraded);
Assert.AreEqual(sourceLocalVersion >= 2 && remoteVersion < 2, VersionedTestMessage.Downgraded);
Assert.AreEqual(1, m_MessageSender.MessageQueue.Count);
Assert.AreEqual(Math.Min(sourceLocalVersion, remoteVersion), SentVersion);
}
public void CheckPostReceiveExpectations(int sourceLocalVersion, int remoteVersion)
{
Assert.AreEqual(SentVersion == 0, VersionedTestMessage_v0.Deserialized);
Assert.AreEqual(SentVersion == 1, VersionedTestMessage_v1.Deserialized);
Assert.AreEqual(SentVersion == 2, VersionedTestMessage.Deserialized);
Assert.AreEqual(remoteVersion >= 1 && sourceLocalVersion < 1, VersionedTestMessage_v1.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 == 2 ? 1 : 0), VersionedTestMessage.DeserializedValues.Count);
Assert.AreEqual(SentVersion, ReceivedVersion);
}
private void SendMessageWithVersions<T>(T message, int fromVersion, int toVersion) where T : unmanaged, INetworkMessage
{
MessagingSystem sendSystem;
switch (fromVersion)
{
case 0: sendSystem = m_MessagingSystem_v0; break;
case 1: sendSystem = m_MessagingSystem_v1; break;
default: sendSystem = m_MessagingSystem_v2; break;
}
sendSystem.SendMessage(ref message, NetworkDelivery.Reliable, (ulong)toVersion);
sendSystem.ProcessSendQueues();
CheckPostSendExpectations(fromVersion, toVersion);
MessagingSystem receiveSystem;
switch (toVersion)
{
case 0: receiveSystem = m_MessagingSystem_v0; break;
case 1: receiveSystem = m_MessagingSystem_v1; break;
default: receiveSystem = m_MessagingSystem_v2; break;
}
receiveSystem.HandleIncomingData((ulong)fromVersion, new ArraySegment<byte>(m_MessageSender.MessageQueue[0]), 0.0f);
receiveSystem.ProcessIncomingMessageQueue();
CheckPostReceiveExpectations(fromVersion, toVersion);
m_MessageSender.MessageQueue.Clear();
}
[Test]
public void WhenSendingV0ToV0_DataIsReceivedCorrectly()
{
var message = GetMessage_v0();
SendMessageWithVersions(message, 0, 0);
var receivedMessage = VersionedTestMessage_v0.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual(message.B, receivedMessage.B);
Assert.AreEqual(message.C, receivedMessage.C);
}
[Test]
public void WhenSendingV0ToV1_DataIsReceivedCorrectly()
{
var message = GetMessage_v0();
SendMessageWithVersions(message, 0, 1);
var receivedMessage = VersionedTestMessage_v1.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual(message.B, receivedMessage.B);
Assert.AreEqual(message.C, receivedMessage.C);
Assert.AreEqual(k_DefaultD, receivedMessage.D);
}
[Test]
public void WhenSendingV0ToV2_DataIsReceivedCorrectly()
{
var message = GetMessage_v0();
SendMessageWithVersions(message, 0, 2);
var receivedMessage = VersionedTestMessage.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual((float)k_DefaultD, receivedMessage.D);
Assert.AreEqual(k_DefaultE, receivedMessage.E);
}
[Test]
public void WhenSendingV1ToV0_DataIsReceivedCorrectly()
{
var message = GetMessage_v1();
SendMessageWithVersions(message, 1, 0);
var receivedMessage = VersionedTestMessage_v0.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual(message.B, receivedMessage.B);
Assert.AreEqual(message.C, receivedMessage.C);
}
[Test]
public void WhenSendingV1ToV1_DataIsReceivedCorrectly()
{
var message = GetMessage_v1();
SendMessageWithVersions(message, 1, 1);
var receivedMessage = VersionedTestMessage_v1.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual(message.B, receivedMessage.B);
Assert.AreEqual(message.C, receivedMessage.C);
Assert.AreEqual(message.D, receivedMessage.D);
}
[Test]
public void WhenSendingV1ToV2_DataIsReceivedCorrectly()
{
var message = GetMessage_v1();
SendMessageWithVersions(message, 1, 2);
var receivedMessage = VersionedTestMessage.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual((float)message.D, receivedMessage.D);
Assert.AreEqual(k_DefaultE, receivedMessage.E);
}
[Test]
public void WhenSendingV2ToV0_DataIsReceivedCorrectly()
{
var message = GetMessage_v2();
SendMessageWithVersions(message, 2, 0);
var receivedMessage = VersionedTestMessage_v0.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual(k_DefaultB, receivedMessage.B);
Assert.AreEqual(k_DefaultC, receivedMessage.C);
}
[Test]
public void WhenSendingV2ToV1_DataIsReceivedCorrectly()
{
var message = GetMessage_v2();
SendMessageWithVersions(message, 2, 1);
var receivedMessage = VersionedTestMessage_v1.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual(k_DefaultB, receivedMessage.B);
Assert.AreEqual(k_DefaultC, receivedMessage.C);
Assert.AreEqual((int)message.D, receivedMessage.D);
}
[Test]
public void WhenSendingV2ToV2_DataIsReceivedCorrectly()
{
var message = GetMessage_v2();
SendMessageWithVersions(message, 2, 2);
var receivedMessage = VersionedTestMessage.DeserializedValues[0];
Assert.AreEqual(message.A, receivedMessage.A);
Assert.AreEqual(message.D, receivedMessage.D);
Assert.AreEqual(message.E, receivedMessage.E);
}
}
}

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

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: eac9a654aacb4faf91128c9ab6024543
timeCreated: 1667326658

20
Tests/Editor/NetworkObjectTests.cs
View File

@@ -1,3 +1,4 @@
using System.Text.RegularExpressions;
using NUnit.Framework;
using UnityEngine;
using UnityEngine.TestTools;
@@ -31,19 +32,17 @@ namespace Unity.Netcode.EditorTests
}
[Test]
public void GetBehaviourIndexNone()
[TestCase(0)]
[TestCase(1)]
[TestCase(2)]
public void GetBehaviourIndexNone(int index)
{
var gameObject = new GameObject(nameof(GetBehaviourIndexNone));
var networkObject = gameObject.AddComponent<NetworkObject>();
// TODO: Maybe not hardcode message?
LogAssert.Expect(LogType.Error, $"[Netcode] Behaviour index was out of bounds. Did you mess up the order of your {nameof(NetworkBehaviour)}s?");
LogAssert.Expect(LogType.Error, $"[Netcode] Behaviour index was out of bounds. Did you mess up the order of your {nameof(NetworkBehaviour)}s?");
LogAssert.Expect(LogType.Error, $"[Netcode] Behaviour index was out of bounds. Did you mess up the order of your {nameof(NetworkBehaviour)}s?");
LogAssert.Expect(LogType.Error, new Regex(".*out of bounds.*"));
Assert.That(networkObject.GetNetworkBehaviourAtOrderIndex(0), Is.Null);
Assert.That(networkObject.GetNetworkBehaviourAtOrderIndex(1), Is.Null);
Assert.That(networkObject.GetNetworkBehaviourAtOrderIndex(2), Is.Null);
Assert.That(networkObject.GetNetworkBehaviourAtOrderIndex((ushort)index), Is.Null);
// Cleanup
Object.DestroyImmediate(gameObject);
@@ -56,13 +55,10 @@ namespace Unity.Netcode.EditorTests
var networkObject = gameObject.AddComponent<NetworkObject>();
var networkBehaviour = gameObject.AddComponent<EmptyNetworkBehaviour>();
// TODO: Maybe not hardcode message?
LogAssert.Expect(LogType.Error, $"[Netcode] Behaviour index was out of bounds. Did you mess up the order of your {nameof(NetworkBehaviour)}s?");
LogAssert.Expect(LogType.Error, $"[Netcode] Behaviour index was out of bounds. Did you mess up the order of your {nameof(NetworkBehaviour)}s?");
LogAssert.Expect(LogType.Error, new Regex(".*out of bounds.*"));
Assert.That(networkObject.GetNetworkBehaviourAtOrderIndex(0), Is.EqualTo(networkBehaviour));
Assert.That(networkObject.GetNetworkBehaviourAtOrderIndex(1), Is.Null);
Assert.That(networkObject.GetNetworkBehaviourAtOrderIndex(2), Is.Null);
// Cleanup
Object.DestroyImmediate(gameObject);

517
Tests/Editor/Serialization/BytePackerTests.cs
View File

@@ -76,116 +76,6 @@ namespace Unity.Netcode.EditorTests
#endregion
private void CheckUnsignedPackedSize64(FastBufferWriter writer, ulong value)
{
if (value <= 240)
{
Assert.AreEqual(1, writer.Position);
}
else if (value <= 2287)
{
Assert.AreEqual(2, writer.Position);
}
else
{
Assert.AreEqual(BitCounter.GetUsedByteCount(value) + 1, writer.Position);
}
}
private void CheckUnsignedPackedValue64(FastBufferWriter writer, ulong value)
{
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
ByteUnpacker.ReadValuePacked(reader, out ulong readValue);
Assert.AreEqual(readValue, value);
}
}
private void CheckUnsignedPackedSize32(FastBufferWriter writer, uint value)
{
if (value <= 240)
{
Assert.AreEqual(1, writer.Position);
}
else if (value <= 2287)
{
Assert.AreEqual(2, writer.Position);
}
else
{
Assert.AreEqual(BitCounter.GetUsedByteCount(value) + 1, writer.Position);
}
}
private void CheckUnsignedPackedValue32(FastBufferWriter writer, uint value)
{
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
ByteUnpacker.ReadValuePacked(reader, out uint readValue);
Assert.AreEqual(readValue, value);
}
}
private void CheckSignedPackedSize64(FastBufferWriter writer, long value)
{
ulong asUlong = Arithmetic.ZigZagEncode(value);
if (asUlong <= 240)
{
Assert.AreEqual(1, writer.Position);
}
else if (asUlong <= 2287)
{
Assert.AreEqual(2, writer.Position);
}
else
{
Assert.AreEqual(BitCounter.GetUsedByteCount(asUlong) + 1, writer.Position);
}
}
private void CheckSignedPackedValue64(FastBufferWriter writer, long value)
{
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
ByteUnpacker.ReadValuePacked(reader, out long readValue);
Assert.AreEqual(readValue, value);
}
}
private void CheckSignedPackedSize32(FastBufferWriter writer, int value)
{
ulong asUlong = Arithmetic.ZigZagEncode(value);
if (asUlong <= 240)
{
Assert.AreEqual(1, writer.Position);
}
else if (asUlong <= 2287)
{
Assert.AreEqual(2, writer.Position);
}
else
{
Assert.AreEqual(BitCounter.GetUsedByteCount(asUlong) + 1, writer.Position);
}
}
private void CheckSignedPackedValue32(FastBufferWriter writer, int value)
{
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
{
ByteUnpacker.ReadValuePacked(reader, out int readValue);
Assert.AreEqual(readValue, value);
}
}
private unsafe void VerifyBytewiseEquality<T>(T value, T otherValue) where T : unmanaged
{
byte* asBytePointer = (byte*)&value;
@@ -229,164 +119,53 @@ namespace Unity.Netcode.EditorTests
}
}
[Test]
public void TestPacking64BitsUnsigned()
private int GetByteCount64Bits(ulong value)
{
var writer = new FastBufferWriter(9, Allocator.Temp);
using (writer)
if (value <= 0b0000_1111)
{
writer.TryBeginWrite(9);
ulong value = 0;
BytePacker.WriteValuePacked(writer, value);
Assert.AreEqual(1, writer.Position);
for (var i = 0; i < 64; ++i)
{
value = 1UL << i;
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValuePacked(writer, value);
CheckUnsignedPackedSize64(writer, value);
CheckUnsignedPackedValue64(writer, value);
for (var j = 0; j < 8; ++j)
{
value = (1UL << i) | (1UL << j);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValuePacked(writer, value);
CheckUnsignedPackedSize64(writer, value);
CheckUnsignedPackedValue64(writer, value);
}
}
return 1;
}
if (value <= 0b0000_1111_1111_1111)
{
return 2;
}
if (value <= 0b0000_1111_1111_1111_1111_1111)
{
return 3;
}
if (value <= 0b0000_1111_1111_1111_1111_1111_1111_1111)
{
return 4;
}
if (value <= 0b0000_1111_1111_1111_1111_1111_1111_1111_1111_1111)
{
return 5;
}
if (value <= 0b0000_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111)
{
return 6;
}
if (value <= 0b0000_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111)
{
return 7;
}
if (value <= 0b0000_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111)
{
return 8;
}
return 9;
}
[Test]
public void TestPacking32BitsUnsigned()
{
var writer = new FastBufferWriter(9, Allocator.Temp);
using (writer)
{
writer.TryBeginWrite(9);
uint value = 0;
BytePacker.WriteValuePacked(writer, value);
Assert.AreEqual(1, writer.Position);
for (var i = 0; i < 64; ++i)
{
value = 1U << i;
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValuePacked(writer, value);
CheckUnsignedPackedSize32(writer, value);
CheckUnsignedPackedValue32(writer, value);
for (var j = 0; j < 8; ++j)
{
value = (1U << i) | (1U << j);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValuePacked(writer, value);
CheckUnsignedPackedSize32(writer, value);
CheckUnsignedPackedValue32(writer, value);
}
}
}
}
[Test]
public void TestPacking64BitsSigned()
{
var writer = new FastBufferWriter(9, Allocator.Temp);
using (writer)
{
writer.TryBeginWrite(9);
long value = 0;
BytePacker.WriteValuePacked(writer, value);
Assert.AreEqual(1, writer.Position);
for (var i = 0; i < 64; ++i)
{
value = 1L << i;
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValuePacked(writer, value);
CheckSignedPackedSize64(writer, value);
CheckSignedPackedValue64(writer, value);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValuePacked(writer, -value);
CheckSignedPackedSize64(writer, -value);
CheckSignedPackedValue64(writer, -value);
for (var j = 0; j < 8; ++j)
{
value = (1L << i) | (1L << j);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValuePacked(writer, value);
CheckSignedPackedSize64(writer, value);
CheckSignedPackedValue64(writer, value);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValuePacked(writer, -value);
CheckSignedPackedSize64(writer, -value);
CheckSignedPackedValue64(writer, -value);
}
}
}
}
[Test]
public void TestPacking32BitsSigned()
{
var writer = new FastBufferWriter(9, Allocator.Temp);
using (writer)
{
writer.TryBeginWrite(5);
int value = 0;
BytePacker.WriteValuePacked(writer, value);
Assert.AreEqual(1, writer.Position);
for (var i = 0; i < 64; ++i)
{
value = 1 << i;
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValuePacked(writer, value);
CheckSignedPackedSize32(writer, value);
CheckSignedPackedValue32(writer, value);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValuePacked(writer, -value);
CheckSignedPackedSize32(writer, -value);
CheckSignedPackedValue32(writer, -value);
for (var j = 0; j < 8; ++j)
{
value = (1 << i) | (1 << j);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValuePacked(writer, value);
CheckSignedPackedSize32(writer, value);
CheckSignedPackedValue32(writer, value);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValuePacked(writer, -value);
CheckSignedPackedSize32(writer, -value);
CheckSignedPackedValue32(writer, -value);
}
}
}
}
private int GetByteCount61Bits(ulong value)
private int GetByteCount32Bits(uint value)
{
if (value <= 0b0001_1111)
@@ -409,57 +188,25 @@ namespace Unity.Netcode.EditorTests
return 4;
}
if (value <= 0b0001_1111_1111_1111_1111_1111_1111_1111_1111_1111)
{
return 5;
}
if (value <= 0b0001_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111)
{
return 6;
}
if (value <= 0b0001_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111)
{
return 7;
}
return 8;
return 5;
}
private int GetByteCount30Bits(uint value)
private int GetByteCount16Bits(ushort value)
{
if (value <= 0b0011_1111)
{
return 1;
}
if (value <= 0b0011_1111_1111_1111)
{
return 2;
}
if (value <= 0b0011_1111_1111_1111_1111_1111)
{
return 3;
}
return 4;
return 3;
}
private int GetByteCount15Bits(ushort value)
{
if (value <= 0b0111_1111)
{
return 1;
}
return 2;
}
private ulong Get61BitEncodedValue(FastBufferWriter writer)
private ulong Get64BitEncodedValue(FastBufferWriter writer)
{
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
@@ -469,7 +216,7 @@ namespace Unity.Netcode.EditorTests
}
}
private long Get60BitSignedEncodedValue(FastBufferWriter writer)
private long Get64BitSignedEncodedValue(FastBufferWriter writer)
{
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
@@ -479,7 +226,7 @@ namespace Unity.Netcode.EditorTests
}
}
private uint Get30BitEncodedValue(FastBufferWriter writer)
private uint Get32BitEncodedValue(FastBufferWriter writer)
{
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
@@ -489,7 +236,7 @@ namespace Unity.Netcode.EditorTests
}
}
private int Get29BitSignedEncodedValue(FastBufferWriter writer)
private int Get32BitSignedEncodedValue(FastBufferWriter writer)
{
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
@@ -499,7 +246,7 @@ namespace Unity.Netcode.EditorTests
}
}
private ushort Get15BitEncodedValue(FastBufferWriter writer)
private ushort Get16BitEncodedValue(FastBufferWriter writer)
{
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
@@ -509,7 +256,7 @@ namespace Unity.Netcode.EditorTests
}
}
private short Get14BitSignedEncodedValue(FastBufferWriter writer)
private short Get16BitSignedEncodedValue(FastBufferWriter writer)
{
var reader = new FastBufferReader(writer, Allocator.Temp);
using (reader)
@@ -520,7 +267,7 @@ namespace Unity.Netcode.EditorTests
}
[Test]
public void TestBitPacking61BitsUnsigned()
public void TestBitPacking64BitsUnsigned()
{
var writer = new FastBufferWriter(9, Allocator.Temp);
@@ -530,18 +277,18 @@ namespace Unity.Netcode.EditorTests
ulong value = 0;
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(1, writer.Position);
Assert.AreEqual(0, writer.ToArray()[0] & 0b111);
Assert.AreEqual(value, Get61BitEncodedValue(writer));
Assert.AreEqual(1, writer.ToArray()[0] & 0b1111);
Assert.AreEqual(value, Get64BitEncodedValue(writer));
for (var i = 0; i < 61; ++i)
for (var i = 0; i < 64; ++i)
{
value = 1UL << i;
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount61Bits(value), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount61Bits(value) - 1, writer.ToArray()[0] & 0b111, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get61BitEncodedValue(writer));
Assert.AreEqual(GetByteCount64Bits(value), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount64Bits(value), writer.ToArray()[0] & 0b1111, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get64BitEncodedValue(writer));
for (var j = 0; j < 8; ++j)
{
@@ -549,18 +296,16 @@ namespace Unity.Netcode.EditorTests
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount61Bits(value), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount61Bits(value) - 1, writer.ToArray()[0] & 0b111, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get61BitEncodedValue(writer));
Assert.AreEqual(GetByteCount64Bits(value), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount64Bits(value), writer.ToArray()[0] & 0b1111, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get64BitEncodedValue(writer));
}
}
Assert.Throws<ArgumentException>(() => { BytePacker.WriteValueBitPacked(writer, 1UL << 61); });
}
}
[Test]
public void TestBitPacking60BitsSigned()
public void TestBitPacking64BitsSigned()
{
var writer = new FastBufferWriter(9, Allocator.Temp);
@@ -570,28 +315,28 @@ namespace Unity.Netcode.EditorTests
long value = 0;
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(1, writer.Position);
Assert.AreEqual(0, writer.ToArray()[0] & 0b111);
Assert.AreEqual(value, Get60BitSignedEncodedValue(writer));
Assert.AreEqual(1, writer.ToArray()[0] & 0b1111);
Assert.AreEqual(value, Get64BitSignedEncodedValue(writer));
for (var i = 0; i < 61; ++i)
for (var i = 0; i < 64; ++i)
{
value = 1U << i;
ulong zzvalue = Arithmetic.ZigZagEncode(value);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount61Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount61Bits(zzvalue) - 1, writer.ToArray()[0] & 0b111, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get60BitSignedEncodedValue(writer));
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.ToArray()[0] & 0b1111, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get64BitSignedEncodedValue(writer));
value = -value;
zzvalue = Arithmetic.ZigZagEncode(value);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount61Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount61Bits(zzvalue) - 1, writer.ToArray()[0] & 0b111, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get60BitSignedEncodedValue(writer));
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.ToArray()[0] & 0b1111, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get64BitSignedEncodedValue(writer));
for (var j = 0; j < 8; ++j)
{
@@ -600,27 +345,25 @@ namespace Unity.Netcode.EditorTests
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount61Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount61Bits(zzvalue) - 1, writer.ToArray()[0] & 0b111, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get60BitSignedEncodedValue(writer));
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.ToArray()[0] & 0b1111, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get64BitSignedEncodedValue(writer));
value = -value;
zzvalue = Arithmetic.ZigZagEncode(value);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount61Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount61Bits(zzvalue) - 1, writer.ToArray()[0] & 0b111, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get60BitSignedEncodedValue(writer));
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.ToArray()[0] & 0b1111, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get64BitSignedEncodedValue(writer));
}
}
Assert.Throws<ArgumentException>(() => { BytePacker.WriteValueBitPacked(writer, 1UL << 61); });
}
}
[Test]
public void TestBitPacking30BitsUnsigned()
public void TestBitPacking32BitsUnsigned()
{
var writer = new FastBufferWriter(9, Allocator.Temp);
@@ -630,18 +373,18 @@ namespace Unity.Netcode.EditorTests
uint value = 0;
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(1, writer.Position);
Assert.AreEqual(0, writer.ToArray()[0] & 0b11);
Assert.AreEqual(value, Get30BitEncodedValue(writer));
Assert.AreEqual(1, writer.ToArray()[0] & 0b111);
Assert.AreEqual(value, Get32BitEncodedValue(writer));
for (var i = 0; i < 30; ++i)
for (var i = 0; i < 32; ++i)
{
value = 1U << i;
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount30Bits(value), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount30Bits(value) - 1, writer.ToArray()[0] & 0b11, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get30BitEncodedValue(writer));
Assert.AreEqual(GetByteCount32Bits(value), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount32Bits(value), writer.ToArray()[0] & 0b111, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get32BitEncodedValue(writer));
for (var j = 0; j < 8; ++j)
{
@@ -649,18 +392,16 @@ namespace Unity.Netcode.EditorTests
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount30Bits(value), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount30Bits(value) - 1, writer.ToArray()[0] & 0b11, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get30BitEncodedValue(writer));
Assert.AreEqual(GetByteCount32Bits(value), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount32Bits(value), writer.ToArray()[0] & 0b111, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get32BitEncodedValue(writer));
}
}
Assert.Throws<ArgumentException>(() => { BytePacker.WriteValueBitPacked(writer, 1U << 30); });
}
}
[Test]
public void TestBitPacking29BitsSigned()
public void TestBitPacking32BitsSigned()
{
var writer = new FastBufferWriter(9, Allocator.Temp);
@@ -670,28 +411,28 @@ namespace Unity.Netcode.EditorTests
int value = 0;
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(1, writer.Position);
Assert.AreEqual(0, writer.ToArray()[0] & 0b11);
Assert.AreEqual(value, Get30BitEncodedValue(writer));
Assert.AreEqual(1, writer.ToArray()[0] & 0b111);
Assert.AreEqual(value, Get32BitEncodedValue(writer));
for (var i = 0; i < 29; ++i)
for (var i = 0; i < 32; ++i)
{
value = 1 << i;
uint zzvalue = (uint)Arithmetic.ZigZagEncode(value);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount30Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount30Bits(zzvalue) - 1, writer.ToArray()[0] & 0b11, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get29BitSignedEncodedValue(writer));
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.ToArray()[0] & 0b111, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get32BitSignedEncodedValue(writer));
value = -value;
zzvalue = (uint)Arithmetic.ZigZagEncode(value);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount30Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount30Bits(zzvalue) - 1, writer.ToArray()[0] & 0b11, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get29BitSignedEncodedValue(writer));
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.ToArray()[0] & 0b111, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get32BitSignedEncodedValue(writer));
for (var j = 0; j < 8; ++j)
{
@@ -700,25 +441,25 @@ namespace Unity.Netcode.EditorTests
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount30Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount30Bits(zzvalue) - 1, writer.ToArray()[0] & 0b11, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get29BitSignedEncodedValue(writer));
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.ToArray()[0] & 0b111, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get32BitSignedEncodedValue(writer));
value = -value;
zzvalue = (uint)Arithmetic.ZigZagEncode(value);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount30Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount30Bits(zzvalue) - 1, writer.ToArray()[0] & 0b11, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get29BitSignedEncodedValue(writer));
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.ToArray()[0] & 0b111, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get32BitSignedEncodedValue(writer));
}
}
}
}
[Test]
public void TestBitPacking15BitsUnsigned()
public void TestBitPacking16BitsUnsigned()
{
var writer = new FastBufferWriter(9, Allocator.Temp);
@@ -728,18 +469,18 @@ namespace Unity.Netcode.EditorTests
ushort value = 0;
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(1, writer.Position);
Assert.AreEqual(0, writer.ToArray()[0] & 0b1);
Assert.AreEqual(value, Get15BitEncodedValue(writer));
Assert.AreEqual(1, writer.ToArray()[0] & 0b11);
Assert.AreEqual(value, Get16BitEncodedValue(writer));
for (var i = 0; i < 15; ++i)
for (var i = 0; i < 16; ++i)
{
value = (ushort)(1U << i);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount15Bits(value), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount15Bits(value) - 1, writer.ToArray()[0] & 0b1, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get15BitEncodedValue(writer));
Assert.AreEqual(GetByteCount16Bits(value), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount16Bits(value), writer.ToArray()[0] & 0b11, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get16BitEncodedValue(writer));
for (var j = 0; j < 8; ++j)
{
@@ -747,17 +488,15 @@ namespace Unity.Netcode.EditorTests
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount15Bits(value), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount15Bits(value) - 1, writer.ToArray()[0] & 0b1, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get15BitEncodedValue(writer));
Assert.AreEqual(GetByteCount16Bits(value), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount16Bits(value), writer.ToArray()[0] & 0b11, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get16BitEncodedValue(writer));
}
}
Assert.Throws<ArgumentException>(() => { BytePacker.WriteValueBitPacked(writer, (ushort)(1U << 15)); });
}
}
[Test]
public void TestBitPacking14BitsSigned()
public void TestBitPacking16BitsSigned()
{
var writer = new FastBufferWriter(9, Allocator.Temp);
@@ -767,28 +506,28 @@ namespace Unity.Netcode.EditorTests
short value = 0;
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(1, writer.Position);
Assert.AreEqual(0, writer.ToArray()[0] & 0b1);
Assert.AreEqual(value, Get15BitEncodedValue(writer));
Assert.AreEqual(1, writer.ToArray()[0] & 0b11);
Assert.AreEqual(value, Get16BitEncodedValue(writer));
for (var i = 0; i < 14; ++i)
for (var i = 0; i < 16; ++i)
{
value = (short)(1 << i);
ushort zzvalue = (ushort)Arithmetic.ZigZagEncode(value);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount15Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount15Bits(zzvalue) - 1, writer.ToArray()[0] & 0b1, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get14BitSignedEncodedValue(writer));
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.ToArray()[0] & 0b11, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get16BitSignedEncodedValue(writer));
value = (short)-value;
zzvalue = (ushort)Arithmetic.ZigZagEncode(value);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount15Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount15Bits(zzvalue) - 1, writer.ToArray()[0] & 0b1, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get14BitSignedEncodedValue(writer));
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.ToArray()[0] & 0b11, $"Failed on {value} ({i})");
Assert.AreEqual(value, Get16BitSignedEncodedValue(writer));
for (var j = 0; j < 8; ++j)
{
@@ -797,18 +536,18 @@ namespace Unity.Netcode.EditorTests
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount15Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount15Bits(zzvalue) - 1, writer.ToArray()[0] & 0b1, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get14BitSignedEncodedValue(writer));
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.ToArray()[0] & 0b11, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get16BitSignedEncodedValue(writer));
value = (short)-value;
zzvalue = (ushort)Arithmetic.ZigZagEncode(value);
writer.Seek(0);
writer.Truncate();
BytePacker.WriteValueBitPacked(writer, value);
Assert.AreEqual(GetByteCount15Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount15Bits(zzvalue) - 1, writer.ToArray()[0] & 0b1, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get14BitSignedEncodedValue(writer));
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.ToArray()[0] & 0b11, $"Failed on {value} ({i}, {j})");
Assert.AreEqual(value, Get16BitSignedEncodedValue(writer));
}
}
}

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

@@ -126,5 +126,40 @@ namespace Unity.Netcode.EditorTests
transport.Shutdown();
}
#if UTP_TRANSPORT_2_0_ABOVE
[Test]
public void UnityTransport_EmptySecurityStringsShouldThrow([Values("", null)] string cert, [Values("", null)] string secret)
{
var supportingGO = new GameObject();
try
{
var networkManager = supportingGO.AddComponent<NetworkManager>(); // NM is required for UTP to work with certificates.
networkManager.NetworkConfig = new NetworkConfig();
UnityTransport transport = supportingGO.AddComponent<UnityTransport>();
networkManager.NetworkConfig.NetworkTransport = transport;
transport.Initialize();
transport.SetServerSecrets(serverCertificate: cert, serverPrivateKey: secret);
// Use encryption, but don't set certificate and check for exception
transport.UseEncryption = true;
Assert.Throws<System.Exception>(() =>
{
networkManager.StartServer();
});
// Make sure StartServer failed
Assert.False(transport.NetworkDriver.IsCreated);
Assert.False(networkManager.IsServer);
Assert.False(networkManager.IsListening);
}
finally
{
if (supportingGO != null)
{
Object.DestroyImmediate(supportingGO);
}
}
}
#endif
}
}

3
Tests/Editor/UI.meta
View File

@@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: f672293e0efc41a6a7e930fd7ff14436
timeCreated: 1631650280

15
Tests/Editor/UI/UITestHelpers.cs
View File

@@ -1,15 +0,0 @@
using Unity.Netcode.Editor;
using UnityEditor;
using UnityEngine;
namespace Unity.Netcode.EditorTests
{
internal static class UITestHelpers
{
[MenuItem("Netcode/UI/Reset Multiplayer Tools Tip Status")]
private static void ResetMultiplayerToolsTipStatus()
{
PlayerPrefs.DeleteKey(NetworkManagerEditor.InstallMultiplayerToolsTipDismissedPlayerPrefKey);
}
}
}

3
Tests/Editor/UI/UITestHelpers.cs.meta
View File

@@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: bde5fc3349494f77bebd0be12a6957e1
timeCreated: 1631650292

31
Tests/Editor/XXHashTests.cs Normal file
View File

@@ -0,0 +1,31 @@
using NUnit.Framework;
namespace Unity.Netcode.EditorTests
{
public class XXHashTests
{
[Test]
public void TestXXHash32Short()
{
Assert.That("TestStuff".Hash32(), Is.EqualTo(0x64e10c4c));
}
[Test]
public void TestXXHash32Long()
{
Assert.That("TestingHashingWithLongStringValues".Hash32(), Is.EqualTo(0xba3d1783));
}
[Test]
public void TestXXHas64Short()
{
Assert.That("TestStuff".Hash64(), Is.EqualTo(0x4c3be8d82d14a5a9));
}
[Test]
public void TestXXHash64Long()
{
Assert.That("TestingHashingWithLongStringValues".Hash64(), Is.EqualTo(0x5b374f98b10bf246));
}
}
}

11
Tests/Editor/XXHashTests.cs.meta Normal file
View File

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

7
Tests/Editor/com.unity.netcode.editortests.asmdef
View File

@@ -32,6 +32,11 @@
"name": "Unity",
"expression": "(0,2022.2.0a5)",
"define": "UNITY_UNET_PRESENT"
},
{
"name": "com.unity.transport",
"expression": "2.0.0-exp",
"define": "UTP_TRANSPORT_2_0_ABOVE"
}
]
}
}