fe02ca682e
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)
843 lines
31 KiB
C#
843 lines
31 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using NUnit.Framework;
|
|
using Unity.Collections;
|
|
using UnityEngine;
|
|
using Random = System.Random;
|
|
|
|
namespace Unity.Netcode.EditorTests
|
|
{
|
|
public class BytePackerTests
|
|
{
|
|
#region Test Types
|
|
|
|
private enum ByteEnum : byte
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
private enum SByteEnum : sbyte
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
private enum ShortEnum : short
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
private enum UShortEnum : ushort
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
private enum IntEnum
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
private enum UIntEnum : uint
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
private enum LongEnum : long
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
private enum ULongEnum : ulong
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
public enum WriteType
|
|
{
|
|
WriteDirect,
|
|
WriteAsObject
|
|
}
|
|
|
|
#endregion
|
|
|
|
private unsafe void VerifyBytewiseEquality<T>(T value, T otherValue) where T : unmanaged
|
|
{
|
|
byte* asBytePointer = (byte*)&value;
|
|
byte* otherBytePointer = (byte*)&otherValue;
|
|
for (var i = 0; i < sizeof(T); ++i)
|
|
{
|
|
Assert.AreEqual(asBytePointer[i], otherBytePointer[i]);
|
|
}
|
|
}
|
|
|
|
private unsafe void RunTypeTest<T>(T value) where T : unmanaged
|
|
{
|
|
var writer = new FastBufferWriter(sizeof(T) * 2, Allocator.Temp);
|
|
using (writer)
|
|
{
|
|
BytePacker.WriteValuePacked(writer, (dynamic)value);
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
|
|
var outVal = new T();
|
|
MethodInfo method;
|
|
if (value is Enum)
|
|
{
|
|
method = typeof(ByteUnpacker).GetMethods().Single(x =>
|
|
x.Name == "ReadValuePacked" && x.IsGenericMethodDefinition)
|
|
.MakeGenericMethod(typeof(T));
|
|
}
|
|
else
|
|
{
|
|
method = typeof(ByteUnpacker).GetMethod("ReadValuePacked",
|
|
new[] { typeof(FastBufferReader), typeof(T).MakeByRefType() });
|
|
}
|
|
|
|
object[] args = { reader, outVal };
|
|
method.Invoke(null, args);
|
|
outVal = (T)args[1];
|
|
Assert.AreEqual(value, outVal);
|
|
VerifyBytewiseEquality(value, outVal);
|
|
}
|
|
}
|
|
}
|
|
|
|
private int GetByteCount64Bits(ulong value)
|
|
{
|
|
|
|
if (value <= 0b0000_1111)
|
|
{
|
|
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;
|
|
}
|
|
|
|
private int GetByteCount32Bits(uint value)
|
|
{
|
|
|
|
if (value <= 0b0001_1111)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
if (value <= 0b0001_1111_1111_1111)
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
if (value <= 0b0001_1111_1111_1111_1111_1111)
|
|
{
|
|
return 3;
|
|
}
|
|
|
|
if (value <= 0b0001_1111_1111_1111_1111_1111_1111_1111)
|
|
{
|
|
return 4;
|
|
}
|
|
|
|
return 5;
|
|
}
|
|
|
|
private int GetByteCount16Bits(ushort value)
|
|
{
|
|
|
|
if (value <= 0b0011_1111)
|
|
{
|
|
return 1;
|
|
}
|
|
if (value <= 0b0011_1111_1111_1111)
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
return 3;
|
|
}
|
|
|
|
private ulong Get64BitEncodedValue(FastBufferWriter writer)
|
|
{
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out ulong value);
|
|
return value;
|
|
}
|
|
}
|
|
|
|
private long Get64BitSignedEncodedValue(FastBufferWriter writer)
|
|
{
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out long value);
|
|
return value;
|
|
}
|
|
}
|
|
|
|
private uint Get32BitEncodedValue(FastBufferWriter writer)
|
|
{
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out uint value);
|
|
return value;
|
|
}
|
|
}
|
|
|
|
private int Get32BitSignedEncodedValue(FastBufferWriter writer)
|
|
{
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value);
|
|
return value;
|
|
}
|
|
}
|
|
|
|
private ushort Get16BitEncodedValue(FastBufferWriter writer)
|
|
{
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out ushort value);
|
|
return value;
|
|
}
|
|
}
|
|
|
|
private short Get16BitSignedEncodedValue(FastBufferWriter writer)
|
|
{
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out short value);
|
|
return value;
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBitPacking64BitsUnsigned()
|
|
{
|
|
var writer = new FastBufferWriter(9, Allocator.Temp);
|
|
|
|
using (writer)
|
|
{
|
|
writer.TryBeginWrite(8);
|
|
ulong value = 0;
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(1, writer.Position);
|
|
Assert.AreEqual(1, writer.ToArray()[0] & 0b1111);
|
|
Assert.AreEqual(value, Get64BitEncodedValue(writer));
|
|
|
|
for (var i = 0; i < 64; ++i)
|
|
{
|
|
value = 1UL << i;
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
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)
|
|
{
|
|
value = (1UL << i) | (1UL << j);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
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));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBitPacking64BitsSigned()
|
|
{
|
|
var writer = new FastBufferWriter(9, Allocator.Temp);
|
|
|
|
using (writer)
|
|
{
|
|
writer.TryBeginWrite(8);
|
|
long value = 0;
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(1, writer.Position);
|
|
Assert.AreEqual(1, writer.ToArray()[0] & 0b1111);
|
|
Assert.AreEqual(value, Get64BitSignedEncodedValue(writer));
|
|
|
|
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(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(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)
|
|
{
|
|
value = (1U << i) | (1U << j);
|
|
zzvalue = Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
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(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));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBitPacking32BitsUnsigned()
|
|
{
|
|
var writer = new FastBufferWriter(9, Allocator.Temp);
|
|
|
|
using (writer)
|
|
{
|
|
writer.TryBeginWrite(4);
|
|
uint value = 0;
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(1, writer.Position);
|
|
Assert.AreEqual(1, writer.ToArray()[0] & 0b111);
|
|
Assert.AreEqual(value, Get32BitEncodedValue(writer));
|
|
|
|
for (var i = 0; i < 32; ++i)
|
|
{
|
|
value = 1U << i;
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
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)
|
|
{
|
|
value = (1U << i) | (1U << j);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
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));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBitPacking32BitsSigned()
|
|
{
|
|
var writer = new FastBufferWriter(9, Allocator.Temp);
|
|
|
|
using (writer)
|
|
{
|
|
writer.TryBeginWrite(4);
|
|
int value = 0;
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(1, writer.Position);
|
|
Assert.AreEqual(1, writer.ToArray()[0] & 0b111);
|
|
Assert.AreEqual(value, Get32BitEncodedValue(writer));
|
|
|
|
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(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(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)
|
|
{
|
|
value = (1 << i) | (1 << j);
|
|
zzvalue = (uint)Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
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(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 TestBitPacking16BitsUnsigned()
|
|
{
|
|
var writer = new FastBufferWriter(9, Allocator.Temp);
|
|
|
|
using (writer)
|
|
{
|
|
writer.TryBeginWrite(2);
|
|
ushort value = 0;
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(1, writer.Position);
|
|
Assert.AreEqual(1, writer.ToArray()[0] & 0b11);
|
|
Assert.AreEqual(value, Get16BitEncodedValue(writer));
|
|
|
|
for (var i = 0; i < 16; ++i)
|
|
{
|
|
value = (ushort)(1U << i);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
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)
|
|
{
|
|
value = (ushort)((1U << i) | (1U << j));
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
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));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
[Test]
|
|
public void TestBitPacking16BitsSigned()
|
|
{
|
|
var writer = new FastBufferWriter(9, Allocator.Temp);
|
|
|
|
using (writer)
|
|
{
|
|
writer.TryBeginWrite(2);
|
|
short value = 0;
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(1, writer.Position);
|
|
Assert.AreEqual(1, writer.ToArray()[0] & 0b11);
|
|
Assert.AreEqual(value, Get16BitEncodedValue(writer));
|
|
|
|
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(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(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)
|
|
{
|
|
value = (short)((1 << i) | (1 << j));
|
|
zzvalue = (ushort)Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
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(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));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestPackingBasicTypes(
|
|
[Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
|
|
typeof(long), typeof(ulong), typeof(bool), typeof(char), typeof(float), typeof(double),
|
|
typeof(ByteEnum), typeof(SByteEnum), typeof(ShortEnum), typeof(UShortEnum), typeof(IntEnum),
|
|
typeof(UIntEnum), typeof(LongEnum), typeof(ULongEnum), typeof(Vector2), typeof(Vector3), typeof(Vector4),
|
|
typeof(Quaternion), typeof(Color), typeof(Color32), typeof(Ray), typeof(Ray2D))]
|
|
Type testType,
|
|
[Values] WriteType writeType)
|
|
{
|
|
var random = new Random();
|
|
|
|
if (testType == typeof(byte))
|
|
{
|
|
byte b = (byte)random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(b);
|
|
}
|
|
}
|
|
else if (testType == typeof(sbyte))
|
|
{
|
|
sbyte sb = (sbyte)random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(sb);
|
|
}
|
|
}
|
|
else if (testType == typeof(short))
|
|
{
|
|
short s = (short)random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(s);
|
|
}
|
|
}
|
|
else if (testType == typeof(ushort))
|
|
{
|
|
ushort us = (ushort)random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(us);
|
|
}
|
|
}
|
|
else if (testType == typeof(int))
|
|
{
|
|
int i = random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(i);
|
|
}
|
|
}
|
|
else if (testType == typeof(uint))
|
|
{
|
|
uint ui = (uint)random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(ui);
|
|
}
|
|
}
|
|
else if (testType == typeof(long))
|
|
{
|
|
long l = ((long)random.Next() << 32) + random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(l);
|
|
}
|
|
}
|
|
else if (testType == typeof(ulong))
|
|
{
|
|
ulong ul = ((ulong)random.Next() << 32) + (ulong)random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(ul);
|
|
}
|
|
}
|
|
else if (testType == typeof(bool))
|
|
{
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(true);
|
|
}
|
|
}
|
|
else if (testType == typeof(char))
|
|
{
|
|
char c = 'a';
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(c);
|
|
}
|
|
|
|
c = '\u263a';
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(c);
|
|
}
|
|
}
|
|
else if (testType == typeof(float))
|
|
{
|
|
float f = (float)random.NextDouble();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(f);
|
|
}
|
|
}
|
|
else if (testType == typeof(double))
|
|
{
|
|
double d = random.NextDouble();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(d);
|
|
}
|
|
}
|
|
else if (testType == typeof(ByteEnum))
|
|
{
|
|
ByteEnum e = ByteEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(SByteEnum))
|
|
{
|
|
SByteEnum e = SByteEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(ShortEnum))
|
|
{
|
|
ShortEnum e = ShortEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(UShortEnum))
|
|
{
|
|
UShortEnum e = UShortEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(IntEnum))
|
|
{
|
|
IntEnum e = IntEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(UIntEnum))
|
|
{
|
|
UIntEnum e = UIntEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(LongEnum))
|
|
{
|
|
LongEnum e = LongEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(ULongEnum))
|
|
{
|
|
ULongEnum e = ULongEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(Vector2))
|
|
{
|
|
var v = new Vector2((float)random.NextDouble(), (float)random.NextDouble());
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(v);
|
|
}
|
|
}
|
|
else if (testType == typeof(Vector3))
|
|
{
|
|
var v = new Vector3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(v);
|
|
}
|
|
}
|
|
else if (testType == typeof(Vector4))
|
|
{
|
|
var v = new Vector4((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(v);
|
|
}
|
|
}
|
|
else if (testType == typeof(Quaternion))
|
|
{
|
|
var v = new Quaternion((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(v);
|
|
}
|
|
}
|
|
else if (testType == typeof(Color))
|
|
{
|
|
var v = new Color((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(v);
|
|
}
|
|
}
|
|
else if (testType == typeof(Color32))
|
|
{
|
|
var v = new Color32((byte)random.Next(), (byte)random.Next(), (byte)random.Next(), (byte)random.Next());
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(v);
|
|
}
|
|
}
|
|
else if (testType == typeof(Ray))
|
|
{
|
|
// Rays need special handling on the equality checks because the constructor normalizes direction
|
|
// Which can cause slight variations in the result
|
|
var v = new Ray(
|
|
new Vector3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble()),
|
|
new Vector3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble()));
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
unsafe
|
|
{
|
|
var writer = new FastBufferWriter(sizeof(Ray) * 2, Allocator.Temp);
|
|
using (writer)
|
|
{
|
|
BytePacker.WriteValuePacked(writer, v);
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValuePacked(reader, out Ray outVal);
|
|
Assert.AreEqual(v.origin, outVal.origin);
|
|
Assert.AreEqual(v.direction.x, outVal.direction.x, 0.00001);
|
|
Assert.AreEqual(v.direction.y, outVal.direction.y, 0.00001);
|
|
Assert.AreEqual(v.direction.z, outVal.direction.z, 0.00001);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (testType == typeof(Ray2D))
|
|
{
|
|
// Rays need special handling on the equality checks because the constructor normalizes direction
|
|
// Which can cause slight variations in the result
|
|
var v = new Ray2D(
|
|
new Vector2((float)random.NextDouble(), (float)random.NextDouble()),
|
|
new Vector2((float)random.NextDouble(), (float)random.NextDouble()));
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
unsafe
|
|
{
|
|
var writer = new FastBufferWriter(sizeof(Ray2D) * 2, Allocator.Temp);
|
|
using (writer)
|
|
{
|
|
BytePacker.WriteValuePacked(writer, v);
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValuePacked(reader, out Ray2D outVal);
|
|
Assert.AreEqual(v.origin, outVal.origin);
|
|
Assert.AreEqual(v.direction.x, outVal.direction.x, 0.00001);
|
|
Assert.AreEqual(v.direction.y, outVal.direction.y, 0.00001);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Assert.Fail("No type handler was provided for this type in the test!");
|
|
}
|
|
}
|
|
}
|
|
}
|