using System;
using System.Collections.Generic;
using System.IO;
using Mirror.Tests.RemoteAttrributeTest;
using NUnit.Framework;
using UnityEngine;

namespace Mirror.Tests
{
    [TestFixture]
    public class NetworkWriterTest : MirrorEditModeTest
    {
        [SetUp]
        public override void SetUp()
        {
            base.SetUp();

            // start server & connect client because we need spawn functions
            NetworkServer.Listen(1);
            ConnectClientBlockingAuthenticatedAndReady(out _);
        }

        /* uncomment if needed. commented for faster test workflow. this takes >3s.
        [Test]
        public void Benchmark()
        {
            // 10 million reads, Unity 2019.3, code coverage disabled
            //    4014ms ms
            NetworkWriter writer = new NetworkWriter();
            for (int i = 0; i < 10000000; ++i)
            {
                writer.SetLength(0);
                writer.WriteVector3(new Vector3(1, 2, 3));
            }
        }
        */

        // Write/ReadBlittable assumes same endianness on server & client.
        [Test]
        public void LittleEndianPlatform()
        {
            Assert.That(BitConverter.IsLittleEndian, Is.True);
        }

        // some platforms may not support unaligned *(T*) reads/writes.
        // but it still needs to work with our workaround.
        // let's have an editor test to maybe catch it early.
        // Editor runs Win/Mac/Linux and atm the issue only exists on Android,
        // but let's have a test anyway.
        // see also: https://github.com/vis2k/Mirror/issues/3044
        [Test]
        public void WriteUnaligned()
        {
            NetworkWriter writer = new NetworkWriter();
            // make unaligned
            writer.WriteByte(0xFF);
            // write a double
            writer.WriteDouble(Math.PI);
            // should have written 9 bytes without throwing exceptions
            Assert.That(writer.Position, Is.EqualTo(9));
        }

        [Test]
        public void TestWritingSmallMessage()
        {
            // try serializing less than 32kb and see what happens
            NetworkWriter writer = new NetworkWriter();
            for (int i = 0; i < 30000 / 4; ++i)
                writer.WriteInt(i);
            Assert.That(writer.Position, Is.EqualTo(30000));
        }

        [Test]
        public void TestWritingLargeMessage()
        {
            // try serializing more than 32kb and see what happens
            NetworkWriter writer = new NetworkWriter();
            for (int i = 0; i < 40000 / 4; ++i)
                writer.WriteInt(i);
            Assert.That(writer.Position, Is.EqualTo(40000));
        }

        [Test]
        public void TestWritingHugeArray()
        {
            // try serializing array more than 64KB large and see what happens
            NetworkWriter writer = new NetworkWriter();
            writer.WriteBytesAndSize(new byte[100000]);
            byte[] data = writer.ToArray();

            NetworkReader reader = new NetworkReader(data);
            byte[] deserialized = reader.ReadBytesAndSize();
            Assert.That(deserialized.Length, Is.EqualTo(100000));
        }

        [Test]
        public void TestWritingBytesSegment()
        {
            byte[] data = { 1, 2, 3 };
            NetworkWriter writer = new NetworkWriter();
            writer.WriteBytes(data, 0, data.Length);

            NetworkReader reader = new NetworkReader(writer.ToArray());
            ArraySegment<byte> deserialized = reader.ReadBytesSegment(data.Length);
            Assert.That(deserialized.Count, Is.EqualTo(data.Length));
            for (int i = 0; i < data.Length; ++i)
                Assert.That(deserialized.Array[deserialized.Offset + i], Is.EqualTo(data[i]));
        }

        // write byte[], read segment
        [Test]
        public void TestWritingBytesAndReadingSegment()
        {
            byte[] data = { 1, 2, 3 };
            NetworkWriter writer = new NetworkWriter();
            writer.WriteBytesAndSize(data);

            NetworkReader reader = new NetworkReader(writer.ToArray());
            ArraySegment<byte> deserialized = reader.ReadBytesAndSizeSegment();
            Assert.That(deserialized.Count, Is.EqualTo(data.Length));
            for (int i = 0; i < data.Length; ++i)
                Assert.That(deserialized.Array[deserialized.Offset + i], Is.EqualTo(data[i]));
        }

        // write segment, read segment
        [Test]
        public void TestWritingSegmentAndReadingSegment()
        {
            byte[] data = { 1, 2, 3, 4 };
            // [2, 3]
            ArraySegment<byte> segment = new ArraySegment<byte>(data, 1, 1);
            NetworkWriter writer = new NetworkWriter();
            writer.WriteBytesAndSizeSegment(segment);

            NetworkReader reader = new NetworkReader(writer.ToArray());
            ArraySegment<byte> deserialized = reader.ReadBytesAndSizeSegment();
            Assert.That(deserialized.Count, Is.EqualTo(segment.Count));
            for (int i = 0; i < segment.Count; ++i)
                Assert.That(deserialized.Array[deserialized.Offset + i], Is.EqualTo(segment.Array[segment.Offset + i]));
        }

        [Test]
        public void TestResetSetsPotionAndLength()
        {
            NetworkWriter writer = new NetworkWriter();
            writer.WriteString("I saw");
            writer.WriteLong(0xA_FADED_DEAD_EEL);
            writer.WriteString("and ate it");
            writer.Reset();

            Assert.That(writer.Position, Is.EqualTo(0));

            byte[] data = writer.ToArray();
            Assert.That(data, Is.Empty);
        }

        [Test]
        public void TestReading0LengthBytesAndSize()
        {
            NetworkWriter writer = new NetworkWriter();
            writer.WriteBytesAndSize(new byte[] {});
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Assert.That(reader.ReadBytesAndSize().Length, Is.EqualTo(0));
        }

        [Test]
        public void TestReading0LengthBytes()
        {
            NetworkWriter writer = new NetworkWriter();
            writer.WriteBytes(new byte[] {}, 0, 0);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Assert.That(reader.ReadBytes(0).Length, Is.EqualTo(0));
        }

        [Test]
        public void TestWritingNegativeBytesAndSizeFailure()
        {
            NetworkWriter writer = new NetworkWriter();
            Assert.Throws<OverflowException>(() => writer.WriteBytesAndSize(new byte[0], 0, -1));
            Assert.That(writer.Position, Is.EqualTo(0));
        }

        [Test]
        public void TestReadingTooMuch()
        {
            void EnsureThrows(Action<NetworkReader> read, byte[] data = null)
            {
                Assert.Throws<System.IO.EndOfStreamException>(() => read(new NetworkReader(data ?? new byte[] {})));
            }
            // Try reading more than there is data to be read from
            // This should throw EndOfStreamException always
            EnsureThrows(r => r.ReadByte());
            EnsureThrows(r => r.ReadSByte());
            EnsureThrows(r => r.ReadChar());
            EnsureThrows(r => r.ReadBool());
            EnsureThrows(r => r.ReadShort());
            EnsureThrows(r => r.ReadUShort());
            EnsureThrows(r => r.ReadInt());
            EnsureThrows(r => r.ReadUInt());
            EnsureThrows(r => r.ReadLong());
            EnsureThrows(r => r.ReadULong());
            EnsureThrows(r => r.ReadDecimal());
            EnsureThrows(r => r.ReadFloat());
            EnsureThrows(r => r.ReadDouble());
            EnsureThrows(r => r.ReadString());
            EnsureThrows(r => r.ReadBytes(1));
            EnsureThrows(r => r.ReadBytes(2));
            EnsureThrows(r => r.ReadBytes(3));
            EnsureThrows(r => r.ReadBytes(4));
            EnsureThrows(r => r.ReadBytes(8));
            EnsureThrows(r => r.ReadBytes(16));
            EnsureThrows(r => r.ReadBytes(32));
            EnsureThrows(r => r.ReadBytes(100));
            EnsureThrows(r => r.ReadBytes(1000));
            EnsureThrows(r => r.ReadBytes(10000));
            EnsureThrows(r => r.ReadBytes(1000000));
            EnsureThrows(r => r.ReadBytes(10000000));
            EnsureThrows(r => r.ReadBytesAndSize());
            EnsureThrows(r => r.ReadVector2());
            EnsureThrows(r => r.ReadVector3());
            EnsureThrows(r => r.ReadVector4());
            EnsureThrows(r => r.ReadVector2Int());
            EnsureThrows(r => r.ReadVector3Int());
            EnsureThrows(r => r.ReadColor());
            EnsureThrows(r => r.ReadColor32());
            EnsureThrows(r => r.ReadQuaternion());
            EnsureThrows(r => r.ReadRect());
            EnsureThrows(r => r.ReadPlane());
            EnsureThrows(r => r.ReadRay());
            EnsureThrows(r => r.ReadMatrix4x4());
            EnsureThrows(r => r.ReadGuid());
        }

        [Test]
        public void TestBool()
        {
            bool[] inputs = { true, false };
            foreach (bool input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteBool(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                bool output = reader.ReadBool();
                Assert.That(output, Is.EqualTo(input));
            }
        }

        [Test]
        public void TestBoolNullable()
        {
            bool? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteBoolNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            bool? output = reader.ReadBoolNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestByte()
        {
            byte[] inputs = { 1, 2, 3, 4 };
            foreach (byte input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteByte(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                byte output = reader.ReadByte();
                Assert.That(output, Is.EqualTo(input));
            }
        }

        [Test]
        public void TestByteNullable()
        {
            byte? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteByteNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            byte? output = reader.ReadByteNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestSByte()
        {
            sbyte[] inputs = { 1, 2, 3, 4 };
            foreach (sbyte input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteSByte(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                sbyte output = reader.ReadSByte();
                Assert.That(output, Is.EqualTo(input));
            }
        }

        [Test]
        public void TestSByteNullable()
        {
            sbyte? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteSByteNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            sbyte? output = reader.ReadSByteNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestVector2()
        {
            Vector2[] inputs = {
                Vector2.right,
                Vector2.up,
                Vector2.zero,
                Vector2.one,
                Vector2.positiveInfinity,
                new Vector2(0.1f,3.1f)
            };
            foreach (Vector2 input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteVector2(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                Vector2 output = reader.ReadVector2();
                Assert.That(output, Is.EqualTo(input));
            }
        }

        [Test]
        public void TestVector2Nullable()
        {
            Vector2? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteVector2Nullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Vector2? output = reader.ReadVector2Nullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestVector3()
        {
            Vector3[] inputs = {
                Vector3.right,
                Vector3.up,
                Vector3.zero,
                Vector3.one,
                Vector3.positiveInfinity,
                Vector3.forward,
                new Vector3(0.1f,3.1f,1.4f)
            };
            foreach (Vector3 input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteVector3(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                Vector3 output = reader.ReadVector3();
                Assert.That(output, Is.EqualTo(input));
            }
        }

        [Test]
        public void TestVector3Nullable()
        {
            Vector3? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteVector3Nullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Vector3? output = reader.ReadVector3Nullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestVector4()
        {
            Vector4[] inputs = {
                Vector3.right,
                Vector3.up,
                Vector4.zero,
                Vector4.one,
                Vector4.positiveInfinity,
                new Vector4(0.1f,3.1f,1.4f,4.9f)
            };
            foreach (Vector4 input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteVector4(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                Vector4 output = reader.ReadVector4();
                Assert.That(output, Is.EqualTo(input));
            }
        }

        [Test]
        public void TestVector4Nullable()
        {
            Vector4? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteVector4Nullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Vector4? output = reader.ReadVector4Nullable();
            Assert.That(output, Is.EqualTo(output));
        }

        [Test]
        public void TestVector2Int()
        {
            Vector2Int[] inputs = {
                Vector2Int.down,
                Vector2Int.up,
                Vector2Int.left,
                Vector2Int.zero,
                new Vector2Int(-1023,-999999),
                new Vector2Int(257,12345),
                new Vector2Int(0x7fffffff,-12345),
            };
            foreach (Vector2Int input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteVector2Int(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                Vector2Int output = reader.ReadVector2Int();
                Assert.That(output, Is.EqualTo(input));
            }
        }

        [Test]
        public void TestVector2IntNullable()
        {
            Vector2Int? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteVector2IntNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Vector2Int? output = reader.ReadVector2IntNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestVector3Int()
        {
            Vector3Int[] inputs = {
                Vector3Int.down,
                Vector3Int.up,
                Vector3Int.left,
                Vector3Int.one,
                Vector3Int.zero,
                new Vector3Int(-1023,-999999,1392),
                new Vector3Int(257,12345,-6132),
                new Vector3Int(0x7fffffff,-12345,-1),
            };
            foreach (Vector3Int input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteVector3Int(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                Vector3Int output = reader.ReadVector3Int();
                Assert.That(output, Is.EqualTo(input));
            }
        }

        [Test]
        public void TestVector3IntNullable()
        {
            Vector3Int? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteVector3IntNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Vector3Int? output = reader.ReadVector3IntNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestColor()
        {
            Color[] inputs = {
                Color.black,
                Color.blue,
                Color.cyan,
                Color.yellow,
                Color.magenta,
                Color.white,
                new Color(0.401f,0.2f,1.0f,0.123f)
            };
            foreach (Color input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteColor(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                Color output = reader.ReadColor();
                Assert.That(output, Is.EqualTo(input));
            }
        }

        [Test]
        public void TestColorNullable()
        {
            Color? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteColorNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Color? output = reader.ReadColorNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestColor32()
        {
            Color32[] inputs = {
                Color.black,
                Color.blue,
                Color.cyan,
                Color.yellow,
                Color.magenta,
                Color.white,
                new Color32(0xab,0xcd,0xef,0x12),
                new Color32(125,126,0,255)
            };
            foreach (Color32 input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteColor32(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                Color32 output = reader.ReadColor32();
                Assert.That(output, Is.EqualTo(input));
            }
        }

        [Test]
        public void TestColor32Nullable()
        {
            Color32? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteColor32Nullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Color32? output = reader.ReadColor32Nullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestQuaternion()
        {
            Quaternion[] inputs = {
                Quaternion.identity,
                default,
                Quaternion.LookRotation(new Vector3(0.3f,0.4f,0.5f)),
                Quaternion.Euler(45f,56f,Mathf.PI)
            };
            foreach (Quaternion input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteQuaternion(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                Quaternion output = reader.ReadQuaternion();
                Assert.That(output, Is.EqualTo(input));
            }
        }

        [Test]
        public void TestQuaternionNullable()
        {
            Quaternion? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteQuaternionNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Quaternion? output = reader.ReadQuaternionNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestRect()
        {
            Rect[] inputs = {
                Rect.zero,
                new Rect(1004.1f,2.001f,4636,400f),
                new Rect(-100.622f,-200f,300f,975.6f),
                new Rect(-100f,435,-30.04f,400f),
                new Rect(55,-200f,-44,-123),
            };
            foreach (Rect input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteRect(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                Rect output = reader.ReadRect();
                Assert.That(output, Is.EqualTo(input));
            }
        }

        [Test]
        public void TestRectNullable()
        {
            Rect? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteRectNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Rect? output = reader.ReadRectNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestPlane()
        {
            Plane[] inputs = {
                new Plane(new Vector3(-0.24f,0.34f,0.2f), 120.2f),
                new Plane(new Vector3(0.133f,0.34f,0.122f), -10.135f),
                new Plane(new Vector3(0.133f,-0.0f,float.MaxValue), -13.3f),
                new Plane(new Vector3(0.1f,-0.2f,0.3f), 14.5f),
            };
            foreach (Plane input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WritePlane(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                Plane output = reader.ReadPlane();
                // note: Plane constructor does math internally, resulting in
                // floating point precision loss that causes exact comparison
                // to fail the test. So we test that the difference is small.
                Assert.That((output.normal - input.normal).magnitude, Is.LessThan(1e-6f));
                Assert.That(output.distance, Is.EqualTo(input.distance));
            }
        }

        [Test]
        public void TestPlaneNullable()
        {
            Plane? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WritePlaneNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Plane? output = reader.ReadPlaneNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestRay()
        {
            Ray[] inputs = {
                new Ray(Vector3.up,Vector3.down),
                new Ray(new Vector3(0.1f,0.2f,0.3f), new Vector3(0.4f,0.5f,0.6f)),
                new Ray(new Vector3(-0.3f,0.5f,0.999f), new Vector3(1f,100.1f,20f)),
            };
            foreach (Ray input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteRay(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                Ray output = reader.ReadRay();
                Assert.That((output.direction - input.direction).magnitude, Is.LessThan(1e-6f));
                Assert.That(output.origin, Is.EqualTo(input.origin));
            }
        }

        [Test]
        public void TestRayNullable()
        {
            Ray? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteRayNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Ray? output = reader.ReadRayNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestMatrix4x4()
        {
            Matrix4x4[] inputs = {
                Matrix4x4.identity,
                Matrix4x4.zero,
                Matrix4x4.Scale(Vector3.one * 0.12345f),
                Matrix4x4.LookAt(Vector2.up,Vector3.right,Vector3.forward),
                Matrix4x4.Rotate(Quaternion.LookRotation(Vector3.one)),
            };
            foreach (Matrix4x4 input in inputs)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteMatrix4x4(input);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                Matrix4x4 output = reader.ReadMatrix4x4();
                Assert.That(output, Is.EqualTo(input));
            }
        }

        [Test]
        public void TestMatrix4x4Nullable()
        {
            Matrix4x4? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteMatrix4x4Nullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Matrix4x4? output = reader.ReadMatrix4x4Nullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestReadingInvalidString()
        {
            // These are all bytes which never show up in valid UTF8 encodings.
            // NetworkReader should gracefully handle maliciously crafted input.
            byte[] invalidUTF8bytes = {
                0xC0, 0xC1, 0xF5, 0xF6,
                0xF7, 0xF8, 0xF9, 0xFA,
                0xFB, 0xFC, 0xFD, 0xFE,
                0xFF,
            };
            foreach (byte invalid in invalidUTF8bytes)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteString("an uncorrupted string");
                byte[] data = writer.ToArray();
                data[10] = invalid;
                NetworkReader reader = new NetworkReader(data);
                Assert.Throws<System.Text.DecoderFallbackException>(() => reader.ReadString());
            }
        }

        [Test]
        public void TestReadingTruncatedString()
        {
            NetworkWriter writer = new NetworkWriter();
            writer.WriteString("a string longer than 10 bytes");
            writer.Reset();
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Assert.Throws<System.IO.EndOfStreamException>(() => reader.ReadString());
        }

        [Test]
        public void TestToArray()
        {
            // write 2 bytes
            NetworkWriter writer = new NetworkWriter();
            writer.WriteByte(1);
            writer.WriteByte(2);

            // .ToArray() length is 2?
            Assert.That(writer.ToArray().Length, Is.EqualTo(2));

            // set position back by one
            writer.Position = 1;

            // Changing the position alter the size of the data
            Assert.That(writer.ToArray().Length, Is.EqualTo(1));
        }

        [Test]
        public void TestToArraySegment()
        {
            NetworkWriter writer = new NetworkWriter();
            writer.WriteString("hello");
            writer.WriteString("world");

            NetworkReader reader = new NetworkReader(writer.ToArraySegment());
            Assert.That(reader.ReadString(), Is.EqualTo("hello"));
            Assert.That(reader.ReadString(), Is.EqualTo("world"));
        }

        // sometimes we may serialize nothing, then call ToArraySegment.
        // make sure this works even if empty.
        [Test]
        public void TestToArraySegment_EmptyContent()
        {
            NetworkWriter writer = new NetworkWriter();
            ArraySegment<byte> segment = writer.ToArraySegment();
            Assert.That(segment.Count, Is.EqualTo(0));
        }

        [Test]
        public void TestChar()
        {
            char a = 'a';
            char u = 'ⓤ';

            NetworkWriter writer = new NetworkWriter();
            writer.WriteChar(a);
            writer.WriteChar(u);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            char a2 = reader.ReadChar();
            Assert.That(a2, Is.EqualTo(a));
            char u2 = reader.ReadChar();
            Assert.That(u2, Is.EqualTo(u));
        }

        [Test]
        public void TestCharNullable()
        {
            char? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteCharNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            char? output = reader.ReadCharNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestUnicodeString()
        {
            string[] weirdUnicode = {
                "𝔲𝔫𝔦𝔠𝔬𝔡𝔢 𝔱𝔢𝔰𝔱",
                "𝖚𝖓𝖎𝖈𝖔𝖉𝖊 𝖙𝖊𝖘𝖙",
                "𝐮𝐧𝐢𝐜𝐨𝐝𝐞 𝐭𝐞𝐬𝐭",
                "𝘶𝘯𝘪𝘤𝘰𝘥𝘦 𝘵𝘦𝘴𝘵",
                "𝙪𝙣𝙞𝙘𝙤𝙙𝙚 𝙩𝙚𝙨𝙩",
                "𝚞𝚗𝚒𝚌𝚘𝚍𝚎 𝚝𝚎𝚜𝚝",
                "𝓊𝓃𝒾𝒸𝑜𝒹𝑒 𝓉𝑒𝓈𝓉",
                "𝓾𝓷𝓲𝓬𝓸𝓭𝓮 𝓽𝓮𝓼𝓽",
                "𝕦𝕟𝕚𝕔𝕠𝕕𝕖 𝕥𝕖𝕤𝕥",
                "ЦПIᄃӨDΣ ƬΣƧƬ",
                "ㄩ几丨匚ㄖᗪ乇 ㄒ乇丂ㄒ",
                "ひ刀ﾉᄃのり乇 ｲ乇丂ｲ",
                "Ʉ₦ł₵ØĐɆ ₮Ɇ₴₮",
                "ｕｎｉｃｏｄｅ ｔｅｓｔ",
                "ᴜɴɪᴄᴏᴅᴇ ᴛᴇꜱᴛ",
                "ʇsǝʇ ǝpoɔıun",
                "ยภเς๏๔є ՇєรՇ",
                "ᑘᘉᓰᑢᓍᕲᘿ ᖶᘿSᖶ",
                "υɳιƈσԃҽ ƚҽʂƚ",
                "ʊռɨƈօɖɛ ȶɛֆȶ",
                "🆄🅽🅸🅲🅾🅳🅴 🆃🅴🆂🆃",
                "ⓤⓝⓘⓒⓞⓓⓔ ⓣⓔⓢⓣ",
                "̶̝̳̥͈͖̝͌̈͛̽͊̏̚͠",
                // test control codes
                "\r\n", "\n", "\r", "\t",
                "\\", "\"", "\'",
                "\u0000\u0001\u0002\u0003",
                "\u0004\u0005\u0006\u0007",
                "\u0008\u0009\u000A\u000B",
                "\u000C\u000D\u000E\u000F",
                // test invalid bytes as characters
                "\u00C0\u00C1\u00F5\u00F6",
                "\u00F7\u00F8\u00F9\u00FA",
                "\u00FB\u00FC\u00FD\u00FE",
                "\u00FF",
            };
            foreach (string weird in weirdUnicode)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteString(weird);
                byte[] data = writer.ToArray();
                NetworkReader reader = new NetworkReader(data);
                string str = reader.ReadString();
                Assert.That(str, Is.EqualTo(weird));
            }
        }

        [Test]
        public void TestGuid()
        {
            Guid originalGuid = new Guid("0123456789abcdef9876543210fedcba");
            NetworkWriter writer = new NetworkWriter();
            writer.WriteGuid(originalGuid);

            NetworkReader reader = new NetworkReader(writer.ToArray());
            Guid readGuid = reader.ReadGuid();
            Assert.That(readGuid, Is.EqualTo(originalGuid));
        }

        [Test]
        public void TestGuidNullable()
        {
            Guid? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteGuidNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            Guid? output = reader.ReadGuidNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestFloats()
        {
            float[] weirdFloats = {
                0f,
                -0f,
                float.Epsilon,
                -float.Epsilon,
                float.MaxValue,
                float.MinValue,
                float.NaN,
                -float.NaN,
                float.PositiveInfinity,
                float.NegativeInfinity,
                (float) double.MaxValue,
                (float) double.MinValue,
                (float) decimal.MaxValue,
                (float) decimal.MinValue,
                (float) Math.PI,
                (float) Math.E
            };
            foreach (float weird in weirdFloats)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteFloat(weird);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                float readFloat = reader.ReadFloat();
                Assert.That(readFloat, Is.EqualTo(weird));
            }
        }

        [Test]
        public void TestFloatNullable()
        {
            float? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteFloatNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            float? output = reader.ReadFloatNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestDoubles()
        {
            double[] weirdDoubles = {
                0d,
                -0d,
                double.Epsilon,
                -double.Epsilon,
                double.MaxValue,
                double.MinValue,
                double.NaN,
                -double.NaN,
                double.PositiveInfinity,
                double.NegativeInfinity,
                float.MaxValue,
                float.MinValue,
                (double) decimal.MaxValue,
                (double) decimal.MinValue,
                Math.PI,
                Math.E
            };
            foreach (double weird in weirdDoubles)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteDouble(weird);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                double readDouble = reader.ReadDouble();
                Assert.That(readDouble, Is.EqualTo(weird));
            }
        }

        [Test]
        public void TestDoubleNullable()
        {
            double? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteDoubleNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            double? output = reader.ReadDoubleNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestDecimals()
        {
            decimal[] weirdDecimals = {
                decimal.Zero,
                -decimal.Zero,
                decimal.MaxValue,
                decimal.MinValue,
                (decimal) Math.PI,
                (decimal) Math.E
            };
            foreach (decimal weird in weirdDecimals)
            {
                NetworkWriter writer = new NetworkWriter();
                writer.WriteDecimal(weird);
                NetworkReader reader = new NetworkReader(writer.ToArray());
                decimal readDecimal = reader.ReadDecimal();
                Assert.That(readDecimal, Is.EqualTo(weird));
            }
        }

        [Test]
        public void TestDecimalNullable()
        {
            decimal? input = null;
            NetworkWriter writer = new NetworkWriter();
            writer.WriteDecimalNullable(input);
            NetworkReader reader = new NetworkReader(writer.ToArray());
            decimal? output = reader.ReadDecimalNullable();
            Assert.That(output, Is.EqualTo(input));
        }

        [Test]
        public void TestFloatBinaryCompatibility()
        {
            float[] weirdFloats = {
                ((float) Math.PI) / 3.0f,
                ((float) Math.E) / 3.0f
            };
            byte[] expected = {
                146, 10,134, 63,
                197,245,103, 63,
            };
            NetworkWriter writer = new NetworkWriter();
            foreach (float weird in weirdFloats)
            {
                writer.WriteFloat(weird);
            }
            Assert.That(writer.ToArray(), Is.EqualTo(expected));
        }

        [Test]
        public void TestDoubleBinaryCompatibility()
        {
            double[] weirdDoubles = {
                Math.PI / 3.0d,
                Math.E / 3.0d
            };
            byte[] expected = {
                101,115, 45, 56, 82,193,240, 63,
                140,116,112,185,184,254,236, 63,
            };
            NetworkWriter writer = new NetworkWriter();
            foreach (double weird in weirdDoubles)
            {
                writer.WriteDouble(weird);
            }
            Assert.That(writer.ToArray(), Is.EqualTo(expected));
        }

        [Test]
        public void TestDecimalBinaryCompatibility()
        {
            decimal[] weirdDecimals = {
                ((decimal) Math.PI) / 3.0m,
                ((decimal) Math.E) / 3.0m
            };
            byte[] expected = {
                0x00, 0x00, 0x1C, 0x00, 0x12, 0x37, 0xD6, 0x21, 0xAB, 0xEA,
                0x84, 0x0A, 0x5B, 0x5E, 0xB1, 0x03, 0x00, 0x00, 0x0E, 0x00,
                0x00, 0x00, 0x00, 0x00, 0xF0, 0x6D, 0xC2, 0xA4, 0x68, 0x52,
                0x00, 0x00
            };
            NetworkWriter writer = new NetworkWriter();
            foreach (decimal weird in weirdDecimals)
            {
                writer.WriteDecimal(weird);
            }
            //Debug.Log(BitConverter.ToString(writer.ToArray()));
            Assert.That(writer.ToArray(), Is.EqualTo(expected));
        }

        [Test]
        public void TestByteEndianness()
        {
            byte[] values = { 0x12, 0x43, 0x00, 0xff, 0xab, 0x02, 0x20 };
            byte[] expected = { 0x12, 0x43, 0x00, 0xff, 0xab, 0x02, 0x20 };
            NetworkWriter writer = new NetworkWriter();
            foreach (byte value in values)
            {
                writer.WriteByte(value);
            }
            Assert.That(writer.ToArray(), Is.EqualTo(expected));
        }

        [Test]
        public void TestUShortEndianness()
        {
            ushort[] values = { 0x0000, 0x1234, 0xabcd, 0xF00F, 0x0FF0, 0xbeef };
            byte[] expected = { 0x00, 0x00, 0x34, 0x12, 0xcd, 0xab, 0x0F, 0xF0, 0xF0, 0x0F, 0xef, 0xbe };
            NetworkWriter writer = new NetworkWriter();
            foreach (ushort value in values)
            {
                writer.WriteUShort(value);
            }
            Assert.That(writer.ToArray(), Is.EqualTo(expected));
        }

        [Test]
        public void TestUIntEndianness()
        {
            uint[] values = { 0x12345678, 0xabcdef09, 0xdeadbeef };
            byte[] expected = { 0x78, 0x56, 0x34, 0x12, 0x09, 0xef, 0xcd, 0xab, 0xef, 0xbe, 0xad, 0xde };
            NetworkWriter writer = new NetworkWriter();
            foreach (uint value in values)
            {
                writer.WriteUInt(value);
            }
            Assert.That(writer.ToArray(), Is.EqualTo(expected));
        }

        [Test]
        public void TestULongEndianness()
        {
            ulong[] values = { 0x0123456789abcdef, 0xdeaded_beef_c0ffee };
            byte[] expected = { 0xef, 0xcd, 0xab, 0x89, 0x67, 0x45, 0x23, 0x01, 0xee, 0xff, 0xc0, 0xef, 0xbe, 0xed, 0xad, 0xde };
            NetworkWriter writer = new NetworkWriter();
            foreach (ulong value in values)
            {
                writer.WriteULong(value);
            }
            Assert.That(writer.ToArray(), Is.EqualTo(expected));
        }

        [Test]
        public void TestSbyteEndianness()
        {
            byte[] values = { 0x12, 0x43, 0x00, 0xff, 0xab, 0x02, 0x20 };
            byte[] expected = { 0x12, 0x43, 0x00, 0xff, 0xab, 0x02, 0x20 };
            NetworkWriter writer = new NetworkWriter();
            foreach (byte value in values)
            {
                writer.WriteSByte((sbyte)value);
            }
            Assert.That(writer.ToArray(), Is.EqualTo(expected));
        }

        [Test]
        public void TestShortEndianness()
        {
            ushort[] values = { 0x0000, 0x1234, 0xabcd, 0xF00F, 0x0FF0, 0xbeef };
            byte[] expected = { 0x00, 0x00, 0x34, 0x12, 0xcd, 0xab, 0x0F, 0xF0, 0xF0, 0x0F, 0xef, 0xbe };
            NetworkWriter writer = new NetworkWriter();
            foreach (ushort value in values)
            {
                writer.WriteShort((short)value);
            }
            Assert.That(writer.ToArray(), Is.EqualTo(expected));
        }

        [Test]
        public void TestIntEndianness()
        {
            uint[] values = { 0x12345678, 0xabcdef09, 0xdeadbeef };
            byte[] expected = { 0x78, 0x56, 0x34, 0x12, 0x09, 0xef, 0xcd, 0xab, 0xef, 0xbe, 0xad, 0xde };
            NetworkWriter writer = new NetworkWriter();
            foreach (uint value in values)
            {
                writer.WriteInt((int)value);
            }
            Assert.That(writer.ToArray(), Is.EqualTo(expected));
        }

        [Test]
        public void TestLongEndianness()
        {
            ulong[] values = { 0x0123456789abcdef, 0xdeaded_beef_c0ffee };
            byte[] expected = { 0xef, 0xcd, 0xab, 0x89, 0x67, 0x45, 0x23, 0x01, 0xee, 0xff, 0xc0, 0xef, 0xbe, 0xed, 0xad, 0xde };
            NetworkWriter writer = new NetworkWriter();
            foreach (ulong value in values)
            {
                writer.WriteLong((long)value);
            }
            Assert.That(writer.ToArray(), Is.EqualTo(expected));
        }

        [Test]
        public void TestWritingAndReading()
        {
            // write all simple types once
            NetworkWriter writer = new NetworkWriter();
            writer.WriteChar((char)1);
            writer.WriteByte(2);
            writer.WriteSByte(3);
            writer.WriteBool(true);
            writer.WriteShort(4);
            writer.WriteUShort(5);
            writer.WriteInt(6);
            writer.WriteUInt(7U);
            writer.WriteLong(8L);
            writer.WriteULong(9UL);
            writer.WriteFloat(10.0F);
            writer.WriteDouble(11.0D);
            writer.WriteDecimal(12);
            writer.WriteString(null);
            writer.WriteString("");
            writer.WriteString("13");
            // just the byte array, no size info etc.
            writer.WriteBytes(new byte[] { 14, 15 }, 0, 2);
            // [SyncVar] struct values can have uninitialized byte arrays, null needs to be supported
            writer.WriteBytesAndSize(null);
            // buffer, no-offset, count
            writer.WriteBytesAndSize(new byte[] { 17, 18 }, 0, 2);
            // buffer, offset, count
            writer.WriteBytesAndSize(new byte[] { 19, 20, 21 }, 1, 2);
            // size, buffer
            writer.WriteBytesAndSize(new byte[] { 22, 23 }, 0, 2);

            // read them
            NetworkReader reader = new NetworkReader(writer.ToArray());

            Assert.That(reader.ReadChar(), Is.EqualTo(1));
            Assert.That(reader.ReadByte(), Is.EqualTo(2));
            Assert.That(reader.ReadSByte(), Is.EqualTo(3));
            Assert.That(reader.ReadBool(), Is.True);
            Assert.That(reader.ReadShort(), Is.EqualTo(4));
            Assert.That(reader.ReadUShort(), Is.EqualTo(5));
            Assert.That(reader.ReadInt(), Is.EqualTo(6));
            Assert.That(reader.ReadUInt(), Is.EqualTo(7));
            Assert.That(reader.ReadLong(), Is.EqualTo(8));
            Assert.That(reader.ReadULong(), Is.EqualTo(9));
            Assert.That(reader.ReadFloat(), Is.EqualTo(10));
            Assert.That(reader.ReadDouble(), Is.EqualTo(11));
            Assert.That(reader.ReadDecimal(), Is.EqualTo(12));
            // writing null string should write null in Mirror ("" in original HLAPI)
            Assert.That(reader.ReadString(), Is.Null);
            Assert.That(reader.ReadString(), Is.EqualTo(""));
            Assert.That(reader.ReadString(), Is.EqualTo("13"));

            Assert.That(reader.ReadBytes(2), Is.EqualTo(new byte[] { 14, 15 }));

            Assert.That(reader.ReadBytesAndSize(), Is.Null);

            Assert.That(reader.ReadBytesAndSize(), Is.EqualTo(new byte[] { 17, 18 }));

            Assert.That(reader.ReadBytesAndSize(), Is.EqualTo(new byte[] { 20, 21 }));

            Assert.That(reader.ReadBytesAndSize(), Is.EqualTo(new byte[] { 22, 23 }));
        }

        [Test]
        public void TestWritingUri()
        {

            Uri testUri = new Uri("https://www.mirror-networking.com?somthing=other");

            NetworkWriter writer = new NetworkWriter();
            writer.WriteUri(testUri);

            NetworkReader reader = new NetworkReader(writer.ToArray());
            Assert.That(reader.ReadUri(), Is.EqualTo(testUri));
        }

        // URI null support test for https://github.com/vis2k/Mirror/pull/2796/
        [Test]
        public void TestWritingNullUri()
        {
            NetworkWriter writer = new NetworkWriter();
            writer.WriteUri(null);

            NetworkReader reader = new NetworkReader(writer.ToArray());
            Assert.That(reader.ReadUri(), Is.EqualTo(null));
        }

        [Test]
        public void TestList()
        {
            List<int> original = new List<int>() { 1, 2, 3, 4, 5 };
            NetworkWriter writer = new NetworkWriter();
            writer.Write(original);

            NetworkReader reader = new NetworkReader(writer.ToArray());
            List<int> readList = reader.Read<List<int>>();
            Assert.That(readList, Is.EqualTo(original));
        }

        [Test]
        public void TestNullList()
        {
            NetworkWriter writer = new NetworkWriter();
            writer.Write<List<int>>(null);

            NetworkReader reader = new NetworkReader(writer.ToArray());
            List<int> readList = reader.Read<List<int>>();
            Assert.That(readList, Is.Null);
        }


        const int testArraySize = 4;
        [Test]
        [Description("ReadArray should throw if it is trying to read more than length of segment, this is to stop allocation attacks")]
        public void TestArrayDoesNotThrowWithCorrectLength()
        {
            NetworkWriter writer = new NetworkWriter();
            WriteGoodArray();

            NetworkReader reader = new NetworkReader(writer.ToArray());
            Assert.DoesNotThrow(() =>
            {
                _ = reader.ReadArray<int>();
            });

            void WriteGoodArray()
            {
                writer.WriteInt(testArraySize);
                int[] array = new int[testArraySize] { 1, 2, 3, 4 };
                for (int i = 0; i < array.Length; i++)
                    writer.Write(array[i]);
            }
        }
        [Test]
        [Description("ReadArray should throw if it is trying to read more than length of segment, this is to stop allocation attacks")]
        [TestCase(testArraySize * sizeof(int), Description = "max allowed value to allocate array")]
        [TestCase(testArraySize * 2)]
        [TestCase(testArraySize + 1, Description = "min allowed to allocate")]
        public void TestArrayThrowsIfLengthIsWrong(int badLength)
        {
            NetworkWriter writer = new NetworkWriter();
            WriteBadArray();

            NetworkReader reader = new NetworkReader(writer.ToArray());
            Assert.Throws<EndOfStreamException>(() => {
                _ = reader.ReadArray<int>();
            });

            void WriteBadArray()
            {
                writer.WriteInt(badLength);
                int[] array = new int[testArraySize] { 1, 2, 3, 4 };
                for (int i = 0; i < array.Length; i++)
                    writer.Write(array[i]);
            }
        }

        [Test]
        [Description("ReadArray should throw if it is trying to read more than length of segment, this is to stop allocation attacks")]
        [TestCase(testArraySize * sizeof(int) + 1, Description = "min read count is 1 byte, 16 array bytes are writen so 17 should throw error")]
        [TestCase(20_000)]
        [TestCase(int.MaxValue)]
        [TestCase(int.MaxValue - 1)]
        // todo add fuzzy testing to check more values
        public void TestArrayThrowsIfLengthIsTooBig(int badLength)
        {
            NetworkWriter writer = new NetworkWriter();
            WriteBadArray();

            NetworkReader reader = new NetworkReader(writer.ToArray());
            EndOfStreamException exception = Assert.Throws<EndOfStreamException>(() =>
            {
                _ = reader.ReadArray<int>();
            });
            Assert.That(exception, Has.Message.EqualTo($"Received array that is too large: {badLength}"));

            void WriteBadArray()
            {
                writer.WriteInt(badLength);
                int[] array = new int[testArraySize] { 1, 2, 3, 4 };
                for (int i = 0; i < array.Length; i++)
                    writer.Write(array[i]);
            }
        }

        [Test]
        public void TestNetworkBehaviour()
        {
            // create spawned because we will look up netId in .spawned
            CreateNetworkedAndSpawn(out _, out _, out RpcNetworkIdentityBehaviour behaviour,
                                    out _, out _, out _);

            NetworkWriter writer = new NetworkWriter();
            writer.WriteNetworkBehaviour(behaviour);

            byte[] bytes = writer.ToArray();

            Assert.That(bytes.Length, Is.EqualTo(5), "Networkbehaviour should be 5 bytes long.");

            NetworkReader reader = new NetworkReader(bytes);
            RpcNetworkIdentityBehaviour actual = reader.ReadNetworkBehaviour<RpcNetworkIdentityBehaviour>();
            Assert.That(actual, Is.EqualTo(behaviour), "Read should find the same behaviour as written");
        }

        [Test]
        public void TestNetworkBehaviourNull()
        {
            NetworkWriter writer = new NetworkWriter();
            writer.WriteNetworkBehaviour(null);

            byte[] bytes = writer.ToArray();

            Assert.That(bytes.Length, Is.EqualTo(4), "null Networkbehaviour should be 4 bytes long.");

            NetworkReader reader = new NetworkReader(bytes);
            RpcNetworkIdentityBehaviour actual = reader.ReadNetworkBehaviour<RpcNetworkIdentityBehaviour>();
            Assert.That(actual, Is.Null, "should read null");

            Assert.That(reader.Position, Is.EqualTo(4), "should read 4 bytes when netid is 0");
        }

        [Test]
        [Description("Uses Generic read function to check weaver correctly creates it")]
        public void TestNetworkBehaviourWeaverGenerated()
        {
            // create spawned because we will look up netId in .spawned
            CreateNetworkedAndSpawn(out _, out _, out RpcNetworkIdentityBehaviour behaviour,
                                    out _, out _, out _);

            NetworkWriter writer = new NetworkWriter();
            writer.Write(behaviour);

            byte[] bytes = writer.ToArray();

            Assert.That(bytes.Length, Is.EqualTo(5), "Networkbehaviour should be 5 bytes long.");

            NetworkReader reader = new NetworkReader(bytes);
            RpcNetworkIdentityBehaviour actual = reader.Read<RpcNetworkIdentityBehaviour>();
            Assert.That(actual, Is.EqualTo(behaviour), "Read should find the same behaviour as written");
        }
    }
}