public void CreateFromDynamicComplextTest()
        {
            JsonValue target;
            Person    person = AnyInstance.AnyPerson;
            dynamic   dyn    = TestDynamicObject.CreatePersonAsDynamic(person);

            dyn.TestProperty = AnyInstance.AnyString;

            target = JsonValueExtensions.CreateFrom(dyn);
            Assert.NotNull(target);
            Assert.Equal <string>(AnyInstance.AnyString, dyn.TestProperty);
            Person jvPerson = target.ReadAsType <Person>();

            Assert.Equal(person.ToString(), jvPerson.ToString());

            Person p1 = Person.CreateSample();
            Person p2 = Person.CreateSample();

            p2.Name         += "__2";
            p2.Age          += 10;
            p2.Address.City += "__2";

            Person[] friends = new Person[] { p1, p2 };
            target = JsonValueExtensions.CreateFrom(friends);
            Person[] personArr = target.ReadAsType <Person[]>();
            Assert.Equal <int>(friends.Length, personArr.Length);
            Assert.Equal <string>(friends[0].ToString(), personArr[0].ToString());
            Assert.Equal <string>(friends[1].ToString(), personArr[1].ToString());
        }
        public void ReadAsTypeFallbackTest()
        {
            JsonValue jv             = AnyInstance.AnyInt;
            Person    personFallback = Person.CreateSample();

            Person personResult = jv.ReadAsType <Person>(personFallback);

            Assert.Same(personFallback, personResult);

            int intFallback = 45;
            int intValue    = jv.ReadAsType <int>(intFallback);

            Assert.Equal <int>(AnyInstance.AnyInt, intValue);
        }
Exemplo n.º 3
0
        public void DynamicNotationTest()
        {
            bool      boolValue;
            JsonValue jsonValue;

            Person  person = Person.CreateSample();
            dynamic jo     = JsonValueExtensions.CreateFrom(person);

            dynamic target = jo;

            Assert.Equal <int>(person.Age, target.Age.ReadAs <int>());                                                        // JsonPrimitive
            Assert.Equal <string>(person.Address.ToString(), ((JsonObject)target.Address).ReadAsType <Address>().ToString()); // JsonObject

            target = jo.Address.City;                                                                                         // JsonPrimitive
            Assert.NotNull(target);
            Assert.Equal <string>(target.ReadAs <string>(), person.Address.City);

            target = jo.Friends;  // JsonArray
            Assert.NotNull(target);
            jsonValue = target as JsonValue;
            Assert.Equal <int>(person.Friends.Count, jsonValue.ReadAsType <List <Person> >().Count);

            target = jo.Friends[1].Address.City;
            Assert.NotNull(target);
            Assert.Equal <string>(target.ReadAs <string>(), person.Address.City);

            target = jo.Address.NonExistentProp.NonExistentProp2; // JsonObject (default)
            Assert.NotNull(target);
            Assert.True(jo is JsonObject);
            Assert.False(target.TryReadAs <bool>(out boolValue));
            Assert.True(target.TryReadAs <JsonValue>(out jsonValue));
            Assert.Same(target, jsonValue);

            Assert.Same(jo.Address.NonExistent, AnyInstance.DefaultJsonValue);
            Assert.Same(jo.Friends[1000], AnyInstance.DefaultJsonValue);
            Assert.Same(jo.Age.NonExistentProp, AnyInstance.DefaultJsonValue);
            Assert.Same(jo.Friends.NonExistentProp, AnyInstance.DefaultJsonValue);
        }