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 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 FieldToField()
{
var source = new TestType()
{
PropertyA = "test"
};
var target = new TestType()
{
PropertyA = "overwrite this"
};
var ultraMapper = new UltraMapper
(
cfg =>
{
//cfg.GlobalConfiguration.IgnoreConventions = true;
cfg.MapTypes <TestType, TestType>()
.MapMember(s => s.FieldA, t => t.FieldA);
}
);
ultraMapper.Map(source, target);
Assert.IsTrue(!Object.ReferenceEquals(source, target));
Assert.IsTrue(source.PropertyA == target.PropertyA);
}
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 InheritMapping()
{
var source = new TestClass();
source.Strings.Clear();
source.Booleans.Clear();
source.Booleans.Add(true);
source.Booleans.Add(false);
var target = new TestClass();
var ultraMapper = new UltraMapper(cfg =>
{
cfg.MapTypes <bool, string>(b => b ? "1" : "0");
cfg.MapTypes <TestClass, TestClass>()
.MapMember(a => a.Boolean, y => y.String)
.MapMember(a => a.Booleans, y => y.Strings);
});
ultraMapper.Map(source, target);
Assert.IsTrue(source.Boolean ? target.String == "1"
: target.String == "0");
Assert.IsTrue(target.Strings.Contains("1") &&
target.String.Contains("0"));
}
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 static void Update <T>(UltraMapper mapper, IEnumerable <T> source, ICollection <T> target, IEqualityComparer <T> comparer)
where T : class
{
var itemsToRemove = target.Except(source, comparer).ToList();
foreach (var item in itemsToRemove)
{
target.Remove(item);
}
List <T> itemsToAdd = new List <T>();
foreach (var sourceItem in source)
{
bool match = false;
foreach (var targetItem in target)
{
if (comparer.Equals(sourceItem, targetItem))
{
match = true;
mapper.Map(sourceItem, targetItem);
}
}
if (!match)
{
itemsToAdd.Add(sourceItem);
}
}
foreach (var item in itemsToAdd)
{
target.Add(item);
}
}
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 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 EnumToEnum()
{
var ultraMapper = new UltraMapper();
string source = Types.Value1.ToString();
Types target = Types.Value3;
ultraMapper.Map(Types.Value1, out target);
Assert.IsTrue(target == Types.Value1);
}
public void DateTimeMemberMapping()
{
var test = new Test();
var mapper = new UltraMapper();
var clone = mapper.Map(test);
Assert.IsTrue(test.DateTime == clone.DateTime);
Assert.IsTrue(!Object.ReferenceEquals(test.DateTime, clone.DateTime));
}
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 ExactNameAndImplicitlyConvertibleTypeConventionTest()
{
var source = new SourceClass();
var target = new TargetClass();
var mapper = new UltraMapper();
mapper.Map(source, target);
Assert.IsTrue(source.A == target.A);
Assert.IsTrue(source.B == target.B);
}
public void DateTimeDirectTypeMapping()
{
DateTime dateTime = new DateTime(2017, 03, 13);
DateTime clone;
var mapper = new UltraMapper();
mapper.Map(dateTime, out clone);
Assert.IsTrue(dateTime == clone);
Assert.IsTrue(!Object.ReferenceEquals(dateTime, clone));
}
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 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 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 CreateNewInstance()
{
var innerType = new InnerType()
{
A = "fadadfsadsffsd"
};
var source = new OuterType()
{
PrimitiveList = Enumerable.Range(0, 10).ToList(),
InnerType = new InnerType()
{
A = "a",
B = "b"
},
ComplexList = new List <InnerType>()
{
new InnerType()
{
A = "a", B = "b",
},
new InnerType()
{
A = "c", B = "d",
}
}
};
var target = new OuterType()
{
InnerType = innerType,
PrimitiveList = Enumerable.Range(20, 10).ToList()
};
var primitiveList = target.PrimitiveList;
var ultraMapper = new UltraMapper(cfg =>
{
cfg.ReferenceMappingStrategy =
ReferenceMappingStrategies.CREATE_NEW_INSTANCE;
});
ultraMapper.Map(source, target);
Assert.IsFalse(Object.ReferenceEquals(target.InnerType, innerType));
Assert.IsFalse(Object.ReferenceEquals(target.PrimitiveList, primitiveList));
}
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 UseTargetInstanceIfNotNull()
{
var innerType = new InnerType()
{
A = "fadadfsadsffsd"
};
var source = new OuterType()
{
InnerType = innerType,
PrimitiveList = Enumerable.Range(0, 10).ToList(),
ComplexList = new List <InnerType>()
{
innerType
}
};
var target = new OuterType()
{
InnerType = new InnerType(),
PrimitiveList = Enumerable.Range(20, 10).ToList(),
ComplexList = new List <InnerType>()
{
innerType
}
};
var beforeMapInnerType = target.InnerType;
var beforeMapPrimitiveList = target.PrimitiveList;
var beforeMapComplexList = target.ComplexList;
var ultraMapper = new UltraMapper(cfg =>
{
cfg.ReferenceMappingStrategy =
ReferenceMappingStrategies.USE_TARGET_INSTANCE_IF_NOT_NULL;
});
ultraMapper.Map(source, target);
Assert.IsTrue(Object.ReferenceEquals(target.InnerType, beforeMapInnerType));
Assert.IsTrue(Object.ReferenceEquals(target.PrimitiveList, beforeMapPrimitiveList));
Assert.IsTrue(Object.ReferenceEquals(target.ComplexList, beforeMapComplexList));
}
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 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 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 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 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 ExactNameAndTypeConventionTest()
{
var source = new SourceClass();
var target = new TargetClass();
var config = new Configuration(cfg =>
{
cfg.MappingConvention.MatchingRules.GetOrAdd <TypeMatchingRule>(ruleConfig =>
{
ruleConfig.AllowImplicitConversions = false;
ruleConfig.AllowExplicitConversions = false;
});
});
var mapper = new UltraMapper(config);
mapper.Map(source, target);
Assert.IsTrue(source.A != target.A);
Assert.IsTrue(source.B != target.B);
}
