public void ReadObject()
        {
            const string hexBuffer =
                "A666737472696E6763666F6F666E756D626572FB40283D70A3D70A3D64626F6F6CF5646E756C6CF6656172726179820102666F626A656374A162696401";
            CborObject actualObject = Helper.Read <CborObject>(hexBuffer);

            Assert.NotNull(actualObject);

            // pairs
            Assert.Equal(6, actualObject.Count);

            // string
            Assert.True(actualObject.TryGetValue("string", out CborValue value));
            Assert.Equal(CborValueType.String, value.Type);
            Assert.IsType <CborString>(value);
            Assert.Equal("foo", value.Value <string>());

            // number
            Assert.True(actualObject.TryGetValue("number", out value));
            Assert.Equal(CborValueType.Double, value.Type);
            Assert.IsType <CborDouble>(value);
            Assert.Equal(12.12, value.Value <double>(), 3);

            // bool
            Assert.True(actualObject.TryGetValue("bool", out value));
            Assert.Equal(CborValueType.Boolean, value.Type);
            Assert.IsType <CborBoolean>(value);
            Assert.True(value.Value <bool>());

            // null
            Assert.True(actualObject.TryGetValue("null", out value));
            Assert.Equal(CborValueType.Null, value.Type);
            Assert.IsType <CborNull>(value);

            // array
            Assert.True(actualObject.TryGetValue("array", out value));
            Assert.Equal(CborValueType.Array, value.Type);
            Assert.IsType <CborArray>(value);
            CborArray CborArray = (CborArray)value;

            Assert.Equal(2, CborArray.Count);
            Assert.Equal(1, CborArray[0].Value <double>());
            Assert.Equal(2, CborArray[1].Value <double>());

            // object
            Assert.True(actualObject.TryGetValue("object", out value));
            Assert.Equal(CborValueType.Object, value.Type);
            Assert.IsType <CborObject>(value);
            CborObject cborObject = (CborObject)value;

            Assert.True(cborObject.TryGetValue("id", out value));
            Assert.Equal(CborValueType.Positive, value.Type);
            Assert.Equal(1, value.Value <int>());
        }
        public void FromObject()
        {
            SimpleObject obj = new SimpleObject
            {
                Boolean  = true,
                Byte     = 12,
                SByte    = 13,
                Int16    = 14,
                UInt16   = 15,
                Int32    = 16,
                UInt32   = 17u,
                Int64    = 18,
                UInt64   = 19ul,
                Single   = 20.21f,
                Double   = 22.23,
                Decimal  = 2.71828m,
                String   = "string",
                DateTime = new DateTime(2014, 02, 21, 19, 0, 0, DateTimeKind.Utc),
                Enum     = EnumTest.Value1
            };

            CborObject actual = CborObject.FromObject(obj);

            Assert.NotNull(actual);

            // pairs
            Assert.Equal(15, actual.Count);

            // Boolean
            Assert.True(actual.TryGetValue("Boolean", out CborValue value));
            Assert.Equal(CborValueType.Boolean, value.Type);
            Assert.True(value.Value <bool>());

            // Byte
            Assert.True(actual.TryGetValue("Byte", out value));
            Assert.Equal(CborValueType.Positive, value.Type);
            Assert.Equal(12, value.Value <byte>());

            // SByte
            Assert.True(actual.TryGetValue("SByte", out value));
            Assert.Equal(CborValueType.Positive, value.Type);
            Assert.Equal(13, value.Value <sbyte>());

            // Int16
            Assert.True(actual.TryGetValue("Int16", out value));
            Assert.Equal(CborValueType.Positive, value.Type);
            Assert.Equal(14, value.Value <short>());

            // UInt16
            Assert.True(actual.TryGetValue("UInt16", out value));
            Assert.Equal(CborValueType.Positive, value.Type);
            Assert.Equal(15, value.Value <ushort>());

            // Int32
            Assert.True(actual.TryGetValue("Int32", out value));
            Assert.Equal(CborValueType.Positive, value.Type);
            Assert.Equal(16, value.Value <int>());

            // UInt32
            Assert.True(actual.TryGetValue("UInt32", out value));
            Assert.Equal(CborValueType.Positive, value.Type);
            Assert.Equal(17u, value.Value <uint>());

            // Int64
            Assert.True(actual.TryGetValue("Int64", out value));
            Assert.Equal(CborValueType.Positive, value.Type);
            Assert.Equal(18L, value.Value <long>());

            // UInt64
            Assert.True(actual.TryGetValue("UInt64", out value));
            Assert.Equal(CborValueType.Positive, value.Type);
            Assert.Equal(19ul, value.Value <ulong>());

            // Single
            Assert.True(actual.TryGetValue("Single", out value));
            Assert.Equal(CborValueType.Single, value.Type);
            Assert.Equal(20.21f, value.Value <float>());

            // UInt64
            Assert.True(actual.TryGetValue("Double", out value));
            Assert.Equal(CborValueType.Double, value.Type);
            Assert.Equal(22.23, value.Value <double>());

            // Decimal
            Assert.True(actual.TryGetValue("Decimal", out value));
            Assert.Equal(CborValueType.Decimal, value.Type);
            Assert.Equal(2.71828m, value.Value <decimal>());

            // String
            Assert.True(actual.TryGetValue("String", out value));
            Assert.Equal(CborValueType.String, value.Type);
            Assert.Equal("string", value.Value <string>());

            // DateTime
            Assert.True(actual.TryGetValue("DateTime", out value));
            Assert.Equal(CborValueType.String, value.Type);
            Assert.Equal("2014-02-21T19:00:00Z", value.Value <string>());

            // Enum
            Assert.True(actual.TryGetValue("Enum", out value));
            Assert.Equal(CborValueType.Positive, value.Type);
            Assert.Equal((int)EnumTest.Value1, value.Value <int>());
        }
        public void ReadArray()
        {
            string    hexBuffer   = "8663666F6FFB40283D70A3D70A3DF5F6820102A162696401";
            CborArray actualArray = Helper.Read <CborArray>(hexBuffer);

            Assert.NotNull(actualArray);

            // values
            Assert.Equal(6, actualArray.Count);

            // string
            CborValue actualString = actualArray[0];

            Assert.NotNull(actualString);
            Assert.Equal(CborValueType.String, actualString.Type);
            Assert.IsType <CborString>(actualString);
            Assert.Equal("foo", actualString.Value <string>());

            // number
            CborValue actualNumber = actualArray[1];

            Assert.NotNull(actualNumber);
            Assert.Equal(CborValueType.Double, actualNumber.Type);
            Assert.IsType <CborDouble>(actualNumber);
            Assert.Equal(12.12, actualNumber.Value <double>(), 3);

            // bool
            CborValue actualBool = actualArray[2];

            Assert.NotNull(actualBool);
            Assert.Equal(CborValueType.Boolean, actualBool.Type);
            Assert.IsType <CborBoolean>(actualBool);
            Assert.True(actualBool.Value <bool>());

            // null
            CborValue actualNull = actualArray[3];

            Assert.NotNull(actualNull);
            Assert.Equal(CborValueType.Null, actualNull.Type);

            // array
            CborValue actualArrayValue = actualArray[4];

            Assert.NotNull(actualArrayValue);
            Assert.Equal(CborValueType.Array, actualArrayValue.Type);
            Assert.IsType <CborArray>(actualArrayValue);
            CborArray CborArray = (CborArray)actualArrayValue;

            Assert.Equal(2, CborArray.Count);
            Assert.Equal(1, CborArray[0].Value <double>());
            Assert.Equal(2, CborArray[1].Value <double>());

            // object
            CborValue actualObject = actualArray[5];

            Assert.NotNull(actualObject);
            Assert.Equal(CborValueType.Object, actualObject.Type);
            Assert.IsType <CborObject>(actualObject);
            CborObject cborObject = (CborObject)actualObject;

            Assert.True(cborObject.TryGetValue("id", out CborValue value));
            Assert.Equal(CborValueType.Positive, value.Type);
            Assert.Equal(1, value.Value <int>());
        }