public void MergeCollections() { List <int> source = Enumerable.Range(0, 10).ToList(); source.Capacity = 100; List <double> target = new List <double>() { 1, 2, 3 }; Assert.IsTrue(!source.SequenceEqual( target.Select(item => (int)item))); var ultraMapper = new UltraMapper(cfg => { cfg.ReferenceMappingStrategy = ReferenceMappingStrategies.USE_TARGET_INSTANCE_IF_NOT_NULL; }); ultraMapper.Map(source, target); Assert.IsTrue(source.SequenceEqual( target.Select(item => (int)item))); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void ListToListSameElementComplexType() { var innerType = new InnerType() { String = "test" }; var source = new List <ComplexType>() { new ComplexType() { PropertyA = 1, InnerType = innerType }, new ComplexType() { PropertyA = 2, InnerType = innerType } }; var target = new List <ComplexType>(); Assert.IsTrue(!source.SequenceEqual(target)); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); Assert.IsTrue(source.SequenceEqual(target, comparer)); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void FromComplexCollectionToAnother() { var typeProperties = typeof(GenericCollections <ComplexType>).GetProperties(); var source = new GenericCollections <ComplexType>(false); //initialize source for (int i = 0; i < 50; i++) { source.List.Add(new ComplexType() { A = i }); source.HashSet.Add(new ComplexType() { A = i }); source.SortedSet.Add(new ComplexType() { A = i }); source.Stack.Push(new ComplexType() { A = i }); source.Queue.Enqueue(new ComplexType() { A = i }); source.LinkedList.AddLast(new ComplexType() { A = i }); source.ObservableCollection.Add(new ComplexType() { A = i }); } foreach (var sourceProp in typeProperties) { var ultraMapper = new UltraMapper(cfg => { //cfg.GlobalConfiguration.IgnoreConventions = true; }); var target = new GenericCollections <ComplexType>(false); var typeMappingConfig = ultraMapper.MappingConfiguration.MapTypes(source, target); foreach (var targetProp in typeProperties) { typeMappingConfig.MapMember(sourceProp, targetProp); } ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); } }
public void FromComplexCollectionToPrimitiveCollection() { var source = new List <ComplexType>() { new ComplexType() { PropertyA = 1 }, new ComplexType() { PropertyA = 2 } }; var target = new List <int>() { 11, 13, 17 }; var ultraMapper = new UltraMapper ( cfg => cfg.MapTypes <ComplexType, int>(a => a.PropertyA) ); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void BuiltInToBuiltIn() { var source = new BuiltInTypes(); var ultraMapper = new UltraMapper(cfg => { cfg.MapTypes <BuiltInTypes, BuiltInTypes>() //map with custom converter .MapMember(a => a.Single, d => d.String, single => single.ToString()) //map same source property to many different targets .MapMember(a => a.Char, d => d.Single) .MapMember(a => a.Char, d => d.Int32) .MapMember(a => 123, d => d.Single) //same source and destination members: last mapping overrides and adds the converter .MapMember(a => a.String, d => d.Single) .MapMember(a => a.String, d => d.Single, @string => Single.Parse(@string)) //same sourceproperty/destinationProperty: second mapping overrides and removes (set to null) the converter .MapMember(a => a.Single, y => y.Double, a => a + 254) .MapMember(a => a.Single, y => y.Double); }); var target = ultraMapper.Map(source); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void ReferenceSimpleTest() { var innerType = new InnerType() { A = "this is a test" }; var source = new OuterType() { InnerType = innerType, PrimitiveList = Enumerable.Range(20, 10).ToList(), ComplexList = new List <InnerType>() { innerType }, String = "ok" }; source.InnerType.C = source; var target = new OuterType(); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void ComplexCollection() { var innerType = new InnerType() { String = "test" }; var source = new GenericCollections <ComplexType>(false); for (int i = 0; i < 3; i++) { source.List.Add(new ComplexType() { A = i, InnerType = innerType }); source.HashSet.Add(new ComplexType() { A = i, InnerType = innerType }); source.SortedSet.Add(new ComplexType() { A = i, InnerType = innerType }); source.Stack.Push(new ComplexType() { A = i, InnerType = innerType }); source.Queue.Enqueue(new ComplexType() { A = i, InnerType = innerType }); source.LinkedList.AddLast(new ComplexType() { A = i, InnerType = innerType }); source.ObservableCollection.Add(new ComplexType() { A = i, InnerType = innerType }); } var target = new GenericCollections <ComplexType>(false); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); Assert.IsTrue(!Object.ReferenceEquals(source.HashSet.First().InnerType, target.HashSet.First().InnerType)); Assert.IsTrue(target.List.Concat(target.HashSet.Concat(target.SortedSet.Concat(target.Stack.Concat( target.Queue.Concat(target.LinkedList.Concat(target.ObservableCollection)))))) .Select(it => it.InnerType) .All(item => Object.ReferenceEquals(item, target.HashSet.First().InnerType))); }
public void ManualFlatteningUsingExistingInstances() { var source = new FirstLevel() { A = "first", SecondLevel = new SecondLevel() { A = "second", ThirdLevel = new ThirdLevel() { A = "third" } } }; var target = new FirstLevel() { A = "first", SecondLevel = new SecondLevel() { A = "second", ThirdLevel = new ThirdLevel() { A = "third" } } }; var ultraMapper = new UltraMapper(cfg => { cfg.MapTypes <SecondLevel, SecondLevel>(typeConfig => { typeConfig.ReferenceMappingStrategy = ReferenceMappingStrategies.USE_TARGET_INSTANCE_IF_NOT_NULL; }); cfg.MapTypes <FirstLevel, FirstLevel>() //nested property getter: ok .MapMember(a => a.SecondLevel.ThirdLevel.A, b => b.A) //nested mixed member-type getter: ok .MapMember(a => a.SecondLevel.GetThird().A, b => b.A1) //nested multiple method getter .MapMember(a => a.GetSecond().GetThird().A, b => b.A2) //nested mixed member-type getter and setter method: ok .MapMember(a => a.SecondLevel.GetThird().A, b => b.SecondLevel.GetThird().A, (b, value) => b.SecondLevel.GetThird().SetA(value)); }); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void ManualFlatteningWithoutUsingExistingInstances() { var source = new FirstLevel() { A = "first", SecondLevel = new SecondLevel() { A = "second", ThirdLevel = new ThirdLevel() { A = "third" } } }; var target = new FirstLevel() { A = "first", SecondLevel = new SecondLevel() { A = "suka", ThirdLevel = new ThirdLevel() { A = "suka" } } }; var ultraMapper = new UltraMapper(cfg => { cfg.MapTypes <SecondLevel, SecondLevel>(typeConfig => { typeConfig.ReferenceMappingStrategy = ReferenceMappingStrategies.USE_TARGET_INSTANCE_IF_NOT_NULL; }); cfg.MapTypes <FirstLevel, FirstLevel>(typeConfig => { typeConfig.IgnoreMemberMappingResolvedByConvention = true; }) .MapMember(a => a.SecondLevel.ThirdLevel.A, b => b.A) .MapMember(a => a.SecondLevel.GetThird().A, b => b.A1) .MapMember(a => a.GetSecond().GetThird().A, b => b.A2) .MapMember(a => a.SecondLevel.GetThird().A, b => b.SecondLevel.GetThird().A, (b, value) => b.SecondLevel.GetThird().SetA(value)); }); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void ClassToStructMapping() { var mapper = new UltraMapper(); var source = new Test(); var target = new StructTest(); mapper.Map(source, out target); var result = mapper.VerifyMapperResult(source, target); Assert.IsTrue(result); }
public void NullableToNullable() { var source = new NullableBuiltInTypes(); var target = new NullableBuiltInTypes(); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void StructToClassMapping() { var mapper = new UltraMapper(); var source = new StructTest() { DateTime = new DateTime(2013, 12, 18) }; var target = mapper.Map <Test>(source); var result = mapper.VerifyMapperResult(source, target); Assert.IsTrue(result); }
public void PrimitiveToDifferentPrimitive() { int source = 10; double target = 13; Assert.IsTrue(source != target); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, out target); Assert.IsTrue(source == target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void NullableToBuiltIn() { var source = new NullableBuiltInTypes() { Boolean = true, Byte = 0x1, Char = '2', Decimal = 3, Double = 4.0, Int16 = 5, Int32 = 6, Int64 = 7, SByte = 0x9, Single = 10, String = "11", UInt16 = 12, UInt32 = 13, UInt64 = 14 }; var target = new BuiltInTypes() { Boolean = false, Byte = 15, Char = (char)16, Decimal = 17, Double = 18, Int16 = 19, Int32 = 20, Int64 = 21, SByte = 0x23, Single = 24, String = "25", UInt16 = 26, UInt32 = 27, UInt64 = 28 }; var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void ListToListSameElementSimpleType() { List <int> source = Enumerable.Range(0, 10).ToList(); source.Capacity = 1000; List <int> target = Enumerable.Range(10, 10).ToList(); Assert.IsTrue(!source.SequenceEqual(target)); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); Assert.IsTrue(source.SequenceEqual(target)); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void BuiltInToNullable() { var source = new BuiltInTypes(); var target = new NullableBuiltInTypes(); var ultraMapper = new UltraMapper ( cfg => { cfg.MapTypes <BuiltInTypes, NullablePrimitiveTypes>() .MapMember(s => s.Int32, s => s.Char); } ); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void SimpleDictionaryTest() { var source = new GenericDictionaries <int, int>() { Dictionary = new Dictionary <int, int>() { { 1, 1 }, { 2, 2 }, { 3, 3 } } }; var target = new GenericDictionaries <int, int>(); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void DictionaryToDictionarySameElementSimpleType() { Dictionary <int, int> source = new Dictionary <int, int>() { { 1, 1 }, { 2, 2 }, { 3, 3 } }; Dictionary <int, int> target = new Dictionary <int, int>(); Assert.IsTrue(!source.SequenceEqual(target)); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); Assert.IsTrue(source.SequenceEqual(target)); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void NullNullablesToDefaultPrimitives() { var source = new NullableBuiltInTypes(); var target = new BuiltInTypes() { Boolean = true, Byte = 0x1, Char = (char)2, Decimal = 3, Double = 4.0, Int16 = 5, Int32 = 6, Int64 = 7, SByte = 0x9, Single = 10f, String = "11", UInt16 = 12, UInt32 = 13, UInt64 = 14, }; //each property must be set to null Assert.IsTrue(source.GetType().GetProperties() .All(p => p.GetValue(source) == null)); //each property must be set to a non-default value Assert.IsTrue(target.GetType().GetProperties() .All(p => { object defaultValue = p.PropertyType.GetDefaultValueViaActivator(); return(!p.GetValue(target).Equals(defaultValue)); })); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); var isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void PrimitiveToOtherPrimitiveDictionaryTest() { var source = new GenericDictionaries <int, double>() { Dictionary = new Dictionary <int, double>() { { 1, 1 }, { 2, 2 }, { 3, 3 } } }; var target = new GenericDictionaries <double, int>(); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(!Object.ReferenceEquals(source, target)); Assert.IsTrue(isResultOk); }
public void AssignNullCollection() { var source = new GenericCollections <int>(false) { List = null, HashSet = null, SortedSet = null, Stack = null, Queue = null, LinkedList = null, ObservableCollection = null }; var target = new GenericCollections <int>(true); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void FromPrimitiveCollectionToAnother() { var sourceProperties = typeof(GenericCollections <int>).GetProperties(); var targetProperties = typeof(GenericCollections <double>).GetProperties(); var source = new GenericCollections <int>(false); //initialize source for (int i = 0; i < 50; i++) { source.List.Add(i); source.HashSet.Add(i); source.SortedSet.Add(i); source.Stack.Push(i); source.Queue.Enqueue(i); source.LinkedList.AddLast(i); source.ObservableCollection.Add(i); } foreach (var sourceProp in sourceProperties) { var target = new GenericCollections <double>(false); var ultraMapper = new UltraMapper(); var typeMappingConfig = ultraMapper.MappingConfiguration.MapTypes(source, target); foreach (var targetProp in targetProperties) { typeMappingConfig.MapMember(sourceProp, targetProp); } ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); } }
public void ListToListDifferentElementType() { List <int> source = Enumerable.Range(0, 10).ToList(); source.Capacity = 100; List <double> target = new List <double>() { 1, 2, 3 }; Assert.IsTrue(!source.SequenceEqual( target.Select(item => (int)item))); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); Assert.IsTrue(source.SequenceEqual( target.Select(item => (int)item))); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void ComplexToAnotherComplexDictionaryTest() { var source = new GenericDictionaries <int, ComplexType>() { Dictionary = new Dictionary <int, ComplexType>() { { 1, new ComplexType() { A = 29 } } } }; var target = new GenericDictionaries <double, ComplexType2>(); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(!Object.ReferenceEquals(source, target)); Assert.IsTrue(isResultOk); }
public void PrimitiveCollection() { var excludeTypes = new TypeCode[] { TypeCode.Empty, TypeCode.DBNull, TypeCode.DateTime, //DateTime is not managed TypeCode.Object, TypeCode.Boolean, //Bool flattens value to 0 or 1 so hashset differ too much. change the verifier to take care of conversions }; var types = Enum.GetValues(typeof(TypeCode)).Cast <TypeCode>() .Except(excludeTypes) .Select(typeCode => TypeExtensions.GetType(typeCode)).ToList(); foreach (var sourceElementType in types) { foreach (var targetElementType in types) { //for the following pairs a conversion is known //to be harder (not possible or convention-based), //so here we just skip that few cases if (sourceElementType == typeof(string) && targetElementType == typeof(bool)) { continue; } if (sourceElementType == typeof(char) && targetElementType == typeof(bool)) { continue; } if (sourceElementType == typeof(bool) && targetElementType == typeof(char)) { continue; } var sourceType = typeof(GenericCollections <>) .MakeGenericType(sourceElementType); var targetType = typeof(GenericCollections <>) .MakeGenericType(targetElementType); var sourceTypeCtor = ConstructorFactory.CreateConstructor <bool>(sourceType); var targetTypeCtor = ConstructorFactory.CreateConstructor <bool>(targetType); var source = sourceTypeCtor(true); var target = targetTypeCtor(false); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); } } }
public void NullablePrimitiveCollection() { //DateTime is not managed var nullableTypes = new Type[] { // typeof( bool? ),//Bool flattens value to 0 or 1 so hashset differ too much. change the verifier to take care of conversions typeof(char?), typeof(sbyte?), typeof(byte?), typeof(int?), typeof(uint?), typeof(int?), typeof(uint?), typeof(int?), typeof(uint?), typeof(float?), typeof(double?), typeof(decimal? ), //typeof( string ) }; foreach (var sourceElementType in nullableTypes) { foreach (var targetElementType in nullableTypes) { if (sourceElementType == typeof(char?) && targetElementType == typeof(bool?)) { continue; } if (sourceElementType == typeof(bool?) && targetElementType == typeof(char?)) { continue; } //for the following pairs a conversion is known //to be harder (not possible or convention-based), //so here we just skip that few cases if (sourceElementType == typeof(bool?) && targetElementType == typeof(string)) { continue; } if (sourceElementType == typeof(string) && targetElementType == typeof(bool?)) { continue; } var sourceType = typeof(GenericCollections <>) .MakeGenericType(sourceElementType); var targetType = typeof(GenericCollections <>) .MakeGenericType(targetElementType); var sourceTypeCtor = ConstructorFactory.CreateConstructor <bool>(sourceType); var targetTypeCtor = ConstructorFactory.CreateConstructor <bool>(targetType); var source = sourceTypeCtor(true); var target = targetTypeCtor(true); var ultraMapper = new UltraMapper(); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); } } }
public void KeepAndClearCollection() { var source = new GenericCollections <ComplexType>(false); //initialize source for (int i = 0; i < 50; i++) { source.List.Add(new ComplexType() { A = i }); source.HashSet.Add(new ComplexType() { A = i }); source.SortedSet.Add(new ComplexType() { A = i }); source.Stack.Push(new ComplexType() { A = i }); source.Queue.Enqueue(new ComplexType() { A = i }); source.LinkedList.AddLast(new ComplexType() { A = i }); source.ObservableCollection.Add(new ComplexType() { A = i }); } var target = new GenericCollections <ComplexType>(false) { List = new List <Tests.CollectionTests.ComplexType>() { new ComplexType() { A = 100 } } }; var ultraMapper = new UltraMapper(cfg => { cfg.IgnoreMemberMappingResolvedByConvention = true; cfg.MapTypes <ComplexType, ComplexType>(typeCfg => { typeCfg.IgnoreMemberMappingResolvedByConvention = false; }); cfg.MapTypes <GenericCollections <ComplexType>, GenericCollections <ComplexType> >() .MapMember(a => a.List, b => b.List, memberConfig => { memberConfig.CollectionMappingStrategy = CollectionMappingStrategies.RESET; memberConfig.ReferenceMappingStrategy = ReferenceMappingStrategies.USE_TARGET_INSTANCE_IF_NOT_NULL; }); }); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }
public void CollectionUpdate() { var innerType = new InnerType() { String = "test" }; var source = new GenericCollections <ComplexType>(false); //initialize source for (int i = 0; i < 50; i++) { source.List.Add(new ComplexType() { A = i, InnerType = innerType }); source.HashSet.Add(new ComplexType() { A = i }); source.SortedSet.Add(new ComplexType() { A = i }); source.Stack.Push(new ComplexType() { A = i }); source.Queue.Enqueue(new ComplexType() { A = i }); source.LinkedList.AddLast(new ComplexType() { A = i }); source.ObservableCollection.Add(new ComplexType() { A = i }); } var target = new GenericCollections <ComplexType>(false); var temp = new List <ComplexType>() { new ComplexType() { A = 1 }, new ComplexType() { A = 49 }, new ComplexType() { A = 50 } }; var ultraMapper = new UltraMapper(cfg => { cfg.MapTypes(source, target) .MapMember(a => a.List, b => b.List, (itemA, itemB) => itemA.A == itemB.A); }); LinqExtensions.Update(ultraMapper, source.List, temp, new RelayEqualityComparison <ComplexType>((itemA, itemB) => itemA.A == itemB.A)); ultraMapper.Map(source, target); bool isResultOk = ultraMapper.VerifyMapperResult(source, target); Assert.IsTrue(isResultOk); }