public void CreateThrowsOnNullStream()
        {
            Assert.That(
                () => BinaryData.Create(stream: null),
                Throws.InstanceOf <ArgumentNullException>());

            Assert.That(
                async() => await BinaryData.CreateAsync(stream: null),
                Throws.InstanceOf <ArgumentNullException>());
        }
        public void GenericCreateThrowsOnNullSerializer()
        {
            var payload = new TestModel {
                A = "value", B = 5, C = true
            };

            Assert.That(
                () => BinaryData.Create(payload, null),
                Throws.InstanceOf <ArgumentNullException>());
            Assert.That(
                async() => await BinaryData.CreateAsync(payload, null),
                Throws.InstanceOf <ArgumentNullException>());
        }
        public async Task CanCreateBinaryDataFromStream()
        {
            var buffer  = Encoding.UTF8.GetBytes("some data");
            var payload = new MemoryStream(buffer);
            var data    = BinaryData.Create(payload);

            Assert.AreEqual(buffer, data.AsBytes().ToArray());
            Assert.AreEqual(payload, data.AsStream());

            payload.Position = 0;
            data             = await BinaryData.CreateAsync(payload);

            Assert.AreEqual(buffer, data.AsBytes().ToArray());
            Assert.AreEqual(payload, data.AsStream());
        }
        public async Task CanCreateBinaryDataFromCustomType()
        {
            var payload = new TestModel {
                A = "value", B = 5, C = true
            };
            var serializer = new JsonObjectSerializer();

            await AssertData(BinaryData.Create(payload, serializer));
            await AssertData(await BinaryData.CreateAsync(payload, serializer));

            async Task AssertData(BinaryData data)
            {
                Assert.AreEqual(payload.A, data.As <TestModel>(serializer).A);
                Assert.AreEqual(payload.B, data.As <TestModel>(serializer).B);
                Assert.AreEqual(payload.C, data.As <TestModel>(serializer).C);
                Assert.AreEqual(payload.A, (await data.AsAsync <TestModel>(serializer)).A);
                Assert.AreEqual(payload.B, (await data.AsAsync <TestModel>(serializer)).B);
                Assert.AreEqual(payload.C, (await data.AsAsync <TestModel>(serializer)).C);
            }
        }
        public async Task AsThrowsExceptionOnIncompatibleType()
        {
            var payload = new TestModel {
                A = "value", B = 5, C = true
            };
            var serializer = new JsonObjectSerializer();

            AssertData(BinaryData.Create(payload, serializer));
            AssertData(await BinaryData.CreateAsync(payload, serializer));

            void AssertData(BinaryData data)
            {
                Assert.That(
                    () => data.As <string>(serializer),
                    Throws.InstanceOf <Exception>());
                Assert.That(
                    async() => await data.AsAsync <string>(serializer),
                    Throws.InstanceOf <Exception>());
            }
        }