public void ShouldMapAMemberProperty()
        {
            var source = new PublicPropertyStruct <PublicTwoFieldsStruct <string, string> >
            {
                Value = new PublicTwoFieldsStruct <string, string>
                {
                    Value1 = "Over here!",
                    Value2 = "Yes, here!"
                }
            };

            var target = new PublicPropertyStruct <PublicTwoFieldsStruct <string, string> >
            {
                Value = new PublicTwoFieldsStruct <string, string>
                {
                    Value1 = "Over there!"
                }
            };

            var result = Mapper.Map(source).OnTo(target);

            result.Value.Value1.ShouldNotBe("Over here!");
            result.Value.Value1.ShouldBe("Over there!");
            result.Value.Value2.ShouldBe("Yes, here!");
        }
예제 #2
0
        public void ShouldCallAnObjectCreatedCallbackForSpecifiedSourceAndTargetStructTypes()
        {
            using (var mapper = Mapper.CreateNew())
            {
                var createdStruct = default(PublicCtorStruct <long>);

                mapper.WhenMapping
                .From <PublicPropertyStruct <int> >()
                .To <PublicCtorStruct <long> >()
                .After
                .CreatingTargetInstances
                .Call(ctx => createdStruct = ctx.CreatedObject);

                var nonMatchingSource = new { Value = "8765" };
                var nonMatchingResult = mapper.Map(nonMatchingSource).ToANew <PublicCtorStruct <long> >();

                createdStruct.ShouldBeDefault();
                nonMatchingResult.Value.ShouldBe(8765);

                var matchingSource = new PublicPropertyStruct <int> {
                    Value = 5678
                };
                var matchingResult = mapper.Map(matchingSource).ToANew <PublicCtorStruct <long> >();

                createdStruct.ShouldNotBeDefault();
                createdStruct.ShouldBe(matchingResult);
            }
        }
예제 #3
0
        public void ShouldCallAnObjectCreatedCallbackForSpecifiedSourceStructType()
        {
            using (var mapper = Mapper.CreateNew())
            {
                var creationCount = 0;

                mapper.WhenMapping
                .From <PublicPropertyStruct <string> >()
                .To <Customer>()
                .Map(ctx => ctx.Source.Value)
                .To(c => c.Name)
                .And
                .After
                .CreatingTargetInstances
                .Call(ctx => ++ creationCount);

                var nonMatchingSource = new { Name = "Goldblum" };
                var nonMatchingResult = mapper.Map(nonMatchingSource).ToANew <Customer>();

                creationCount.ShouldBe(0);
                nonMatchingResult.Name.ShouldBe("Goldblum");

                var matchingSource = new PublicPropertyStruct <string> {
                    Value = "Fishy"
                };
                var matchingResult = mapper.Map(matchingSource).ToANew <MysteryCustomer>();

                creationCount.ShouldBe(1);
                matchingResult.Name.ShouldBe("Fishy");
            }
        }
예제 #4
0
        public void ShouldHandleANullSourceObject()
        {
            var target = new PublicPropertyStruct <Guid>();
            var result = Mapper.Map(default(PublicField <string>)).Over(target);

            result.ShouldBe(target);
        }
        public void ShouldHandleANullSourceObject()
        {
            var target = new PublicPropertyStruct <int> {
                Value = 123
            };
            var result = Mapper.Map(default(PublicField <int>)).OnTo(target);

            result.ShouldBe(target);
        }
        public void ShouldOverwriteADefaultSimpleTypePropertyValue()
        {
            var source = new PublicGetMethod <decimal>(6372.00m);
            var target = new PublicPropertyStruct <decimal?> {
                Value = null
            };

            var result = Mapper.Map(source).OnTo(target);

            result.Value.ShouldBe(6372.00m);
        }
        public void ShouldPopulateAStringMemberFromAnUntypedEntry()
        {
            var source = new Dictionary <string, object> {
                ["value"] = "Yes!"
            };
            var target = new PublicPropertyStruct <string> {
                Value = "No!"
            };
            var result = Mapper.Map(source).Over(target);

            result.Value.ShouldBe("Yes!");
        }
        public void ShouldPreserveAnExistingSimpleTypePropertyValue()
        {
            var source = new PublicPropertyStruct <long> {
                Value = 928
            };
            var target = new PublicPropertyStruct <long> {
                Value = 527
            };

            var result = Mapper.Map(source).OnTo(target);

            result.Value.ShouldBe(527);
        }
예제 #9
0
        public void ShouldOverwriteAnEnumProperty()
        {
            var source = new PublicPropertyStruct <TitleShortlist?>
            {
                Value = TitleShortlist.Mrs
            };

            dynamic target = new ExpandoObject();

            target.Value = Title.Mr;

            Mapper.Map(source).Over(target);

            Assert.Equal(TitleShortlist.Mrs, target.Value);
        }
        public void ShouldApplyAConfiguredConstant()
        {
            using (var mapper = Mapper.CreateNew())
            {
                mapper.WhenMapping
                .From <PublicPropertyStruct <string> >()
                .To <PublicPropertyStruct <string> >()
                .Map("-- CONFIGURED --")
                .To(pps => pps.Value);

                var source = new PublicPropertyStruct <string> {
                    Value = "Mapped!"
                };
                var result = mapper.Map(source).ToANew <PublicPropertyStruct <string> >();

                result.Value.ShouldBe("-- CONFIGURED --");
            }
        }
        public void ShouldHandleANullConfiguredSourceMember()
        {
            using (var mapper = Mapper.CreateNew())
            {
                mapper.WhenMapping
                .From <MysteryCustomer>()
                .OnTo <PublicPropertyStruct <string> >()
                .Map(ctx => ctx.Source.Address.Line1)
                .To(pps => pps.Value);

                var source = new MysteryCustomer {
                    Name = "Andy"
                };
                var target = new PublicPropertyStruct <string>();
                var result = mapper.Map(source).OnTo(target);

                result.Value.ShouldBeNull();
            }
        }