Initial commit

source/test/MyTelegram.Schema.Tests/Serializer/BitArraySerializerTests.cs

@@ -0,0 +1,59 @@
+using System.Buffers;
+using MyTelegram.Schema.Extensions;
+
+namespace MyTelegram.Schema.Serializer;
+
+public class BitArraySerializerTests
+{
+    [Fact]
+    public void SerializeTest()
+    {
+        var value = new BitArray(32) { [0] = true };
+        var expectedValue = "01000000".ToBytes();
+        //var stream = new MemoryStream();
+        //var bw = new BinaryWriter(stream);
+        using var writer = new ArrayPoolBufferWriter<byte>();
+        var serializer = CreateSerializer();
+
+        serializer.Serialize(value, writer);
+
+        writer.WrittenSpan.ToArray().ShouldBeEquivalentTo(expectedValue);
+    }
+
+    [MemberData(nameof(GetData), parameters: new[] { 0 })]
+    [MemberData(nameof(GetData), parameters: new[] { 1 })]
+    [MemberData(nameof(GetData), parameters: new[] { 2 })]
+    [MemberData(nameof(GetData), parameters: new[] { 31 })]
+    [MemberData(nameof(GetData), parameters: new[] { 1, 2 })]
+    [MemberData(nameof(GetData), parameters: new[] { 1, 2, 3 })]
+    [MemberData(nameof(GetData), parameters: new[] { 1, 2, 31 })]
+    [Theory]
+    public void DeserializeTest(byte[] value, BitArray expectedValue)
+    {
+        //var stream = new MemoryStream(value);
+        //var br = new BinaryReader(stream);
+        var serializer = CreateSerializer();
+        ReadOnlyMemory<byte> buffer = value;
+        var actualValue = serializer.Deserialize(ref buffer);
+
+        actualValue.ShouldBeEquivalentTo(expectedValue);
+    }
+
+    public static IEnumerable<object[]> GetData(params int[] bitOfNSetToTrue)
+    {
+        var bitArray = new BitArray(32);
+        foreach (var i in bitOfNSetToTrue)
+        {
+            bitArray.Set(i, true);
+        }
+
+        var buffer = new byte[4];
+        bitArray.CopyTo(buffer, 0);
+
+        var allData = new List<object[]> { new object[] { buffer, bitArray } };
+
+        return allData;
+    }
+
+    private BitArraySerializer CreateSerializer() => new();
+}

source/test/MyTelegram.Schema.Tests/Serializer/BooleanSerializerTests.cs

@@ -0,0 +1,61 @@
+using System.Buffers;
+using MyTelegram.Schema.Extensions;
+
+namespace MyTelegram.Schema.Serializer;
+
+public class BooleanSerializerTests
+{
+    [Fact]
+    public void Deserialize_ErrorData_Throws_Argument_Exception()
+    {
+        var value = new byte[] { 1, 2, 3, 4 };
+        //var br = new BinaryReader(new MemoryStream(value));
+        //var buffer = new ReadOnlySequence<byte>(value);
+        ReadOnlyMemory<byte> buffer = value;
+        var serializer = CreateSerializer();
+        //Assert.Throws<ArgumentException>(() => serializer.Deserialize(ref reader));
+
+        Assert.Throws<ArgumentException>(() =>
+        {
+            //var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(value));
+            //serializer.Deserialize(ref reader);
+
+            serializer.Deserialize(ref buffer);
+        });
+    }
+
+    [InlineData(new byte[] { 55, 151, 121, 188 }, false)]
+    [InlineData(new byte[] { 181, 117, 114, 153 }, true)]
+    [Theory]
+    public void DeserializeTest(byte[] value,
+        bool expectedValue)
+    {
+        //var stream = new MemoryStream(value);
+        //var br = new BinaryReader(stream);
+        var serializer = CreateSerializer();
+        //var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(value));
+        ReadOnlyMemory<byte> buffer = value;
+
+        var actualValue = serializer.Deserialize(ref buffer);
+
+        actualValue.ShouldBe(expectedValue);
+    }
+
+    [InlineData(false, new byte[] { 55, 151, 121, 188 })]
+    [InlineData(true, new byte[] { 181, 117, 114, 153 })]
+    [Theory]
+    public void SerializeTest(bool value,
+        byte[] expectedValue)
+    {
+        //var stream = new MemoryStream();
+        //var bw = new BinaryWriter(stream);
+        using var writer = new ArrayPoolBufferWriter<byte>();
+        var serializer = CreateSerializer();
+
+        serializer.Serialize(value, writer);
+
+        writer.WrittenSpan.ToArray().ShouldBeEquivalentTo(expectedValue);
+    }
+
+    private BooleanSerializer CreateSerializer() => new();
+}

source/test/MyTelegram.Schema.Tests/Serializer/BytesSerializerTests.cs

@@ -0,0 +1,86 @@
+// ReSharper disable StringLiteralTypo
+
+using System.Buffers;
+using MyTelegram.Schema.Extensions;
+
+namespace MyTelegram.Schema.Serializer;
+
+public class BytesSerializerTests
+{
+    [MemberData(nameof(GetSerializeTestDataLengthLessThan254))]
+    [MemberData(nameof(GetSerializeTestDataLengthGreaterThan253))]
+    [Theory]
+    public void Serialize_Data_Test(string inputBytesData, string expectedBytesData)
+    {
+        // Arrange
+        var dataBytes = inputBytesData.ToBytes();
+        var expectedBytes = expectedBytesData.ToBytes();
+        //var stream = new MemoryStream();
+        //var bw = new BinaryWriter(stream);
+        using var writer = new ArrayPoolBufferWriter<byte>();
+        var serializer = CreateSerializer();
+
+        // Act
+        serializer.Serialize(dataBytes, writer);
+
+        // Assert
+        var serializedBytes = writer.WrittenSpan.ToArray();
+        serializedBytes.ShouldBeEquivalentTo(expectedBytes);
+    }
+
+    [MemberData(nameof(GetSerializeTestDataLengthLessThan254))]
+    [MemberData(nameof(GetSerializeTestDataLengthGreaterThan253))]
+    [Theory]
+    public void Deserialize_Data_Test(string expectedBytesData, string inputBytesData)
+    {
+        // Arrange
+        var expectedBytes = expectedBytesData.ToBytes();
+        var inputBytes = inputBytesData.ToBytes();
+        //var br = new BinaryReader(new MemoryStream(inputBytes));
+        //var buffer = new ReadOnlySequence<byte>(inputBytes);
+        var serializer = CreateSerializer();
+        //var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(inputBytes));
+        ReadOnlyMemory<byte> buffer = inputBytes;
+
+        // Act
+        var actualData = serializer.Deserialize(ref buffer);
+
+        // Assert
+        actualData.ShouldBeEquivalentTo(expectedBytes);
+    }
+
+    public static IEnumerable<object[]> GetSerializeTestDataLengthLessThan254()
+    {
+        // 1
+        yield return new object[] { "8A", "018A0000" };
+
+        // 3
+        yield return new object[] { "B05EDE", "03B05EDE" };
+
+        // 253
+        yield return new object[]
+        {
+            "2586A2E2FA26A0CAED85146EC93A1EEE417A45165C0909097B39A7D8FEDB6D4BCCEEC3C74F4054732CEA1EB8C355E259C8A54A19C02C5040A6F61A7881D688A7D69CD8F89281588CD3B7097EAEBA11B757A871442614CE093D1B43CE571951C9AF7DA7AA32BF0D2C4755E7092E9563CA379FCB4C5736B67070F67CDD8D18166FF2C134603518DDBD890CE2294C698E8A1B45FAB17882EB0141863E45583DC4CE09D005F2C0897DDBC026CD12CDCF42F02C4F652AE882237DA65B03EB35317E5E6D58B3E1E00C5CF10C7EE6E5B4768900F761B831C8B6B21E10EE96B0DC05C4B94A21B1D2F877D71C7DEDD6A467A92FA856B58FFF05A45573CF2E67DF78",
+            "FD2586A2E2FA26A0CAED85146EC93A1EEE417A45165C0909097B39A7D8FEDB6D4BCCEEC3C74F4054732CEA1EB8C355E259C8A54A19C02C5040A6F61A7881D688A7D69CD8F89281588CD3B7097EAEBA11B757A871442614CE093D1B43CE571951C9AF7DA7AA32BF0D2C4755E7092E9563CA379FCB4C5736B67070F67CDD8D18166FF2C134603518DDBD890CE2294C698E8A1B45FAB17882EB0141863E45583DC4CE09D005F2C0897DDBC026CD12CDCF42F02C4F652AE882237DA65B03EB35317E5E6D58B3E1E00C5CF10C7EE6E5B4768900F761B831C8B6B21E10EE96B0DC05C4B94A21B1D2F877D71C7DEDD6A467A92FA856B58FFF05A45573CF2E67DF780000"
+        };
+    }
+
+    public static IEnumerable<object[]> GetSerializeTestDataLengthGreaterThan253()
+    {
+        // 254
+        yield return new object[]
+        {
+            "E3015AEB327305D451B5BFFEAA5E1AEB15DE811373FC0B159D333DB5439715FD19570BCB43C6F3E31D2FF6B501817F67479BCADE30F395B86FDF73ACC354A1D90C2F592FD88CB83337F7D2D249775A2FE4B3EF169AAD2ABD7405940CEFCE9BC025E02FE81F4437C2606E2AD2CF807E334F954671302CD53C47EB8462E44AD73F9FDB3095827542DD6060F3EF2E1472A3B11F0857CBE65B3839C3AD95DE71F0625A6CBDE94B8F3CD1F28993DE72BB9F089C6E30968CB3E365F0AE2D35490AD958C04DE9FF433C5C710D44DF7710C5A5B9A96A113659933B7212BC6BB2715FD7B080E2E01E7583AF6A99967A0E559E74363ACAEE7A94D1A601CF0DAD4B6DC5",
+            "FEFE0000E3015AEB327305D451B5BFFEAA5E1AEB15DE811373FC0B159D333DB5439715FD19570BCB43C6F3E31D2FF6B501817F67479BCADE30F395B86FDF73ACC354A1D90C2F592FD88CB83337F7D2D249775A2FE4B3EF169AAD2ABD7405940CEFCE9BC025E02FE81F4437C2606E2AD2CF807E334F954671302CD53C47EB8462E44AD73F9FDB3095827542DD6060F3EF2E1472A3B11F0857CBE65B3839C3AD95DE71F0625A6CBDE94B8F3CD1F28993DE72BB9F089C6E30968CB3E365F0AE2D35490AD958C04DE9FF433C5C710D44DF7710C5A5B9A96A113659933B7212BC6BB2715FD7B080E2E01E7583AF6A99967A0E559E74363ACAEE7A94D1A601CF0DAD4B6DC50000"
+        };
+
+        // 512
+        yield return new object[]
+        {
+            "1CBB65F9B0CA8EB14FB956E0A7C3285B7A4FCCEACD3E6A12FB231ACC6F53C8ACDE096C2D6619F4DC44DF78EA1C22D0C97B42B3913BAFB20611CB092D8DDE854A91F47CB0C21F61813430469E7C3DCBDC2520494D690A0356965E49351917C4127B3BF76B0531510BD684158565B9CFCD08C51DC9F8A4650EE8B7637ED67CC2E1641713B6D111539902991E81F83B35950302EAC773F1FAC6DE8FA9448A4B40554DD4FDDDB969AC9706AB51CE84C562826C2695A977C20C09874C5264548234F658A83CD59C2870E9AF31423C782368E91852E0AA3F7A73C512017DEAB1D4443E46B61CE5FB9D2ADD800771C7D879C0E457319ACA3D12A1A8737094B079D901C8DCB7BC69428D3502532867CE086788667888D91ADEBCC59342D32ACD76E42D9663260D2069C13DEF4FF35F592287A7B7ECF7A630FC2DF995F736D658C779A4DF255F1BD8629BF427B329A3BBD0AFC2359B5ABD9CACA622723B1990B469DDFAF09D809D28260E5F75035B3EEAB9D1010E4F82E6FF77617C2A48B8E61F47BF264B36E4E4ED7C87F97661395B64DEF2A68C6A980F3EDB930D5B1487E131198B7481D2245C94D938A85A7233EFCA6F30958F147C0C400CA4BB4E6785CAF6581C9C067D2784A7A33EC34C1A52AF1031EB23AA57EBACCC57731466C04759968CA8412FEB11344B1BD377D41A7DEABE8D19DBA4ADF556D99A6095AB49F968CC890066C3",
+            "FE0002001CBB65F9B0CA8EB14FB956E0A7C3285B7A4FCCEACD3E6A12FB231ACC6F53C8ACDE096C2D6619F4DC44DF78EA1C22D0C97B42B3913BAFB20611CB092D8DDE854A91F47CB0C21F61813430469E7C3DCBDC2520494D690A0356965E49351917C4127B3BF76B0531510BD684158565B9CFCD08C51DC9F8A4650EE8B7637ED67CC2E1641713B6D111539902991E81F83B35950302EAC773F1FAC6DE8FA9448A4B40554DD4FDDDB969AC9706AB51CE84C562826C2695A977C20C09874C5264548234F658A83CD59C2870E9AF31423C782368E91852E0AA3F7A73C512017DEAB1D4443E46B61CE5FB9D2ADD800771C7D879C0E457319ACA3D12A1A8737094B079D901C8DCB7BC69428D3502532867CE086788667888D91ADEBCC59342D32ACD76E42D9663260D2069C13DEF4FF35F592287A7B7ECF7A630FC2DF995F736D658C779A4DF255F1BD8629BF427B329A3BBD0AFC2359B5ABD9CACA622723B1990B469DDFAF09D809D28260E5F75035B3EEAB9D1010E4F82E6FF77617C2A48B8E61F47BF264B36E4E4ED7C87F97661395B64DEF2A68C6A980F3EDB930D5B1487E131198B7481D2245C94D938A85A7233EFCA6F30958F147C0C400CA4BB4E6785CAF6581C9C067D2784A7A33EC34C1A52AF1031EB23AA57EBACCC57731466C04759968CA8412FEB11344B1BD377D41A7DEABE8D19DBA4ADF556D99A6095AB49F968CC890066C3"
+        };
+    }
+
+    private BytesSerializer CreateSerializer() => new();
+}

source/test/MyTelegram.Schema.Tests/Serializer/DoubleSerializerTests.cs

@@ -0,0 +1,44 @@
+using System.Buffers;
+using MyTelegram.Schema.Extensions;
+
+namespace MyTelegram.Schema.Serializer;
+
+public class DoubleSerializerTests
+{
+    [InlineData(1.2345d)]
+    [InlineData(-1.2345d)]
+    [InlineData(10000.2345d)]
+    [Theory]
+    public void SerializeTest(double a)
+    {
+        var bytes = BitConverter.GetBytes(a);
+        //var stream = new MemoryStream();
+        //var bw = new BinaryWriter(stream);
+        using var writer = new ArrayPoolBufferWriter<byte>();
+        var serializer = CreateSerializer();
+
+        serializer.Serialize(a, writer);
+
+        var actualBytes = writer.WrittenSpan.ToArray();
+        actualBytes.ShouldBeEquivalentTo(bytes);
+    }
+
+
+    [InlineData("8D976E1283C0F33F", 1.2345d)]
+    [InlineData("8D976E1283C0F3BF", -1.2345d)]
+    [InlineData("759318041E88C340", 10000.2345d)]
+    [Theory]
+    public void DeserializeTest(string data, double expectedValue)
+    {
+        var dataBytes = data.ToBytes();
+        //var br = new BinaryReader(new MemoryStream(dataBytes));
+        var serializer = CreateSerializer();
+        ReadOnlyMemory<byte> buffer = dataBytes;
+
+        var actualValue = serializer.Deserialize(ref buffer);
+
+        actualValue.ShouldBe(expectedValue);
+    }
+
+    private DoubleSerializer CreateSerializer() => new();
+}

source/test/MyTelegram.Schema.Tests/Serializer/Extensions.cs

@@ -0,0 +1,30 @@
+namespace MyTelegram.Schema.Serializer;
+
+public static class Extensions
+{
+    public static byte[] ToBytes(this string hex)
+    {
+        return HexToBytes(hex);
+    }
+
+    //public static string ToHexString(this MemoryStream memoryStream) => memoryStream.ToArray().ToHexString();
+    public static string ToHexString(this byte[] bytes) => BitConverter.ToString(bytes).Replace("-", string.Empty);
+
+    private static byte[] HexToBytes(string hex)
+    {
+        var text = hex.Replace(" ", string.Empty)
+            .Replace("\r\n", string.Empty)
+            .Replace("\n", string.Empty)
+            .Replace("-", string.Empty)
+            ;
+        return StringToByteArray(text);
+    }
+
+    public static byte[] StringToByteArray(string hex)
+    {
+        return Enumerable.Range(0, hex.Length)
+            .Where(x => x % 2 == 0)
+            .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
+            .ToArray();
+    }
+}

source/test/MyTelegram.Schema.Tests/Serializer/Int128SerializerTests.cs

@@ -0,0 +1,37 @@
+using System.Buffers;
+using MyTelegram.Schema.Extensions;
+
+namespace MyTelegram.Schema.Serializer;
+
+public class Int128SerializerTests
+{
+    [Fact]
+    public void SerializeTest()
+    {
+        var value = "C0CC11F66E1111B8529BB89742D77959".ToBytes();
+        //var stream = new MemoryStream();
+        //var bw = new BinaryWriter(stream);
+        using var writer = new ArrayPoolBufferWriter<byte>();
+        var serializer = CreateSerializer();
+
+        serializer.Serialize(value, writer);
+
+        writer.WrittenSpan.ToArray().ShouldBeEquivalentTo(value);
+    }
+
+    [Fact]
+    public void DeserializeTest()
+    {
+        var expectedBytes = "C0CC11F66E1111B8529BB89742D77959".ToBytes();
+        //var stream = new MemoryStream(expectedBytes);
+        //var br = new BinaryReader(stream);
+        var serializer = CreateSerializer();
+        //var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(expectedBytes));
+        ReadOnlyMemory<byte> buffer = expectedBytes;
+        var actualBytes = serializer.Deserialize(ref buffer);
+
+        actualBytes.ShouldBeEquivalentTo(expectedBytes);
+    }
+
+    private Int128Serializer CreateSerializer() => new();
+}

source/test/MyTelegram.Schema.Tests/Serializer/Int256SerializerTests.cs

@@ -0,0 +1,39 @@
+using System.Buffers;
+using MyTelegram.Schema.Extensions;
+
+namespace MyTelegram.Schema.Serializer;
+
+
+
+public class Int256SerializerTests
+{
+    [Fact]
+    public void DeserializeTest()
+    {
+        var expectedBytes = "6B5DB1FB13049F1CBC9FE635C66786F220BF979222CF064F1A59DD0C23971293".ToBytes();
+        //var stream = new MemoryStream(expectedBytes);
+        //var br = new BinaryReader(stream);
+        ReadOnlyMemory<byte> buffer = expectedBytes;
+        var serializer = CreateSerializer();
+
+        var actualBytes = serializer.Deserialize(ref buffer);
+
+        actualBytes.ShouldBeEquivalentTo(expectedBytes);
+    }
+
+    [Fact]
+    public void SerializeTest()
+    {
+        var expectedBytes = "6B5DB1FB13049F1CBC9FE635C66786F220BF979222CF064F1A59DD0C23971293".ToBytes();
+        //var stream = new MemoryStream();
+        //var bw = new BinaryWriter(stream);
+        using var writer = new ArrayPoolBufferWriter<byte>();
+        var serializer = CreateSerializer();
+
+        serializer.Serialize(expectedBytes, writer);
+
+        writer.WrittenSpan.ToArray().ShouldBeEquivalentTo(expectedBytes);
+    }
+
+    private Int256Serializer CreateSerializer() => new();
+}

source/test/MyTelegram.Schema.Tests/Serializer/Int32SerializerTests.cs

@@ -0,0 +1,33 @@
+namespace MyTelegram.Schema.Serializer;
+
+public class Int32SerializerTests
+{
+    [Fact]
+    public void SerializeTest()
+    {
+        var expectedValue = new byte[] { 01, 0, 0, 0 };
+        //var stream = new MemoryStream();
+        //var bw = new BinaryWriter(stream);
+        using var writer = new ArrayPoolBufferWriter<byte>();
+        var serializer = CreateSerializer();
+
+        serializer.Serialize(1, writer);
+
+        writer.WrittenSpan.ToArray().ShouldBeEquivalentTo(expectedValue);
+    }
+
+    [Fact]
+    public void DeserializeTest()
+    {
+        var value = new byte[] { 01, 0, 0, 0 };
+        var expectedValue = 1;
+        ReadOnlyMemory<byte> buffer = value;
+        var serializer = CreateSerializer();
+
+        var actualValue = serializer.Deserialize(ref buffer);
+
+        actualValue.ShouldBeEquivalentTo(expectedValue);
+    }
+
+    private Int32Serializer CreateSerializer() => new();
+}

source/test/MyTelegram.Schema.Tests/Serializer/Int64SerializerTests.cs

@@ -0,0 +1,32 @@
+namespace MyTelegram.Schema.Serializer;
+
+public class Int64SerializerTests
+{
+    [Fact]
+    public void SerializeTest()
+    {
+        var expectedBytes = "6300000000000000".ToBytes();
+        //var stream = new MemoryStream();
+        //var bw = new BinaryWriter(stream);
+        using var writer = new ArrayPoolBufferWriter<byte>();
+        var serializer = CreateSerializer();
+
+        serializer.Serialize(99L, writer);
+
+        writer.WrittenSpan.ToArray().ShouldBeEquivalentTo(expectedBytes);
+    }
+
+    [Fact]
+    public void DeserializeTest()
+    {
+        var expectedBytes = "6300000000000000".ToBytes();
+        ReadOnlyMemory<byte> buffer = expectedBytes;
+        var serializer = CreateSerializer();
+
+        var actualBytes = serializer.Deserialize(ref buffer);
+
+        actualBytes.ShouldBeEquivalentTo(99L);
+    }
+
+    private Int64Serializer CreateSerializer() => new();
+}

source/test/MyTelegram.Schema.Tests/Serializer/StringSerializerTests.cs

@@ -0,0 +1,43 @@
+// ReSharper disable StringLiteralTypo
+using MyTelegram.Schema.Extensions;
+
+namespace MyTelegram.Schema.Serializer;
+
+public class StringSerializerTests
+{
+    [Fact]
+    public void SerializeTest()
+    {
+        var value = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()_+<>?:{}[],./;'";
+        var expectedValue =
+            "576162636465666768696A6B6C6D6E6F707172737475767778797A4142434445464748494A4B4C4D4E4F505152535455565758595A3132333435363738393021402324255E262A28295F2B3C3E3F3A7B7D5B5D2C2E2F3B27"
+                .ToBytes();
+        //var stream = new MemoryStream();
+        //var bw = new BinaryWriter(stream);
+        using var writer = new ArrayPoolBufferWriter<byte>();
+        var serializer = CreateSerializer();
+
+        serializer.Serialize(value, writer);
+
+        writer.WrittenSpan.ToArray().ShouldBeEquivalentTo(expectedValue);
+    }
+
+    [Fact]
+    public void DeserializeTest()
+    {
+        var expectedValue = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()_+<>?:{}[],./;'";
+        var value =
+            "576162636465666768696A6B6C6D6E6F707172737475767778797A4142434445464748494A4B4C4D4E4F505152535455565758595A3132333435363738393021402324255E262A28295F2B3C3E3F3A7B7D5B5D2C2E2F3B27"
+                .ToBytes();
+        //var stream = new MemoryStream(value);
+        //var br = new BinaryReader(stream);
+        ReadOnlyMemory<byte> buffer = value;
+        var serializer = CreateSerializer();
+
+        var actualValue = serializer.Deserialize(ref buffer);
+
+        actualValue.ShouldBeEquivalentTo(expectedValue);
+    }
+
+    private StringSerializer CreateSerializer() => new();
+}

source/test/MyTelegram.Schema.Tests/Serializer/UInt32SerializerTests.cs

@@ -0,0 +1,47 @@
+using MyTelegram.Schema.Extensions;
+
+namespace MyTelegram.Schema.Serializer;
+
+//public abstract class SerializeTestBase
+//{
+//    protected void SerializeTest<TData>(TData t, byte[] expectedValue)
+//    {
+
+//    }
+//}
+
+public class UInt32SerializerTests
+{
+    [Fact]
+    public void SerializeTest()
+    {
+        var expectedBytes = "09000080".ToBytes();
+        //var stream = new MemoryStream();
+        //var bw = new BinaryWriter(stream);
+        var value = int.MaxValue + 10u;
+        using var writer = new ArrayPoolBufferWriter<byte>();
+        var serializer = CreateSerializer();
+
+        serializer.Serialize(value, writer);
+
+        writer.WrittenSpan.ToArray().ShouldBeEquivalentTo(expectedBytes);
+    }
+
+    [Fact]
+    public void DeserializeTest()
+    {
+        var expectedBytes = "09000080".ToBytes();
+        //var stream = new MemoryStream(expectedBytes);
+        //var br = new BinaryReader(stream);
+        //var buffer = new ReadOnlySequence<byte>(expectedBytes);
+        var expectedValue = int.MaxValue + 10u;
+        var serializer = CreateSerializer();
+        ReadOnlyMemory<byte> buffer = expectedBytes;
+
+        var actualBytes = serializer.Deserialize(ref buffer);
+
+        actualBytes.ShouldBeEquivalentTo(expectedValue);
+    }
+
+    private UInt32Serializer CreateSerializer() => new();
+}