com.unity.netcode.gameobjects@1.0.0-pre.10

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.0.0-pre.10] - 2022-06-21 ### Added - Added a new `OnTransportFailure` callback to `NetworkManager`. This callback is invoked when the manager's `NetworkTransport` encounters an unrecoverable error. Transport failures also cause the `NetworkManager` to shut down. Currently, this is only used by `UnityTransport` to signal a timeout of its connection to the Unity Relay servers. (#1994) - Added `NetworkEvent.TransportFailure`, which can be used by implementations of `NetworkTransport` to signal to `NetworkManager` that an unrecoverable error was encountered. (#1994) - Added test to ensure a warning occurs when nesting NetworkObjects in a NetworkPrefab (#1969) - Added `NetworkManager.RemoveNetworkPrefab(...)` to remove a prefab from the prefabs list (#1950) ### Changed - Updated `UnityTransport` dependency on `com.unity.transport` to 1.1.0. (#2025) - (API Breaking) `ConnectionApprovalCallback` is no longer an `event` and will not allow more than 1 handler registered at a time. Also, `ConnectionApprovalCallback` is now a `Func<>` taking `ConnectionApprovalRequest` in and returning `ConnectionApprovalResponse` back out (#1972) ### Removed ### Fixed - Fixed issue where dynamically spawned `NetworkObject`s could throw an exception if the scene of origin handle was zero (0) and the `NetworkObject` was already spawned. (#2017) - Fixed issue where `NetworkObject.Observers` was not being cleared when despawned. (#2009) - Fixed `NetworkAnimator` could not run in the server authoritative mode. (#2003) - Fixed issue where late joining clients would get a soft synchronization error if any in-scene placed NetworkObjects were parented under another `NetworkObject`. (#1985) - Fixed issue where `NetworkBehaviourReference` would throw a type cast exception if using `NetworkBehaviourReference.TryGet` and the component type was not found. (#1984) - Fixed `NetworkSceneManager` was not sending scene event notifications for the currently active scene and any additively loaded scenes when loading a new scene in `LoadSceneMode.Single` mode. (#1975) - Fixed issue where one or more clients disconnecting during a scene event would cause `LoadEventCompleted` or `UnloadEventCompleted` to wait until the `NetworkConfig.LoadSceneTimeOut` period before being triggered. (#1973) - Fixed issues when multiple `ConnectionApprovalCallback`s were registered (#1972) - Fixed a regression in serialization support: `FixedString`, `Vector2Int`, and `Vector3Int` types can now be used in NetworkVariables and RPCs again without requiring a `ForceNetworkSerializeByMemcpy<>` wrapper. (#1961) - Fixed generic types that inherit from NetworkBehaviour causing crashes at compile time. (#1976) - Fixed endless dialog boxes when adding a `NetworkBehaviour` to a `NetworkManager` or vice-versa. (#1947) - Fixed `NetworkAnimator` issue where it was only synchronizing parameters if the layer or state changed or was transitioning between states. (#1946) - Fixed `NetworkAnimator` issue where when it did detect a parameter had changed it would send all parameters as opposed to only the parameters that changed. (#1946) - Fixed `NetworkAnimator` issue where it was not always disposing the `NativeArray` that is allocated when spawned. (#1946) - Fixed `NetworkAnimator` issue where it was not taking the animation speed or state speed multiplier into consideration. (#1946) - Fixed `NetworkAnimator` issue where it was not properly synchronizing late joining clients if they joined while `Animator` was transitioning between states. (#1946) - Fixed `NetworkAnimator` issue where the server was not relaying changes to non-owner clients when a client was the owner. (#1946) - Fixed issue where the `PacketLoss` metric for tools would return the packet loss over a connection lifetime instead of a single frame. (#2004)
2022-06-21 00:00:00 +00:00
parent 5b1fc203ed
commit 0f7a30d285
62 changed files with 3763 additions and 1286 deletions
--- a/Tests/Editor/NetworkManagerConfigurationTests.cs
+++ b/Tests/Editor/NetworkManagerConfigurationTests.cs
@@ -1,6 +1,8 @@
 using NUnit.Framework;
 using UnityEngine;
 using Unity.Netcode.Editor;
+using UnityEditor.SceneManagement;
+using UnityEngine.SceneManagement;
 using UnityEngine.TestTools;

 namespace Unity.Netcode.EditorTests
@@ -78,5 +80,37 @@ namespace Unity.Netcode.EditorTests
            // Clean up
            Object.DestroyImmediate(gameObject);
        }
+
+        [Test]
+        public void NestedNetworkObjectPrefabCheck()
+        {
+            // Setup
+            var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
+            var networkManager = networkManagerObject.AddComponent<NetworkManager>();
+            networkManager.NetworkConfig = new NetworkConfig();
+
+            var parent = new GameObject("Parent").AddComponent<NetworkObject>();
+            var child = new GameObject("Child").AddComponent<NetworkObject>();
+
+            // Set parent
+            child.transform.SetParent(parent.transform);
+
+            // Make it a prefab, warning only applies to prefabs
+            networkManager.AddNetworkPrefab(parent.gameObject);
+
+            // Mark scene as dirty to ensure OnValidate actually runs
+            EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+
+            // Force OnValidate
+            networkManager.OnValidate();
+
+            // Expect a warning
+            LogAssert.Expect(LogType.Warning, $"[Netcode] {NetworkManager.PrefabDebugHelper(networkManager.NetworkConfig.NetworkPrefabs[0])} has child {nameof(NetworkObject)}(s) but they will not be spawned across the network (unsupported {nameof(NetworkPrefab)} setup)");
+
+            // Clean up
+            Object.DestroyImmediate(networkManagerObject);
+            Object.DestroyImmediate(parent);
+
+        }
    }
 }
--- a/Tests/Editor/Serialization/BaseFastBufferReaderWriterTest.cs
+++ b/Tests/Editor/Serialization/BaseFastBufferReaderWriterTest.cs
@@ -220,6 +220,14 @@ namespace Unity.Netcode.EditorTests
            {
                RunTestWithWriteType(new Vector3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble()), writeType);
            }
+            else if (testType == typeof(Vector2Int))
+            {
+                RunTestWithWriteType(new Vector2Int((int)random.NextDouble(), (int)random.NextDouble()), writeType);
+            }
+            else if (testType == typeof(Vector3Int))
+            {
+                RunTestWithWriteType(new Vector3Int((int)random.NextDouble(), (int)random.NextDouble(), (int)random.NextDouble()), writeType);
+            }
            else if (testType == typeof(Vector4))
            {
                RunTestWithWriteType(new Vector4((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble()), writeType);
@@ -495,6 +503,22 @@ namespace Unity.Netcode.EditorTests
                    new Vector3((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble()),
                }, writeType);
            }
+            else if (testType == typeof(Vector2Int))
+            {
+                RunTypeTestLocal(new[]{
+                    new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
+                    new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
+                    new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
+                }, writeType);
+            }
+            else if (testType == typeof(Vector3Int))
+            {
+                RunTypeTestLocal(new[]{
+                    new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
+                    new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
+                    new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
+                }, writeType);
+            }
            else if (testType == typeof(Vector4))
            {
                RunTypeTestLocal(new[]{
--- a/Tests/Editor/Serialization/FastBufferReaderTests.cs
+++ b/Tests/Editor/Serialization/FastBufferReaderTests.cs
@@ -351,8 +351,9 @@ namespace Unity.Netcode.EditorTests
            [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), typeof(TestStruct))]
+                typeof(UIntEnum), typeof(LongEnum), typeof(ULongEnum), typeof(Vector2), typeof(Vector3),
+                typeof(Vector2Int), typeof(Vector3Int), typeof(Vector4), typeof(Quaternion), typeof(Color),
+                typeof(Color32), typeof(Ray), typeof(Ray2D), typeof(TestStruct))]
            Type testType,
            [Values] WriteType writeType)
        {
@@ -364,14 +365,156 @@ namespace Unity.Netcode.EditorTests
            [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), typeof(TestStruct))]
+                typeof(UIntEnum), typeof(LongEnum), typeof(ULongEnum), typeof(Vector2), typeof(Vector3),
+                typeof(Vector2Int), typeof(Vector3Int), typeof(Vector4), typeof(Quaternion), typeof(Color),
+                typeof(Color32), typeof(Ray), typeof(Ray2D), typeof(TestStruct))]
            Type testType,
            [Values] WriteType writeType)
        {
            BaseArrayTypeTest(testType, writeType);
        }

+
+        public unsafe void RunFixedStringTest<T>(T fixedStringValue, int numBytesWritten, WriteType writeType) where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            fixedStringValue.Length = numBytesWritten;
+
+            var serializedValueSize = FastBufferWriter.GetWriteSize(fixedStringValue);
+
+            Assert.AreEqual(serializedValueSize, fixedStringValue.Length + sizeof(int));
+
+            var writer = new FastBufferWriter(serializedValueSize + 3, Allocator.Temp);
+            using (writer)
+            {
+                var offset = 0;
+                switch (writeType)
+                {
+                    case WriteType.WriteDirect:
+                        Assert.IsTrue(writer.TryBeginWrite(serializedValueSize + 2), "Writer denied write permission");
+                        writer.WriteValue(fixedStringValue);
+                        break;
+                    case WriteType.WriteSafe:
+                        writer.WriteValueSafe(fixedStringValue);
+                        break;
+
+                }
+
+                WriteCheckBytes(writer, serializedValueSize + offset);
+
+                var reader = new FastBufferReader(writer, Allocator.Temp);
+                using (reader)
+                {
+                    VerifyPositionAndLength(reader, writer.Length);
+
+                    var result = new T();
+                    reader.ReadValueSafe(out result);
+                    Assert.AreEqual(fixedStringValue, result);
+
+                    VerifyCheckBytes(reader, serializedValueSize);
+                }
+            }
+        }
+
+        [TestCase(3, WriteType.WriteDirect)]
+        [TestCase(5, WriteType.WriteSafe)]
+        [TestCase(16, WriteType.WriteDirect)]
+        [TestCase(29, WriteType.WriteSafe)]
+        public void WhenReadingFixedString32Bytes_ValueIsReadCorrectly(int numBytesWritten, WriteType writeType)
+        {
+            // Repeats 01234567890123456789...
+            string valueToTest = "";
+            for (var i = 0; i < 29; ++i)
+            {
+                valueToTest += (i % 10).ToString();
+            }
+
+            var fixedStringValue = new FixedString32Bytes(valueToTest);
+
+            RunFixedStringTest(fixedStringValue, numBytesWritten, writeType);
+        }
+
+        [TestCase(3, WriteType.WriteDirect)]
+        [TestCase(5, WriteType.WriteSafe)]
+        [TestCase(16, WriteType.WriteDirect)]
+        [TestCase(29, WriteType.WriteSafe)]
+        [TestCase(61, WriteType.WriteSafe)]
+        public void WhenReadingFixedString64Bytes_ValueIsReadCorrectly(int numBytesWritten, WriteType writeType)
+        {
+            // Repeats 01234567890123456789...
+            string valueToTest = "";
+            for (var i = 0; i < 61; ++i)
+            {
+                valueToTest += (i % 10).ToString();
+            }
+
+            var fixedStringValue = new FixedString64Bytes(valueToTest);
+
+            RunFixedStringTest(fixedStringValue, numBytesWritten, writeType);
+        }
+
+        [TestCase(3, WriteType.WriteDirect)]
+        [TestCase(5, WriteType.WriteSafe)]
+        [TestCase(16, WriteType.WriteDirect)]
+        [TestCase(29, WriteType.WriteSafe)]
+        [TestCase(61, WriteType.WriteSafe)]
+        [TestCase(125, WriteType.WriteSafe)]
+        public void WhenReadingFixedString128Bytes_ValueIsReadCorrectly(int numBytesWritten, WriteType writeType)
+        {
+            // Repeats 01234567890123456789...
+            string valueToTest = "";
+            for (var i = 0; i < 125; ++i)
+            {
+                valueToTest += (i % 10).ToString();
+            }
+
+            var fixedStringValue = new FixedString128Bytes(valueToTest);
+
+            RunFixedStringTest(fixedStringValue, numBytesWritten, writeType);
+        }
+
+        [TestCase(3, WriteType.WriteDirect)]
+        [TestCase(5, WriteType.WriteSafe)]
+        [TestCase(16, WriteType.WriteDirect)]
+        [TestCase(29, WriteType.WriteSafe)]
+        [TestCase(61, WriteType.WriteSafe)]
+        [TestCase(125, WriteType.WriteSafe)]
+        [TestCase(509, WriteType.WriteSafe)]
+        public void WhenReadingFixedString512Bytes_ValueIsReadCorrectly(int numBytesWritten, WriteType writeType)
+        {
+            // Repeats 01234567890123456789...
+            string valueToTest = "";
+            for (var i = 0; i < 509; ++i)
+            {
+                valueToTest += (i % 10).ToString();
+            }
+
+            var fixedStringValue = new FixedString512Bytes(valueToTest);
+
+            RunFixedStringTest(fixedStringValue, numBytesWritten, writeType);
+        }
+
+        [TestCase(3, WriteType.WriteDirect)]
+        [TestCase(5, WriteType.WriteSafe)]
+        [TestCase(16, WriteType.WriteDirect)]
+        [TestCase(29, WriteType.WriteSafe)]
+        [TestCase(61, WriteType.WriteSafe)]
+        [TestCase(125, WriteType.WriteSafe)]
+        [TestCase(509, WriteType.WriteSafe)]
+        [TestCase(4093, WriteType.WriteSafe)]
+        public void WhenReadingFixedString4096Bytes_ValueIsReadCorrectly(int numBytesWritten, WriteType writeType)
+        {
+            // Repeats 01234567890123456789...
+            string valueToTest = "";
+            for (var i = 0; i < 4093; ++i)
+            {
+                valueToTest += (i % 10).ToString();
+            }
+
+            var fixedStringValue = new FixedString4096Bytes(valueToTest);
+
+            RunFixedStringTest(fixedStringValue, numBytesWritten, writeType);
+        }
+
        [TestCase(false, WriteType.WriteDirect)]
        [TestCase(false, WriteType.WriteSafe)]
        [TestCase(true, WriteType.WriteDirect)]
--- a/Tests/Editor/Serialization/FastBufferWriterTests.cs
+++ b/Tests/Editor/Serialization/FastBufferWriterTests.cs
@@ -257,8 +257,9 @@ namespace Unity.Netcode.EditorTests
            [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), typeof(TestStruct))]
+                typeof(UIntEnum), typeof(LongEnum), typeof(ULongEnum), typeof(Vector2), typeof(Vector3),
+                typeof(Vector2Int), typeof(Vector3Int), typeof(Vector4), typeof(Quaternion), typeof(Color),
+                typeof(Color32), typeof(Ray), typeof(Ray2D), typeof(TestStruct))]
            Type testType,
            [Values] WriteType writeType)
        {
@@ -270,8 +271,9 @@ namespace Unity.Netcode.EditorTests
            [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), typeof(TestStruct))]
+                typeof(UIntEnum), typeof(LongEnum), typeof(ULongEnum), typeof(Vector2), typeof(Vector3),
+                typeof(Vector2Int), typeof(Vector3Int), typeof(Vector4), typeof(Quaternion), typeof(Color),
+                typeof(Color32), typeof(Ray), typeof(Ray2D), typeof(TestStruct))]
            Type testType,
            [Values] WriteType writeType)
        {
@@ -336,6 +338,147 @@ namespace Unity.Netcode.EditorTests
            }
        }

+        public unsafe void RunFixedStringTest<T>(T fixedStringValue, int numBytesWritten, WriteType writeType) where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            fixedStringValue.Length = numBytesWritten;
+
+            var serializedValueSize = FastBufferWriter.GetWriteSize(fixedStringValue);
+
+            Assert.AreEqual(fixedStringValue.Length + sizeof(int), serializedValueSize);
+
+            var writer = new FastBufferWriter(serializedValueSize + 3, Allocator.Temp);
+            using (writer)
+            {
+                var offset = 0;
+                switch (writeType)
+                {
+                    case WriteType.WriteDirect:
+                        Assert.IsTrue(writer.TryBeginWrite(serializedValueSize + 2), "Writer denied write permission");
+                        writer.WriteValue(fixedStringValue);
+                        break;
+                    case WriteType.WriteSafe:
+                        writer.WriteValueSafe(fixedStringValue);
+                        break;
+
+                }
+
+                VerifyPositionAndLength(writer, serializedValueSize + offset);
+                WriteCheckBytes(writer, serializedValueSize + offset);
+
+                int* sizeValue = (int*)(writer.GetUnsafePtr() + offset);
+                Assert.AreEqual(fixedStringValue.Length, *sizeValue);
+
+                byte* underlyingByteArray = writer.GetUnsafePtr() + sizeof(int) + offset;
+                for (var i = 0; i < fixedStringValue.Length; ++i)
+                {
+                    Assert.AreEqual(fixedStringValue[i], underlyingByteArray[i]);
+                }
+
+                var underlyingArray = writer.ToArray();
+                VerifyCheckBytes(underlyingArray, serializedValueSize + offset);
+            }
+        }
+
+        [TestCase(3, WriteType.WriteDirect)]
+        [TestCase(5, WriteType.WriteSafe)]
+        [TestCase(16, WriteType.WriteDirect)]
+        [TestCase(29, WriteType.WriteSafe)]
+        public void WhenWritingFixedString32Bytes_ValueIsWrittenCorrectly(int numBytesWritten, WriteType writeType)
+        {
+            // Repeats 01234567890123456789...
+            string valueToTest = "";
+            for (var i = 0; i < 29; ++i)
+            {
+                valueToTest += (i % 10).ToString();
+            }
+
+            var fixedStringValue = new FixedString32Bytes(valueToTest);
+
+            RunFixedStringTest(fixedStringValue, numBytesWritten, writeType);
+        }
+
+        [TestCase(3, WriteType.WriteDirect)]
+        [TestCase(5, WriteType.WriteSafe)]
+        [TestCase(16, WriteType.WriteDirect)]
+        [TestCase(29, WriteType.WriteSafe)]
+        [TestCase(61, WriteType.WriteSafe)]
+        public void WhenWritingFixedString64Bytes_ValueIsWrittenCorrectly(int numBytesWritten, WriteType writeType)
+        {
+            // Repeats 01234567890123456789...
+            string valueToTest = "";
+            for (var i = 0; i < 61; ++i)
+            {
+                valueToTest += (i % 10).ToString();
+            }
+
+            var fixedStringValue = new FixedString64Bytes(valueToTest);
+
+            RunFixedStringTest(fixedStringValue, numBytesWritten, writeType);
+        }
+
+        [TestCase(3, WriteType.WriteDirect)]
+        [TestCase(5, WriteType.WriteSafe)]
+        [TestCase(16, WriteType.WriteDirect)]
+        [TestCase(29, WriteType.WriteSafe)]
+        [TestCase(61, WriteType.WriteSafe)]
+        [TestCase(125, WriteType.WriteSafe)]
+        public void WhenWritingFixedString128Bytes_ValueIsWrittenCorrectly(int numBytesWritten, WriteType writeType)
+        {
+            // Repeats 01234567890123456789...
+            string valueToTest = "";
+            for (var i = 0; i < 125; ++i)
+            {
+                valueToTest += (i % 10).ToString();
+            }
+
+            var fixedStringValue = new FixedString128Bytes(valueToTest);
+
+            RunFixedStringTest(fixedStringValue, numBytesWritten, writeType);
+        }
+
+        [TestCase(3, WriteType.WriteDirect)]
+        [TestCase(5, WriteType.WriteSafe)]
+        [TestCase(16, WriteType.WriteDirect)]
+        [TestCase(29, WriteType.WriteSafe)]
+        [TestCase(61, WriteType.WriteSafe)]
+        [TestCase(125, WriteType.WriteSafe)]
+        [TestCase(509, WriteType.WriteSafe)]
+        public void WhenWritingFixedString512Bytes_ValueIsWrittenCorrectly(int numBytesWritten, WriteType writeType)
+        {
+            // Repeats 01234567890123456789...
+            string valueToTest = "";
+            for (var i = 0; i < 509; ++i)
+            {
+                valueToTest += (i % 10).ToString();
+            }
+
+            var fixedStringValue = new FixedString512Bytes(valueToTest);
+
+            RunFixedStringTest(fixedStringValue, numBytesWritten, writeType);
+        }
+
+        [TestCase(3, WriteType.WriteDirect)]
+        [TestCase(5, WriteType.WriteSafe)]
+        [TestCase(16, WriteType.WriteDirect)]
+        [TestCase(29, WriteType.WriteSafe)]
+        [TestCase(61, WriteType.WriteSafe)]
+        [TestCase(125, WriteType.WriteSafe)]
+        [TestCase(509, WriteType.WriteSafe)]
+        [TestCase(4093, WriteType.WriteSafe)]
+        public void WhenWritingFixedString4096Bytes_ValueIsWrittenCorrectly(int numBytesWritten, WriteType writeType)
+        {
+            // Repeats 01234567890123456789...
+            string valueToTest = "";
+            for (var i = 0; i < 4093; ++i)
+            {
+                valueToTest += (i % 10).ToString();
+            }
+
+            var fixedStringValue = new FixedString4096Bytes(valueToTest);
+
+            RunFixedStringTest(fixedStringValue, numBytesWritten, writeType);
+        }
+
        [TestCase(1, 0)]
        [TestCase(2, 0)]
        [TestCase(3, 0)]