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);
}