public IMapper CreateMapper(object data)
        {
            IMapper mapper;

            if (IsXml(data.ToString()))
            {
                mapper = new XmlMapper();
            }
            else if (IsJson(data.ToString()))
            {
                mapper = new JsonMapper();
            }
            else
            {
                if(data.GetType().IsPrimitive)
                {
                    mapper = new PocoMapper();
                }
                else
                {
                    mapper = new StringMapper();
                }
            }
            return mapper;
        }
        public void MapNestedReferenceType_Expected_PathToPublicPrimitiveMemberOfNestedPublicReferenceMember()
        {
            PocoTestData testData = Given();

            PocoMapper pocoMapper = new PocoMapper();
            IEnumerable<IPath> paths = pocoMapper.Map(testData);

            Assert.IsTrue(paths.Any(p => p.ActualPath == "NestedData.Name"));
        }
        public void MapReferenceTypeNestedEnumerableAnWithinEnumerable_Expected_PathToPublicPrimitiveMemberOfNestedPublicEnumerableMember()
        {
            PocoTestData testData = GivenWithParallelAndNestedEnumerables();

            PocoMapper pocoMapper = new PocoMapper();
            IEnumerable<IPath> paths = pocoMapper.Map(testData);

            Assert.IsTrue(paths.Any(p => p.ActualPath == "EnumerableData().EnumerableData().Name"));
        }
        public void MapReferenceType_WhereGetAccessorsOfMembersThrowExceptions_Expected_PathsToExcludeThoseMembers()
        {
            PocoMapper pocoMapper = new PocoMapper();
            Uri uri = new Uri("/Cake", UriKind.Relative);
            IEnumerable<IPath> paths = pocoMapper.Map(uri);

            Assert.IsFalse(paths.Any(p => p.ActualPath == "Host"));
        }
        public void MapEnumerableNestedInAnEnumerable_Expected_PathToPublicPrimitiveMemberOfEnumerableNestedInTheOuterEnumerable()
        {
            PocoMapper pocoMapper = new PocoMapper();
            PocoTestData testData = GivenWithParallelAndNestedEnumerables();

            IEnumerable<IPath> paths = pocoMapper.Map(testData);

            Assert.IsTrue(paths.Any(p => p.ActualPath == "EnumerableData().EnumerableData.Count"));
        }
        public void MapEnumerable_Expected_PathToPublicPrimitiveMember()
        {
            PocoMapper pocoMapper = new PocoMapper();
            List<int> primitives = new List<int>();

            IEnumerable<IPath> paths = pocoMapper.Map(primitives);

            Assert.IsTrue(paths.Any(p => p.ActualPath == "Count"));
        }
        public void MapEnumerableOnlyContainingPrimitives_Expected_PathToRoot()
        {
            PocoMapper pocoMapper = new PocoMapper();
            List<int> primitives = new List<int> { 1, 2, 3 };
            IEnumerable<IPath> paths = pocoMapper.Map(primitives);

            Assert.IsTrue(paths.Any(p => p.ActualPath == PocoPath.EnumerableSymbol + PocoPath.SeperatorSymbol));
        }
        public void MapPrimitive_Expected_PathToRoot()
        {
            PocoMapper pocoMapper = new PocoMapper();
            IEnumerable<IPath> paths = pocoMapper.Map(1);

            Assert.IsTrue(paths.Any(p => p.ActualPath == PocoPath.SeperatorSymbol));
        }