public void ObjectMapConfig_Map_ClassPropertyMapMode_NullProperty_NewObject()
        {
            var config = new ObjectMapConfig();

            config.ClassPropertyMapMode = ClassPropertyMapMode.NewObject;
            config.MaxCallStackCount    = 100;

            var u1 = new User();

            u1.ParentUser = new User("ParentUser1");
            u1.Dictionary = new Dictionary <string, string>();
            var u2 = new User();

            u2.ParentUser = null;
            u2.Dictionary = null;
            config.Map(u1, u2);

            Assert.IsNotNull(u2.ParentUser);
            Assert.IsNotNull(u2.Dictionary);
            Assert.AreEqual("ParentUser1", u2.ParentUser.Name);

            u1.ParentUser.Name = "ParentUserChanged";
            //Difference object
            Assert.AreNotEqual("ParentUserChanged", u2.ParentUser.Name);
        }
        public void ObjectMapConfig_AddPostAction_Encoding()
        {
            var config = new ObjectMapConfig();

            config.AddPostAction <String, Encoding>((source, target) =>
            {
                if (source == "U8")
                {
                    return(Encoding.UTF8);
                }
                return(null);
            });

            config.PropertyMapRules.Clear();
            var rule = new PropertyNameMappingRule();

            rule.AddPropertyNameMap("Value", "Encoding");
            config.PropertyMapRules.Add(rule);

            var u1 = new User();

            u1.Value = "U8";
            var p2 = new TextParser();

            p2.Encoding = null;
            config.Map(u1, p2);

            Assert.AreEqual(Encoding.UTF8, p2.Encoding);
        }
        public void ObjectMapConfig_Map_CollectionElementMapMode_CollectionElement_None()
        {
            var config = new ObjectMapConfig();

            config.CollectionElementMapMode = CollectionElementMapMode.None;

            var u1 = new User();

            for (int i = 0; i < 3; i++)
            {
                u1.Users.Add(new User("TestUser" + i.ToString()));
            }
            var u2 = config.Map(u1, new User());

            config.AddPostAction <User, User>((source, target) =>
            {
                if (source == null)
                {
                    return;
                }
                target.Users.AddRange(source.Users);
            });
            var u3 = config.Map(u1, new User());

            Assert.AreEqual(0, u2.Users.Count);
            Assert.AreEqual(3, u3.Users.Count);
        }
        public void ObjectMapConfig_Map_Dictionary_Object()
        {
            var config = new ObjectMapConfig();

            var d = new Dictionary <String, String>();

            d["Name"]         = "N";
            d["Int32"]        = "46";
            d["Decimal"]      = "46.46";
            d["DateTime"]     = "2014/12/17";
            d["DayOfWeek"]    = "Friday";
            d["GuidNullable"] = "7195FBEF-B18C-BC29-E339-39DDC81FC90F";
            var u1 = new User();

            u1.Value = "Value1";
            var u2 = config.Map(d, u1);

            Assert.AreEqual("Value1", u2.Value);
            Assert.AreEqual("N", u2.Name);
            Assert.AreEqual(46, u2.Int32);
            Assert.AreEqual(46.46m, u2.Decimal);
            Assert.AreEqual(new DateTime(2014, 12, 17), u2.DateTime);
            Assert.AreEqual(DayOfWeek.Friday, u2.DayOfWeek);
            Assert.AreEqual(new Guid("7195FBEF-B18C-BC29-E339-39DDC81FC90F"), u2.GuidNullable);
        }
        public void ObjectMapConfig_CustomPropertyMappingRule()
        {
            var config = new ObjectMapConfig();

            config.PropertyMapRules.Clear();
            var rule = new PropertyNameMappingRule();

            rule.AddPropertyNameMap("Value", "Int32");
            rule.AddPropertyNameMap("Value", "DateTime");
            rule.AddPropertyNameMap("Value", "Decimal");
            rule.AddPropertyNameMap("Value", "DayOfWeek");
            config.PropertyMapRules.Add(rule);

            var u1 = new User();
            {
                u1.Value = "23";
                var u2 = config.Map(u1, new User());
                Assert.AreEqual(23, u2.Int32);
            }
            {
                u1.Value = "2014/12/17 00:00:00";
                var u2 = config.Map(u1, new User());
                Assert.AreEqual(new DateTime(2014, 12, 17), u2.DateTime);
            }
            {
                u1.Value = "23.4";
                var u2 = config.Map(u1, new User());
                Assert.AreEqual(23.4m, u2.Decimal);
            }
            {
                u1.Value = "Friday";
                var u2 = config.Map(u1, new User());
                Assert.AreEqual(DayOfWeek.Friday, u2.DayOfWeek);
            }
        }
        public void ObjectMapConfig_Map_ValueType_Object()
        {
            var config = new ObjectMapConfig();

            var v1 = new Vector2(3, 6);
            var u1 = config.Map(v1, new UserFlatten());

            Assert.AreEqual(u1.X, v1.X);
        }
        public void ObjectMapConfig_Map_SubClass_ListProperty()
        {
            var config = new ObjectMapConfig();

            var s1 = new Schedule();

            s1.UserList.Add(new User("Test1"));
            var s2 = config.Map(s1, new AllDaySchedule());

            Assert.AreEqual(1, s2.UserList.Count);
        }
        public void ObjectMapConfig_Map_CollectionElementMapMode_InfiniteLoop()
        {
            var config = new ObjectMapConfig();

            config.CollectionElementMapMode = CollectionElementMapMode.NewObject;

            var n1 = new TreeNode();

            n1.Nodes = new List <TreeNode>();
            n1.Nodes.Add(n1);
            var n2 = config.Map(n1, new TreeNode());
        }
        public void ObjectMapConfig_Map_Dictionary_Object_Convert_Failure()
        {
            var config = new ObjectMapConfig();

            var d = new Dictionary <String, String>();

            d["Decimal"] = "abc";
            var u2 = config.Map(d, new User());

            //Not changed...
            Assert.AreEqual(20.4m, u2.Decimal);
        }
        public void ObjectMapConfig_Map_List_List()
        {
            var config = new ObjectMapConfig();

            var l1 = new List <User>();

            l1.Capacity = 100;
            l1.Add(new User());
            var l2 = config.Map(l1, new List <User>());

            Assert.AreEqual(0, l2.Count);
            Assert.AreEqual(100, l2.Capacity);
        }
        public void ObjectMapConfig_Map_NullListProperty_NewObject()
        {
            var config = new ObjectMapConfig();

            config.ClassPropertyMapMode = ClassPropertyMapMode.NewObject;
            var u1 = new User();
            var u2 = new User();

            u2.Users = null;
            config.Map(u1, u2);

            Assert.IsNotNull(u2.Users);
        }
        public void ObjectMapConfig_Map_SubClass_UserProperty()
        {
            var config = new ObjectMapConfig();

            config.ClassPropertyMapMode = ClassPropertyMapMode.None;

            var s1 = new Schedule();

            s1.CreateUser = new User("Test1");
            var s2 = config.Map(s1, new AllDaySchedule());

            Assert.IsNull(s2.CreateUser);
        }
        public void ObjectMapConfig_AddPostAction_IUser()
        {
            var config = new ObjectMapConfig();

            config.AddPostAction <User, IUser>((source, target) =>
            {
                //Do nothing...
            });
            var u1 = new User();
            var u2 = config.Map(u1, new User());

            Assert.AreEqual(u1.Name, u2.Name);
        }
        public void ObjectMapConfig_Map_Object_ValueType()
        {
            var config = new ObjectMapConfig();

            var u1 = new UserFlatten();

            u1.X = 5;
            u1.Y = 7;
            var v1 = config.Map(u1, new Vector2(3, 6));

            Assert.AreEqual(u1.X, v1.X);
            Assert.AreEqual(u1.Y, v1.Y);
        }
        public void ObjectMapConfig_RemoveAllPropertyMap()
        {
            var config = new ObjectMapConfig();

            config.RemovePropertyMap <User, User>();

            var u1 = new User();

            u1.Value = "23.456";
            var u2 = config.Map(u1, new User());

            Assert.AreNotEqual(u1.Value, u2.Value);
        }
Exemple #16
0
        static Program()
        {
            ObjectMapConfig.Configure();
            var containerBuilder = new ContainerBuilder();

            containerBuilder.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
            containerBuilder.RegisterModule(new DataModule());
            containerBuilder.RegisterModule(new ServiceModule());
            using (var container = containerBuilder.Build())
            {
                OrgUserService = container.Resolve <IOrgUserService>();
            }
        }
Exemple #17
0
        public void ObjectMapConfig_Map_List_List_ValueType()
        {
            var config = new ObjectMapConfig();

            var l1 = new VectorInfo();

            l1.Vectors.Add(new Vector2()
            {
                X = 1, Y = 2
            });
            var l2 = config.Map(l1, new VectorInfo());

            Assert.AreEqual(1, l2.Vectors[0].X);
        }
        public void ObjectMapConfig_Map_Object_Dictionary()
        {
            var config = new ObjectMapConfig();

            var u1 = new User();
            var d  = config.Map(u1, new Dictionary <String, Object>());

            Assert.AreEqual(u1.Name, d["Name"]);
            Assert.AreEqual(u1.Int32, d["Int32"]);
            Assert.AreEqual(u1.Decimal, d["Decimal"]);
            Assert.AreEqual(u1.DateTime, d["DateTime"]);
            Assert.AreEqual(u1.DayOfWeek, d["DayOfWeek"]);
            Assert.AreEqual(u1.MapPoint, d["MapPoint"]);
        }
        public void ObjectMapConfig_Map_Dictionary_Encoding()
        {
            var config = new ObjectMapConfig();

            var d = new Dictionary <String, String>();

            d["Encoding"] = "UTF-8";
            var p1 = new TextParser();

            p1.Encoding = Encoding.ASCII;
            var p2 = config.Map(d, p1);

            Assert.AreEqual(Encoding.UTF8, p2.Encoding);
        }
        public void ObjectMapConfig_Map_List_ReadonlyList()
        {
            var config = new ObjectMapConfig();

            var l1 = new VectorList();

            l1.ReadonlyVectors.Add(new Vector2()
            {
                X = 1, Y = 2
            });
            var l2 = config.Map(l1, new VectorList());

            Assert.AreEqual(1, l2.ReadonlyVectors[0].X);
        }
Exemple #21
0
        public void ObjectMapConfig_Map_Object_Object_SetNullablePropertyToNull()
        {
            var config = new ObjectMapConfig();

            var u1 = new User();

            u1.DecimalNullable = null;
            var u2 = config.Map(u1, new User()
            {
                DecimalNullable = 23.4m
            });

            Assert.IsNull(u2.DecimalNullable);
        }
        public void ObjectMapConfig_Map_ByteArrayProperty()
        {
            var config = new ObjectMapConfig();

            config.ClassPropertyMapMode = ClassPropertyMapMode.NewObject;

            var u1 = new User();

            u1.Timestamp = new Byte[] { 1, 3, 6 };

            var u2 = config.Map(u1, new User());

            Assert.AreEqual(u1.Timestamp[2], u2.Timestamp[2]);
        }
        public void ObjectMapConfig_IgnoreUnderscorePropertyMappingRule()
        {
            var config = new ObjectMapConfig();

            var rule = new IgnoreUnderscorePropertyMappingRule();

            config.PropertyMapRules.Add(rule);

            var u1 = new User();

            u1.Int32Nullable = 3;
            var u2 = config.Map(u1, new User());

            Assert.AreEqual(u1.Int32Nullable, u2.Int32_Nullable);
        }
        public void ObjectMapConfig_Map_Inherit_New_List_Property()
        {
            var config = new ObjectMapConfig();

            var s1 = new ScheduleRecord();

            s1.Title     = "s1";
            s1.StartTime = new DateTimeOffset();
            s1.EndTime   = new DateTimeOffset();
            var s2 = new ScheduleRecordChild();

            config.Map(s1, s2);

            Assert.AreEqual(s1.Title, s2.Title);
        }
        public void ObjectMapConfig_CustomPropertyMappingRule()
        {
            var config = new ObjectMapConfig();
            config.PropertyMapRules.Clear();
            var rule = new SuffixPropertyMappingRule("Nullable");
            config.PropertyMapRules.Add(rule);

            var u1 = new User();
            var u2 = config.Map(u1, new User());

            Assert.AreEqual(u1.Name, u2.Name);
            Assert.AreEqual(u1.Int32, u2.Int32Nullable);
            Assert.AreEqual(u1.Decimal, u2.DecimalNullable);
            Assert.AreEqual(u1.DateTime, u2.DateTimeNullable);
            Assert.AreEqual(u1.DayOfWeek, u2.DayOfWeekNullable);
        }
        public void ObjectMapConfig_CustomStructConverter()
        {
            var config = new ObjectMapConfig();
            config.AddConverter(DayOfWeekConverter);

            config.PropertyMapRules.Clear();
            var rule = new PropertyNameMappingRule();
            rule.PropertyNameMaps.Add("Value", "DayOfWeek");
            config.PropertyMapRules.Add(rule);

            var u1 = new User();
            u1.Value = "Friday";
            var u2 = config.Map(u1, new User());

            Assert.AreEqual(DayOfWeek.Friday, u2.DayOfWeek);
        }
        public void ObjectMapConfig_CustomDictionaryMappingRule()
        {
            var config = new ObjectMapConfig();

            var rule = new DictionaryKeyMappingRule(DictionaryMappingDirection.DictionaryToObject, typeof(User), TypeFilterCondition.Inherit);

            rule.AddMap("Int32Nullable", "int_nullable");
            config.DictionaryMappingRules.Add(rule);

            var d = new Dictionary <String, String>();

            d["int_nullable"] = "8";
            var u2 = config.Map(d, new User());

            Assert.AreEqual(8, u2.Int32Nullable);
        }
        public void ObjectMapConfig_Map_Dictionary_ClassPropertyMapMode_NewObject()
        {
            var config = new ObjectMapConfig();

            config.ClassPropertyMapMode = ClassPropertyMapMode.NewObject;

            var d = new Dictionary <String, String>();

            d["Int32Nullable"] = "abc";
            var u2 = new User();

            u2.Int32Nullable = null;
            config.Map(d, u2);

            Assert.AreEqual(null, u2.Int32Nullable);
        }
        public void ObjectMapConfig_Map_CollectionElementMapMode_CollectionElement_NewObject_NoDefaultConstructor()
        {
            var config = new ObjectMapConfig();

            config.CollectionElementMapMode = CollectionElementMapMode.NewObject;

            var u1 = new List <User>();

            for (int i = 0; i < 3; i++)
            {
                u1.Add(new User("TestUser" + i.ToString()));
            }
            var u2 = config.Map(u1, new List <UserNoDefaultConstructor>());

            Assert.AreEqual(0, u2.Count);
        }
        public void ObjectMapConfig_Map_Flatten()
        {
            var config = new ObjectMapConfig();

            config.AddPostAction <User, UserFlatten>((source, target) =>
            {
                source.Vector2.Map(target);
                source.MapPoint.Map(target);
            });
            var u1 = new User();
            var u2 = config.Map(u1, new UserFlatten());

            Assert.AreEqual(u1.MapPoint.Latitude, u2.Latitude);
            Assert.AreEqual(u1.MapPoint.Longitude, u2.Longitude);
            Assert.AreEqual(u1.Vector2.X, u2.X);
        }
        public void ObjectMapConfig_ReplacePropertyMap()
        {
            var config = new ObjectMapConfig();

            config.ReplacePropertyMap <User, User>((source, target) =>
            {
                target.Decimal = Decimal.Parse(source.Value);
            });

            var u1 = new User();

            u1.Value = "23.456";
            var u2 = config.Map(u1, new User());

            Assert.AreNotEqual(u1.Value, u2.Value);
            Assert.AreEqual(23.456m, u2.Decimal);
        }
        public void ObjectMapConfig_RemovePropertyMap()
        {
            var config = new ObjectMapConfig();

            config.RemovePropertyMap <User, VipUser>("Timestamp");

            var u1 = new User();

            u1.Timestamp = new Byte[] { 1, 3, 6 };

            var u2 = config.Map(u1, new VipUser());

            Assert.IsNull(u2.Timestamp);

            Assert.AreEqual(u1.MapPoint.Latitude, u2.MapPoint.Latitude);
            Assert.AreEqual(u1.MapPoint.Longitude, u2.MapPoint.Longitude);
        }
        public void ObjectMapConfig_CustomClassConverter()
        {
            var config = new ObjectMapConfig();
            config.AddConverter<MapPoint>(MapPointConverter);

            config.PropertyMapRules.Clear();
            var rule = new PropertyNameMappingRule();
            rule.PropertyNameMaps.Add("Value", "MapPoint");
            config.PropertyMapRules.Add(rule);

            var u1 = new User();
            u1.Value = "23, 45";
            var u2 = config.Map(u1, new User());

            Assert.AreEqual(23m, u2.MapPoint.Latitude);
            Assert.AreEqual(45m, u2.MapPoint.Longitude);
        }
        public void ObjectMapConfig_DefaultTypeConverter()
        {
            var config = new ObjectMapConfig();
            var rules = config.PropertyMapRules.ToArray();
            config.PropertyMapRules.Clear();

            config.PropertyMapRules.Clear();
            var rule = new PropertyNameMappingRule();
            rule.PropertyNameMaps.Add("Value", "Int32");
            rule.PropertyNameMaps.Add("Value", "DateTime");
            rule.PropertyNameMaps.Add("Value", "Decimal");
            rule.PropertyNameMaps.Add("Value", "DayOfWeek");
            config.PropertyMapRules.Add(rule);

            var u1 = new User();
            {
                u1.Value = "23";
                var u2 = config.Map(u1, new User());
                Assert.AreEqual(23, u2.Int32);
            }
            {
                u1.Value = "2014/12/17 00:00:00";
                var u2 = config.Map(u1, new User());
                Assert.AreEqual(new DateTime(2014, 12, 17), u2.DateTime);
            }
            {
                u1.Value = "23.4";
                var u2 = config.Map(u1, new User());
                Assert.AreEqual(23.4m, u2.Decimal);
            }
            {
                u1.Value = "Friday";
                var u2 = config.Map(u1, new User());
                Assert.AreEqual(DayOfWeek.Friday, u2.DayOfWeek);
            }
        }
        public void ObjectMapConfig_Map_Dictionary_Object()
        {
            var config = new ObjectMapConfig();

            var d = new Dictionary<String, String>();
            d["Name"] = "N";
            d["Int32"] = "46";
            d["Decimal"] = "46.46";
            d["DateTime"] = "2014/12/17";
            d["DayOfWeek"] = "Friday";
            var u2 = config.Map(d, new User());

            Assert.AreEqual("N", u2.Name);
            Assert.AreEqual(46, u2.Int32);
            Assert.AreEqual(46.46m, u2.Decimal);
            Assert.AreEqual(new DateTime(2014, 12,17), u2.DateTime);
            Assert.AreEqual(DayOfWeek.Friday, u2.DayOfWeek);
        }
        public void ObjectMapConfig_Map_Dictionary_Object_Convert_Failure()
        {
            var config = new ObjectMapConfig();

            var d = new Dictionary<String, String>();
            d["Decimal"] = "abc";
            var u2 = config.Map(d, new User());
            //Not changed...
            Assert.AreEqual(20.4m, u2.Decimal);
        }
        public void ObjectMapConfig_Map_FromDecimalToInt32()
        {
            var config = new ObjectMapConfig();
            config.PropertyMapRules.Clear();

            var rule = new PropertyNameMappingRule();
            rule.PropertyNameMaps.Add("Int32", "Decimal");
            config.PropertyMapRules.Add(rule);

            var u1 = new User();
            u1.Int32 = 23;
            var u2 = config.Map(u1, new User());

            Assert.AreEqual(23m, u2.Decimal);
        }
        public void ObjectMapConfig_Map_Object_Object_Convert_Failure()
        {
            var config = new ObjectMapConfig();
            config.PropertyMapRules.Clear();

            var rule = new PropertyNameMappingRule();
            rule.PropertyNameMaps.Add("Value", "Decimal");
            config.PropertyMapRules.Add(rule);

            var u1 = new User();
            u1.Value = "abc";
            var u2 = config.Map(u1, new User());
            //Not changed...
            Assert.AreEqual(20.4m, u2.Decimal);
        }
        public void ObjectMapConfig_Map_List_List()
        {
            var config = new ObjectMapConfig();

            var l1 = new List<User>();
            l1.Capacity = 100;
            l1.Add(new User());
            var l2 = config.Map(l1, new List<User>());

            Assert.AreEqual(0, l2.Count);
            Assert.AreEqual(100, l2.Capacity);
        }
 public void ObjectMapConfig_Map_ManyProperty()
 {
     var config = new ObjectMapConfig();
     var p1 = new Person();
     var p2 = p1.Map(new Person());
 }
        public void ObjectMapConfig_RemovePropertyMap()
        {
            var config = new ObjectMapConfig();
            config.PropertyMapRules.Clear();
            var rule = new SuffixPropertyMappingRule("Nullable");
            config.PropertyMapRules.Add(rule);
            config.RemovePropertyMap<User, User>(new String[] { "DecimalNullable", "DateTimeNullable", "DayOfWeekNullable" }, null);

            var u1 = new User();
            var u2 = config.Map(u1, new User());

            Assert.AreEqual(u1.Name, u2.Name);
            Assert.AreEqual(u1.Int32, u2.Int32Nullable);
            Assert.IsNull(u2.DecimalNullable);
            Assert.IsNull(u2.DateTimeNullable);
            Assert.IsNull(u2.DayOfWeekNullable);

            Assert.AreEqual(u1.MapPoint.Latitude, u2.MapPoint.Latitude);
            Assert.AreEqual(u1.MapPoint.Longitude, u2.MapPoint.Longitude);
        }
        public void ObjectMapConfig_Map_Object_Dictionary()
        {
            var config = new ObjectMapConfig();

            var u1 = new User();
            var d = config.Map(u1, new Dictionary<String, Object>());

            Assert.AreEqual(u1.Name, d["Name"]);
            Assert.AreEqual(u1.Int32, d["Int32"]);
            Assert.AreEqual(u1.Decimal, d["Decimal"]);
            Assert.AreEqual(u1.DateTime, d["DateTime"]);
            Assert.AreEqual(u1.DayOfWeek, d["DayOfWeek"]);
            Assert.AreEqual(u1.MapPoint, d["MapPoint"]);
        }
        public void ObjectMapConfig_Map_Object_Object_SetNullablePropertyToNull()
        {
            var config = new ObjectMapConfig();

            var u1 = new User();
            u1.DecimalNullable = null;
            var u2 = config.Map(u1, new User() { DecimalNullable = 23.4m });

            Assert.IsNull(u2.DecimalNullable);
        }
        public void ObjectMapConfig_Map_ArrayProperty()
        {
            var config = new ObjectMapConfig();
            config.AddConverter<String[]>(o =>
            {
                if (o is String[])
                {
                    return new ConvertResult<String[]>(true, o as String[]);
                }
                return new ConvertResult<String[]>();
            });

            var u1 = new User();
            u1.Tags = new String[2];
            u1.Tags[0] = "News";
            u1.Tags[1] = "Sports";
            var u2 = config.Map(u1, new User());

            Assert.AreEqual(u1.Tags[0], u2.Tags[0]);
            Assert.AreEqual(u1.Tags[1], u2.Tags[1]);
        }
        public void ObjectMapConfig_Map_ListProperty()
        {
            var config = new ObjectMapConfig();
            config.AddConverter<String[]>(o =>
            {
                if (o is String[])
                {
                    return new ConvertResult<String[]>(true, o as String[]);
                }
                return new ConvertResult<String[]>();
            });

            var u1 = new User();
            for (int i = 0; i < 3; i++)
            {
                u1.Users.Add(new User("TestUser" + i.ToString()));
            }
            var u2 = config.Map(u1, new User());

            Assert.AreEqual(0, u2.Users.Count);
        }
        public void ObjectMapConfig_Map_Object_Object()
        {
            var config = new ObjectMapConfig();

            var u1 = new User();

            var u2 = config.Map(u1, new User());

            Assert.AreEqual(u1.Name, u2.Name);
            Assert.AreEqual(u1.Int32, u2.Int32);
            Assert.AreEqual(u1.Decimal, u2.Decimal);
            Assert.AreEqual(u1.DateTime, u2.DateTime);
            Assert.AreEqual(u1.DayOfWeek, u2.DayOfWeek);

            Assert.AreEqual(u1.MapPoint.Latitude, u2.MapPoint.Latitude);
            Assert.AreEqual(u1.MapPoint.Longitude, u2.MapPoint.Longitude);
        }