public async Task ReadSimpleObject()
        {
            const string hexBuffer = "AE67426F6F6C65616EF56553427974650D64427974650C65496E7431360E6655496E7431360F65496E743332106655496E7433321165496E743634126655496E7436341366537472696E6766737472696E676653696E676C65FA41A1AE1466446F75626C65FB40363AE147AE147B684461746554696D6574323031342D30322D32315431393A30303A30305A64456E756D6656616C756531";

            byte[] buffer = hexBuffer.HexToBytes();

            Mock <HttpRequest> httpRequest = new Mock <HttpRequest>(MockBehavior.Strict);

            httpRequest.Setup(r => r.ContentType).Returns("application/cbor");
            httpRequest.Setup(r => r.ContentLength).Returns(buffer.Length);
            httpRequest.Setup(r => r.Body).Returns(new MemoryStream(buffer));
#if (NETCOREAPP3_0 || NETCOREAPP3_1)
            httpRequest.Setup(r => r.BodyReader).Returns(await CreatePipeReader());

            async Task <PipeReader> CreatePipeReader()
            {
                Pipe          pipe        = new Pipe();
                Memory <byte> writeBuffer = pipe.Writer.GetMemory(buffer.Length);

                buffer.CopyTo(writeBuffer);
                pipe.Writer.Advance(buffer.Length);
                await pipe.Writer.FlushAsync();

                await pipe.Writer.CompleteAsync();

                return(pipe.Reader);
            }
#endif

            Mock <HttpContext> httpContext = new Mock <HttpContext>(MockBehavior.Strict);
            httpContext.Setup(c => c.Request).Returns(httpRequest.Object);

            Mock <ModelMetadata> modelMetadata = new Mock <ModelMetadata>(
                MockBehavior.Strict,
                ModelMetadataIdentity.ForType(typeof(SimpleObject)));

            InputFormatterContext context = new InputFormatterContext(
                httpContext.Object,
                nameof(SimpleObject),
                new ModelStateDictionary(),
                modelMetadata.Object,
                (stream, encoding) => new StreamReader(stream, encoding));

            IInputFormatter inputFormatter = new CborInputFormatter(null);

            Assert.True(inputFormatter.CanRead(context));

            InputFormatterResult result = await inputFormatter.ReadAsync(context);

            Assert.False(result.HasError);
            Assert.True(result.IsModelSet);

            SimpleObject obj = (SimpleObject)result.Model;

            Assert.NotNull(obj);
            Assert.True(obj.Boolean);
            Assert.Equal(12, obj.Byte);
            Assert.Equal(13, obj.SByte);
            Assert.Equal(14, obj.Int16);
            Assert.Equal(15, obj.UInt16);
            Assert.Equal(16, obj.Int32);
            Assert.Equal(17u, obj.UInt32);
            Assert.Equal(18, obj.Int64);
            Assert.Equal(19ul, obj.UInt64);
            Assert.Equal(20.21f, obj.Single);
            Assert.Equal(22.23, obj.Double);
            Assert.Equal("string", obj.String);
            Assert.Equal(new DateTime(2014, 02, 21, 19, 0, 0, DateTimeKind.Utc), obj.DateTime);
            Assert.Equal(EnumTest.Value1, obj.Enum);
        }
        public async Task WriteSimpleObject()
        {
            SimpleObject obj = new SimpleObject
            {
                Boolean  = true,
                Byte     = 12,
                SByte    = 13,
                Int16    = 14,
                UInt16   = 15,
                Int32    = 16,
                UInt32   = 17u,
                Int64    = 18,
                UInt64   = 19ul,
                Single   = 20.25f,
                Double   = 22.23,
                String   = "string",
                DateTime = new DateTime(2014, 02, 21, 19, 0, 0, DateTimeKind.Utc),
                Enum     = EnumTest.Value1
            };

            const string hexBuffer = "AE67426F6F6C65616EF56553427974650D64427974650C65496E7431360E6655496E7431360F65496E743332106655496E7433321165496E743634126655496E7436341366537472696E6766737472696E676653696E676C65FA41A2000066446F75626C65FB40363AE147AE147B684461746554696D6574323031342D30322D32315431393A30303A30305A64456E756D6656616C756531";

            byte[]       buffer = hexBuffer.HexToBytes();
            MemoryStream body   = new MemoryStream();

            Mock <HttpResponse> httpResponse = new Mock <HttpResponse>(MockBehavior.Strict);

            httpResponse.SetupSet(r => r.ContentType = "application/cbor");
            httpResponse.Setup(r => r.Body).Returns(body);
#if (NETCOREAPP3_0 || NETCOREAPP3_1)
            Pipe pipe = new Pipe();
            httpResponse.Setup(r => r.BodyWriter).Returns(pipe.Writer);
#endif

            Mock <HttpContext> httpContext = new Mock <HttpContext>(MockBehavior.Strict);
            httpContext.Setup(c => c.Response).Returns(httpResponse.Object);

            Mock <ModelMetadata> modelMetadata = new Mock <ModelMetadata>(
                MockBehavior.Strict,
                ModelMetadataIdentity.ForType(typeof(SimpleObject)));

            OutputFormatterWriteContext context = new OutputFormatterWriteContext(
                httpContext.Object,
                (stream, encoding) => new StreamWriter(stream, encoding),
                typeof(SimpleObject),
                obj);

            IOutputFormatter outputFormatter = new CborOutputFormatter(
                new CborOptions
            {
                EnumFormat = ValueFormat.WriteToString
            });

            Assert.True(outputFormatter.CanWriteResult(context));

            await outputFormatter.WriteAsync(context);

#if (NETCOREAPP3_0 || NETCOREAPP3_1)
            await pipe.Reader.CopyToAsync(body);
#endif
            string actualHexBuffer = BitConverter.ToString(body.ToArray()).Replace("-", "");
            Assert.Equal(hexBuffer, actualHexBuffer);
        }