public void TestObject()
        {
            var writer = new Amf0Writer();
            var reader = new Amf0Reader();

            object nullVal = null;
            var    refVal  = new List <object>()
            {
                1, 2, "test"
            };

            var obj = new AmfObject
            {
                { "c", 1.0 },
                { "test", false },
                { "test2", nullVal },
                { "test3", new Undefined() },
                { "test4", refVal },
                { "test5", "test" },
                { "test6", refVal }
            };

            using (var sc = new SerializationContext())
            {
                writer.WriteBytes(obj, sc);
                var buffer = new byte[sc.MessageLength];
                sc.GetMessage(buffer);

                // test reference table is working
                Assert.AreEqual(buffer.Length, 97);
                Assert.IsTrue(reader.TryGetObject(buffer, out var readObj, out var consumed));
                Assert.AreEqual(consumed, buffer.Length);
            }
        }
        public void TestTypedObject()
        {
            var writer = new Amf0Writer();
            var reader = new Amf0Reader();

            reader.RegisterType <TypedClass>();

            object nullVal = null;
            var    refVal  = new List <object>()
            {
                1, 2, "test"
            };

            var obj = new TypedClass()
            {
                c     = 1.0,
                test  = false,
                test2 = nullVal,
                test3 = new Undefined(),
                test4 = refVal,
                test5 = "test",
                test6 = refVal
            };

            using (var sc = new SerializationContext())
            {
                writer.WriteTypedBytes(obj, sc);
                var buffer = new byte[sc.MessageLength];
                sc.GetMessage(buffer);

                Assert.IsTrue(reader.TryGetTypedObject(buffer, out var readObj, out var consumed));
                Assert.AreEqual(consumed, buffer.Length);
            }
        }
        public void TestEcmaArray()
        {
            var writer = new Amf0Writer();
            var reader = new Amf0Reader();

            var array = new Dictionary <string, object>()
            {
                ["1"] = 1.0,
                ["2"] = 2.0,
                ["3"] = "a",
                ["4"] = "a"
            };

            using (var sc = new SerializationContext())
            {
                writer.WriteBytes(array, sc);
                var buffer = new byte[sc.MessageLength];
                sc.GetMessage(buffer);
                // EcmaMarker:byte + ElementCount: uint +
                // StringLength: ushort + StringContent: byte * 1 + NumberMarker: byte + Number: double +
                // StringLength: ushort + StringContent: byte * 1 + NumberMarker: byte + Number: double
                // StringLength: ushort + StringContent: byte * 1 + StringMarker: byte + StringLength: ushort + StringContent: byte * 1 +
                // StringLength: ushort + StringContent: byte * 1 + ReferenceMarker: byte + ReferenceIndex: ushort +
                // StringLength: ushort + StringConent: byte * 0 + ObjectEndMarker: byte
                Assert.AreEqual(buffer.Length, 45);
                Assert.IsTrue(reader.TryGetEcmaArray(buffer, out var readData, out var consumed));

                Assert.IsTrue(readData.SequenceEqual(array));
            }
        }
        public void TestArray()
        {
            var writer = new Amf0Writer();
            var reader = new Amf0Reader();

            var array = new List <object>()
            {
                1, 3.0, "string", new DateTime(2019, 2, 11), false, new List <object>()
                {
                    null, 3, "string2", "string2"
                }
            };

            using (var sc = new SerializationContext())
            {
                writer.WriteBytes(array, sc);
                var buffer = new byte[sc.MessageLength];
                sc.GetMessage(buffer);

                Assert.IsTrue(reader.TryGetStrictArray(buffer, out var val, out var consumed));
                Assert.IsTrue((double)val[0] == 1.0);
                Assert.IsTrue((double)val[1] == 3.0);
                Assert.IsTrue((string)val[2] == "string");
                Assert.IsTrue((DateTime)val[3] == new DateTime(2019, 2, 11));
                Assert.IsTrue((bool)val[4] == false);
                var e5 = (List <object>)val[5];

                Assert.IsTrue(e5[0] == null);
                Assert.IsTrue((double)e5[1] == 3.0);
                Assert.IsTrue((string)e5[2] == "string2");
                Assert.IsTrue((string)e5[3] == "string2");
            }
        }
        public void TestPacket()
        {
            var reader = new Amf0Reader();

            reader.RegisterType <RemotingMessage>();
            reader.StrictMode = false;
            using (var file = new FileStream("../../../../samples/amf0/misc/packet.amf0", FileMode.Open))
            {
                var data = new byte[file.Length];
                file.Read(data);
                Assert.IsTrue(reader.TryGetPacket(data, out var headers, out var messages, out var consumed));
                Assert.AreEqual(consumed, file.Length);
            }
        }
        public void TestReadUndefined()
        {
            var reader = new Amf0Reader();


            using (var f = new FileStream("../../../../samples/amf0/misc/undefined.amf0", FileMode.Open))
            {
                var data = new byte[f.Length];
                f.Read(data);

                Assert.IsTrue(reader.TryGetUndefined(data, out var dataRead, out var consumed));
                Assert.AreEqual(consumed, f.Length);
            }
        }
        public void TestReadLongString()
        {
            var reader = new Amf0Reader();


            using (var f = new FileStream("../../../../samples/amf0/misc/longstring.amf0", FileMode.Open))
            {
                var data = new byte[f.Length];
                f.Read(data);

                Assert.IsTrue(reader.TryGetLongString(data, out var dataRead, out var consumed));
                Assert.AreEqual(string.Concat(Enumerable.Repeat("abc", 32767)), dataRead);
                Assert.AreEqual(consumed, f.Length);
            }
        }
        public void TestNull()
        {
            var writer = new Amf0Writer();
            var reader = new Amf0Reader();

            using (var sc = new SerializationContext())
            {
                writer.WriteNullBytes(sc);
                var buffer = new byte[sc.MessageLength];
                sc.GetMessage(buffer);

                Assert.IsTrue(reader.TryGetNull(buffer, out var nullObj, out var consunmed));
                Assert.IsNull(nullObj);
                Assert.AreEqual(consunmed, buffer.Length);
            }
        }
        public void TestUndefined()
        {
            var writer = new Amf0Writer();
            var reader = new Amf0Reader();

            using (var sc = new SerializationContext())
            {
                writer.WriteBytes(new Undefined(), sc);
                var buffer = new byte[sc.MessageLength];
                sc.GetMessage(buffer);

                Assert.IsTrue(reader.TryGetUndefined(buffer, out var ud, out var consunmed));
                Assert.IsNotNull(ud);
                Assert.AreEqual(consunmed, buffer.Length);
            }
        }
        public void TestReadArray()
        {
            var reader = new Amf0Reader();


            using (var f = new FileStream("../../../../samples/amf0/misc/array.amf0", FileMode.Open))
            {
                var data = new byte[f.Length];
                f.Read(data);
                var arrayData = new List <object> {
                    1.0d, 2.0d, 3.0d, 4.0d, "a", "asdf", "eee"
                };
                Assert.IsTrue(reader.TryGetStrictArray(data, out var dataRead, out var consumed));
                Assert.IsTrue(arrayData.SequenceEqual(dataRead));
                Assert.AreEqual(consumed, data.Length);
            }
        }
        public void TestReadXml()
        {
            var reader = new Amf0Reader();


            using (var f = new FileStream("../../../../samples/amf0/misc/xml.amf0", FileMode.Open))
            {
                var data = new byte[f.Length];
                f.Read(data);

                Assert.IsTrue(reader.TryGetXmlDocument(data, out var dataRead, out var consumed));
                Assert.AreNotEqual(dataRead.GetElementsByTagName("a").Count, 0);
                Assert.AreNotEqual(dataRead.GetElementsByTagName("b").Count, 0);
                Assert.IsNotNull(dataRead.GetElementsByTagName("b")[0].Attributes["value"], "1");
                Assert.AreEqual(consumed, f.Length);
            }
        }
        public void TestReadDate()
        {
            var reader = new Amf0Reader();


            using (var f = new FileStream("../../../../samples/amf0/misc/date.amf0", FileMode.Open))
            {
                var data = new byte[f.Length];
                f.Read(data);

                Assert.IsTrue(reader.TryGetDate(data, out var dataRead, out var consumed));
                Assert.AreEqual(dataRead.Year, 2019);
                Assert.AreEqual(dataRead.Month, 2);
                Assert.AreEqual(dataRead.Day, 11);
                Assert.AreEqual(consumed, data.Length);
            }
        }
        public void TestReadBoolean()
        {
            var reader = new Amf0Reader();

            var files = Directory.GetFiles("../../../../samples/amf0/boolean");

            foreach (var file in files)
            {
                var value = bool.Parse(Path.GetFileNameWithoutExtension(file));
                using (var f = new FileStream(file, FileMode.Open))
                {
                    var data = new byte[f.Length];
                    f.Read(data);
                    Assert.IsTrue(reader.TryGetBoolean(data, out var dataRead, out var consumed));
                    Assert.AreEqual(dataRead, value);
                    Assert.AreEqual(consumed, f.Length);
                }
            }
        }
        public void TestLongString()
        {
            var writer = new Amf0Writer();
            var reader = new Amf0Reader();

            using (var sc = new SerializationContext())
            {
                for (int i = 0; i < 1000; i++)
                {
                    var val = string.Concat(Enumerable.Repeat(Guid.NewGuid().ToString(), 2000));
                    writer.WriteBytes(val, sc);
                    var buffer = new byte[sc.MessageLength];
                    sc.GetMessage(buffer);

                    reader.TryGetLongString(buffer, out var readValue, out var consumed);
                    Assert.AreEqual(val, readValue);
                    Assert.AreEqual(buffer.Length, consumed);
                }
            }
        }
        public void TestXml()
        {
            var writer = new Amf0Writer();
            var reader = new Amf0Reader();

            using (var sc = new SerializationContext())
            {
                var xml  = new XmlDocument();
                var elem = xml.CreateElement("price");
                xml.AppendChild(elem);
                writer.WriteBytes(xml, sc);
                var buffer = new byte[sc.MessageLength];
                sc.GetMessage(buffer);

                Assert.IsTrue(reader.TryGetXmlDocument(buffer, out var ud, out var consunmed));
                Assert.IsNotNull(ud);
                Assert.AreNotEqual(ud.GetElementsByTagName("price").Count, 0);
                Assert.AreEqual(consunmed, buffer.Length);
            }
        }
        public void TestReadObject()
        {
            var reader = new Amf0Reader();

            // pyamf has a bug about element count of ecma array
            // https://github.com/hydralabs/pyamf/blob/master/pyamf/amf0.py#L567
            reader.StrictMode = false;

            using (var f = new FileStream("../../../../samples/amf0/misc/object.amf0", FileMode.Open))
            {
                var data = new byte[f.Length];
                f.Read(data);

                Assert.IsTrue(reader.TryGetObject(data, out var dataRead, out var consumed));
                Assert.IsTrue(dataRead.Fields.SequenceEqual(new Dictionary <string, object>()
                {
                    ["a"] = "b", ["c"] = 1.0
                }));
                Assert.AreEqual(consumed, data.Length);
            }
        }
        public void TestNumber()
        {
            var random = new Random();
            var writer = new Amf0Writer();
            var reader = new Amf0Reader();

            using (var sc = new SerializationContext())
            {
                for (int i = 0; i < 1000; i++)
                {
                    var num = random.NextDouble() * 10 - 5;
                    writer.WriteBytes(num, sc);
                    var buffer = new byte[sc.MessageLength];
                    sc.GetMessage(buffer);

                    reader.TryGetNumber(buffer, out var readValue, out var consumed);
                    Assert.AreEqual(num, readValue);
                    Assert.AreEqual(buffer.Length, consumed);
                }
            }
        }
        public void TestDate()
        {
            var writer = new Amf0Writer();
            var reader = new Amf0Reader();

            var date = DateTime.Now;

            using (var sc = new SerializationContext())
            {
                writer.WriteBytes(date, sc);
                var buffer = new byte[sc.MessageLength];
                sc.GetMessage(buffer);

                Assert.IsTrue(reader.TryGetDate(buffer, out var val, out var consumed));
                Assert.AreEqual(val.Date, date.Date);
                Assert.AreEqual(val.Hour, date.Hour);
                Assert.AreEqual(val.Minute, date.Minute);
                Assert.AreEqual(val.Second, date.Second);
                Assert.AreEqual(val.Millisecond, date.Millisecond);
                Assert.AreEqual(val.Kind, date.Kind);
                Assert.AreEqual(consumed, buffer.Length);
            }
        }
        public void TestBoolean()
        {
            var writer = new Amf0Writer();
            var reader = new Amf0Reader();

            using (var sc = new SerializationContext())
            {
                writer.WriteBytes(true, sc);
                var buffer = new byte[sc.MessageLength];
                sc.GetMessage(buffer);

                Assert.IsTrue(reader.TryGetBoolean(buffer, out var val, out var consumed));
                Assert.IsTrue(val);
                Assert.AreEqual(consumed, buffer.Length);

                writer.WriteBytes(false, sc);
                buffer = new byte[sc.MessageLength];
                sc.GetMessage(buffer);

                Assert.IsTrue(reader.TryGetBoolean(buffer, out val, out consumed));
                Assert.IsFalse(val);
                Assert.AreEqual(consumed, buffer.Length);
            }
        }