public void ShouldApplyAConfiguredExpression()
{
using (var mapper = Mapper.CreateNew())
{
mapper.WhenMapping
.From <PublicField <int> >()
.Over <PublicTwoFieldsStruct <int, int> >()
.Map(ctx => ctx.Source.Value)
.To(pps => pps.Value1)
.And
.Map((pf, ptfs, i) => pf.Value + ptfs.Value2)
.To(pps => pps.Value2);
var source = new PublicField <int> {
Value = 63872
};
var target = new PublicTwoFieldsStruct <int, int> {
Value1 = 1, Value2 = 2
};
var result = mapper.Map(source).Over(target);
result.Value1.ShouldBe(63872);
result.Value2.ShouldBe(63874);
}
}
public void ShouldCloneAConstructorDataSource()
{
using (var originalMapper = Mapper.CreateNew())
{
originalMapper.WhenMapping
.From <PublicTwoFieldsStruct <Guid, long> >()
.To <PublicTwoParamCtor <string, int> >()
.Map("Hello there!")
.ToCtor <string>();
using (var clonedMapper = originalMapper.CloneSelf())
{
clonedMapper.WhenMapping
.From <PublicTwoFieldsStruct <Guid, long> >()
.ToANew <PublicTwoParamCtor <string, int> >()
.Map((s, t) => s.Value2 / 2)
.ToCtor <int>();
var source = new PublicTwoFieldsStruct <Guid, long>
{
Value1 = Guid.NewGuid(),
Value2 = 8
};
var result = clonedMapper.Map(source).ToANew <PublicTwoParamCtor <string, int> >();
result.Value1.ShouldBe("Hello there!");
result.Value2.ShouldBe(4);
}
}
}
public void ShouldConvertFieldValues()
{
var source = new PublicTwoFieldsStruct <int, int> {
Value1 = 123, Value2 = 456
};
var result = Mapper.Map(source).ToANew <PublicTwoFieldsStruct <long, string> >();
result.Value1.ShouldBe(123L);
result.Value2.ShouldBe("456");
}
public void ShouldHandleNoMatchingSourceMember()
{
var source = new { Value1 = "You" };
var target = new PublicTwoFieldsStruct <string, int> {
Value1 = "kjd", Value2 = 527
};
var result = Mapper.Map(source).Over(target);
result.Value1.ShouldBe("You");
result.Value2.ShouldBe(527);
}
public void ShouldMapFromAnAnonymousType()
{
var source = new { Value1 = "One", Value2 = 10.00m };
var target = new PublicTwoFieldsStruct <string, string> {
Value1 = "Zero"
};
var result = Mapper.Map(source).OnTo(target);
result.ShouldNotBe(target);
result.Value1.ShouldBe("Zero");
result.Value2.ShouldBe("10.00");
}
public void ShouldUseGreediestFactoryMethod()
{
var source = new PublicTwoFieldsStruct <int, int> {
Value1 = 111, Value2 = 222
};
var result = Mapper.Map(source).ToANew <MultiParameterCreateMethod>();
result.ShouldNotBeNull();
result.Value1.ShouldBe("111");
result.Value2.ShouldBe("222");
}
public void ShouldMapFromAnAnonymousType()
{
var source = new { Value1 = Guid.NewGuid(), Value2 = "Mr Pants" };
var target = new PublicTwoFieldsStruct <Guid, string>()
{
Value1 = Guid.NewGuid(),
Value2 = "Mrs Trousers"
};
var result = Mapper.Map(source).Over(target);
result.ShouldNotBe(target);
result.Value1.ShouldBe(source.Value1);
result.Value2.ShouldBe(source.Value2);
}
public void ShouldApplyAToTargetDataSourceConditionally()
{
using (var mapper = Mapper.CreateNew())
{
mapper.WhenMapping
.From <PublicTwoFieldsStruct <PublicPropertyStruct <int>, int> >()
.OnTo <PublicTwoFields <int, int> >()
.If((s, t) => s.Value1.Value > 5)
.Map((s, t) => s.Value1)
.ToTarget();
mapper.WhenMapping
.From <PublicPropertyStruct <int> >()
.OnTo <PublicTwoFields <int, int> >()
.Map((s, t) => s.Value)
.To(t => t.Value1);
var matchingSource = new PublicTwoFieldsStruct <PublicPropertyStruct <int>, int>
{
Value1 = new PublicPropertyStruct <int> {
Value = 10
},
Value2 = 627
};
var target = new PublicTwoFields <int, int> {
Value2 = 673282
};
mapper.Map(matchingSource).OnTo(target);
target.Value1.ShouldBe(10);
target.Value2.ShouldBe(673282);
var nonMatchingSource = new PublicTwoFieldsStruct <PublicPropertyStruct <int>, int>
{
Value1 = new PublicPropertyStruct <int> {
Value = 1
},
Value2 = 9285
};
target.Value1 = target.Value2 = default(int);
mapper.Map(nonMatchingSource).OnTo(target);
target.Value1.ShouldBeDefault();
target.Value2.ShouldBe(9285);
}
}
public void ShouldSetAnExistingSimpleTypePropertyValueToDefault()
{
var source = new PublicTwoFields <double?, int>();
var target = new PublicTwoFieldsStruct <double?, int> {
Value1 = 537.0, Value2 = 6382
};
var result = Mapper.Map(source).Over(target);
target.Value1.ShouldBe(537.0m);
target.Value2.ShouldBe(6382);
result.Value1.ShouldBeNull();
result.Value2.ShouldBeDefault();
}
public void ShouldIgnoreSourceMemberByDateTimeValueFilterAndSourceType()
{
using (var mapper = Mapper.CreateNew())
{
mapper.WhenMapping
.From <PublicTwoFieldsStruct <DateTime, string> >()
.IgnoreSources(c => c.If <DateTime>(dt => dt < DateTime.Now));
var anHourAgo = DateTime.Now.AddHours(-1);
var matchingSource = new PublicTwoFieldsStruct <DateTime, string>
{
Value1 = anHourAgo,
Value2 = "456"
};
var matchingResult = mapper.Map(matchingSource).ToANew <PublicTwoFields <string, string> >();
matchingResult.ShouldNotBeNull();
matchingResult.Value1.ShouldBeNull();
matchingResult.Value2.ShouldBe("456");
var nonMatchingTypeSource = new PublicTwoFieldsStruct <DateTime?, string>
{
Value1 = anHourAgo,
Value2 = "123"
};
var nonMatchingTypeResult = mapper.Map(nonMatchingTypeSource).ToANew <PublicTwoFields <string, string> >();
nonMatchingTypeResult.ShouldNotBeNull();
nonMatchingTypeResult.Value1.ShouldBe(anHourAgo.ToString(CultureInfo.CurrentCulture.DateTimeFormat));
nonMatchingTypeResult.Value2.ShouldBe("123");
var nonMatchingFilterSource = new PublicTwoFieldsStruct <DateTime?, string>
{
Value1 = anHourAgo.AddHours(+2),
Value2 = "123"
};
var nonMatchingFilterResult = mapper.Map(nonMatchingFilterSource).ToANew <PublicTwoFields <string, string> >();
nonMatchingFilterResult.ShouldNotBeNull();
nonMatchingFilterResult.Value1.ShouldBe(anHourAgo.AddHours(+2).ToString(CultureInfo.CurrentCulture.DateTimeFormat));
nonMatchingFilterResult.Value2.ShouldBe("123");
}
}
public void ShouldDeepCloneWithInlineConfiguration()
{
var source = new PublicTwoFieldsStruct <int, int> {
Value1 = 456, Value2 = 123
};
var result = source.DeepClone(cfg => cfg
.Map(ctx => ctx.Source.Value1)
.To(p => p.Value2)
.And
.Map(ctx => ctx.Source.Value2)
.To(p => p.Value1));
result.ShouldNotBe(source);
result.Value1.ShouldBe(123);
result.Value2.ShouldBe(456);
}
public void ShouldIgnoreConfiguredDataSourceByIntValueFilterSourceAndTargetTypeConditionally()
{
using (var mapper = Mapper.CreateNew())
{
mapper.WhenMapping
.From <PublicTwoFieldsStruct <int, string> >()
.To <PublicField <string> >()
.If(ctx => ctx.Source.Value1 > 100)
.Map((ptf, pf) => ptf.Value1)
.To(pf => pf.Value)
.And
.IgnoreSources(c => c.If <int>(i => !(i < 200)));
var matchingTarget = new PublicField <string>
{
Value = "Value!"
};
var conditionFilteredSource = new PublicTwoFieldsStruct <int, string>
{
Value1 = 50
};
mapper.Map(conditionFilteredSource).Over(matchingTarget);
matchingTarget.Value.ShouldBe("Value!");
var filterFilteredSource = new PublicTwoFieldsStruct <int, string>
{
Value1 = 300
};
mapper.Map(filterFilteredSource).Over(matchingTarget);
matchingTarget.Value.ShouldBe("Value!");
var matchingSource = new PublicTwoFieldsStruct <int, string>
{
Value1 = 150
};
mapper.Map(matchingSource).Over(matchingTarget);
matchingTarget.Value.ShouldBe("150");
}
}
public void ShouldMergeAParsedStringValue()
{
var source = new PublicTwoFields <string, string>
{
Value1 = "123",
Value2 = "456"
};
var target = new PublicTwoFieldsStruct <long, long>
{
Value1 = 678L
};
var result = source.Map().OnTo(target);
result.Value1.ShouldBe(678L);
result.Value2.ShouldBe(456L);
}
public void ShouldUpdateANullMemberValue()
{
var source = new PublicTwoFieldsStruct <string, string>
{
Value1 = "New value!",
Value2 = "Won't be a new value!"
};
dynamic target = new ExpandoObject();
target.Value1 = default(string);
target.Value2 = "Already populated!";
Mapper.Map(source).OnTo(target);
((string)target.Value1).ShouldBe("New value!");
((string)target.Value2).ShouldBe("Already populated!");
}
public void ShouldOverwriteWithInlineConfiguration()
{
var source = new PublicTwoFieldsStruct <int, int> {
Value1 = 456, Value2 = 123
};
var target = new PublicTwoFields <int, int> {
Value1 = 627, Value2 = 890
};
source.Map().Over(target, cfg => cfg
.Map(ctx => ctx.Source.Value1)
.To(p => p.Value2)
.And
.Map(ctx => ctx.Source.Value2)
.To(p => p.Value1));
target.Value1.ShouldBe(123);
target.Value2.ShouldBe(456);
}
public void ShouldDeepCloneWithASpecifiedMapper()
{
using (var mapper = Mapper.CreateNew())
{
mapper.WhenMapping
.From <PublicTwoFieldsStruct <int, int> >()
.To <PublicTwoFieldsStruct <int, int> >()
.Map(ctx => ctx.Source.Value1)
.To(p => p.Value2)
.And
.Map(ctx => ctx.Source.Value2)
.To(p => p.Value1);
var source = new PublicTwoFieldsStruct <int, int> {
Value1 = 123, Value2 = 456
};
var result = source.DeepCloneUsing(mapper);
result.ShouldNotBe(source);
result.Value1.ShouldBe(456);
result.Value2.ShouldBe(123);
}
}
public void ShouldIgnoreConfiguredDataSourceByTimeSpanValueFilterSourceAndTargetType()
{
using (var mapper = Mapper.CreateNew())
{
mapper.WhenMapping
.From <PublicTwoFieldsStruct <TimeSpan, string> >()
.To <PublicField <TimeSpan> >()
.Map((ptf, pf) => ptf.Value1)
.To(pf => pf.Value)
.And
.IgnoreSources(c => c.If <TimeSpan>(ts => ts > TimeSpan.FromHours(1)));
var matchingSource = new PublicTwoFieldsStruct <TimeSpan, string>
{
Value1 = TimeSpan.FromHours(2)
};
var matchingTarget = new PublicField <TimeSpan>
{
Value = TimeSpan.FromHours(1)
};
mapper.Map(matchingSource).Over(matchingTarget);
matchingTarget.Value.ShouldBe(TimeSpan.FromHours(1));
mapper.WhenMapping
.From <PublicTwoFieldsStruct <TimeSpan, string> >()
.To <PublicField <TimeSpan?> >()
.Map((ptf, pf) => ptf.Value1)
.To(pf => pf.Value);
var nonMatchingTarget = new PublicField <TimeSpan?>
{
Value = TimeSpan.FromHours(1)
};
mapper.Map(matchingSource).Over(nonMatchingTarget);
nonMatchingTarget.Value.ShouldBe(TimeSpan.FromHours(2));
mapper.WhenMapping
.From <PublicTwoFieldsStruct <string, string> >()
.To <PublicField <TimeSpan> >()
.Map((ptf, pf) => ptf.Value1)
.To(pf => pf.Value);
var nonMatchingSourceTypeSource = new PublicTwoFieldsStruct <string, string>
{
Value1 = TimeSpan.FromHours(2).ToString()
};
mapper.Map(nonMatchingSourceTypeSource).Over(matchingTarget);
matchingTarget.Value.ShouldBe(TimeSpan.FromHours(2));
var nonMatchingFilterSource = new PublicTwoFieldsStruct <TimeSpan, string>
{
Value1 = TimeSpan.FromMinutes(30)
};
mapper.Map(nonMatchingFilterSource).Over(matchingTarget);
matchingTarget.Value.ShouldBe(TimeSpan.FromMinutes(30));
}
}
public void ShouldIgnoreSourceMemberByNullableLongValueFilterRuleSetSourceTypeAndTargetType()
{
using (var mapper = Mapper.CreateNew())
{
mapper.WhenMapping
.From <PublicTwoFieldsStruct <long?, string> >()
.ToANew <PublicTwoFields <string, long> >()
.IgnoreSources(c => c.If <long?>(l => l.HasValue && l > 100L));
var matchingSource = new PublicTwoFieldsStruct <long?, string>
{
Value1 = 200L,
Value2 = "555"
};
var matchingResult = mapper.Map(matchingSource).ToANew <PublicTwoFields <string, long> >();
matchingResult.ShouldNotBeNull();
matchingResult.Value1.ShouldBeNull();
matchingResult.Value2.ShouldBe(555L);
var nonMatchingTargetTypeResult = mapper.Map(matchingSource).ToANew <PublicTwoFields <string, int> >();
nonMatchingTargetTypeResult.ShouldNotBeNull();
nonMatchingTargetTypeResult.Value1.ShouldBe("200");
nonMatchingTargetTypeResult.Value2.ShouldBe(555);
var nonMatchingRuleSetResult = mapper
.Map(matchingSource)
.Over(new PublicTwoFields <string, long> {
Value1 = "100", Value2 = 55L
});
nonMatchingRuleSetResult.ShouldNotBeNull();
nonMatchingRuleSetResult.Value1.ShouldBe("200");
nonMatchingRuleSetResult.Value2.ShouldBe(555L);
var nullValueSource = new PublicTwoFieldsStruct <int, string>
{
Value1 = 200,
Value2 = "444"
};
var nullValueResult = mapper.Map(nullValueSource).ToANew <PublicTwoFields <string, long> >();
nullValueResult.ShouldNotBeNull();
nullValueResult.Value1.ShouldBe("200");
nullValueResult.Value2.ShouldBe(444L);
var nonMatchingSourceTypeSource = new PublicTwoFieldsStruct <int, string>
{
Value1 = 200,
Value2 = "444"
};
var nonMatchingSourceTypeResult = mapper.Map(nonMatchingSourceTypeSource).ToANew <PublicTwoFields <string, long> >();
nonMatchingSourceTypeResult.ShouldNotBeNull();
nonMatchingSourceTypeResult.Value1.ShouldBe("200");
nonMatchingSourceTypeResult.Value2.ShouldBe(444L);
var nonMatchingFilterSource = new PublicTwoFieldsStruct <long?, string>
{
Value1 = 99L,
Value2 = "123"
};
var nonMatchingFilterResult = mapper.Map(nonMatchingFilterSource).ToANew <PublicTwoFields <string, long> >();
nonMatchingFilterResult.ShouldNotBeNull();
nonMatchingFilterResult.Value1.ShouldBe("99");
nonMatchingFilterResult.Value2.ShouldBe(123L);
}
}
