public AutoMapperMappingException(ResolutionContext context, Exception inner, PropertyMap propertyMap)
     : base(null, inner)
 {
     Context = context;
     Types = context.Types;
     PropertyMap = propertyMap;
 }

        public object ResolveValue(ResolutionContext context)
        {
            var ctorArgs = new List<object>();

            foreach (var map in CtorParams)
            {
                var result = map.ResolveValue(context);

                var sourceType = result.Type;
                var destinationType = map.Parameter.ParameterType;

                var typeMap = context.ConfigurationProvider.ResolveTypeMap(result, destinationType);

                Type targetSourceType = typeMap != null ? typeMap.SourceType : sourceType;

                var newContext = context.CreateTypeContext(typeMap, result.Value, null, targetSourceType,
                    destinationType);

                if (typeMap == null && map.Parameter.IsOptional)
                {
                    object value = map.Parameter.DefaultValue;
                    ctorArgs.Add(value);
                }
                else
                {
                    var value = context.Engine.Map(newContext);
                    ctorArgs.Add(value);
                }
            }

            return _runtimeCtor.Value(ctorArgs.ToArray());
        }

        public object CreateObject(ResolutionContext context)
        {
            var typeMap = context.TypeMap;
            var destinationType = context.DestinationType;

            if (typeMap != null)
                if (typeMap.DestinationCtor != null)
                    return typeMap.DestinationCtor(context);
                else if (typeMap.ConstructDestinationUsingServiceLocator)
                    return context.Options.ServiceCtor(destinationType);
                else if (typeMap.ConstructorMap != null && typeMap.ConstructorMap.CtorParams.All(p => p.CanResolve))
                    return typeMap.ConstructorMap.ResolveValue(context);

            if (context.DestinationValue != null)
                return context.DestinationValue;

            if (destinationType.IsInterface())
#if PORTABLE
                throw new PlatformNotSupportedException("Mapping to interfaces through proxies not supported.");
#else
                destinationType = new ProxyGenerator().GetProxyType(destinationType);
#endif

                return !ConfigurationProvider.AllowNullDestinationValues
                ? ObjectCreator.CreateNonNullValue(destinationType)
                : ObjectCreator.CreateObject(destinationType);
        }

        public string FormatValue(ResolutionContext context)
        {
            var timespan = (TimeSpan) context.SourceValue;
            var list = new List<string>(3);

            int days = timespan.Days;
            int hours = timespan.Hours;
            int minutes = timespan.Minutes;

            if (days > 1)
                list.Add(string.Format("{0} days", days));
            else if (days == 1)
                list.Add(string.Format("{0} day", days));

            if (hours > 1)
                list.Add(string.Format("{0} hours", hours));
            else if (hours == 1)
                list.Add(string.Format("{0} hour", hours));

            if (minutes > 1)
                list.Add(string.Format("{0} minutes", minutes));
            else if (minutes == 1)
                list.Add(string.Format("{0} minute", minutes));

            return string.Join(", ", list.ToArray());
        }

        private static bool CheckPropertyMapSkipList(ResolutionContext context, Type formatterType)
        {
            if (context.PropertyMap == null)
                return true;

            return !context.PropertyMap.FormattersToSkipContains(formatterType);
        }

 private ResolutionResult(object value, ResolutionContext context, Type memberType)
 {
     Value = value;
     Context = context;
     Type = ResolveType(value, memberType);
     MemberType = memberType;
 }

 private ResolutionResult(object value, ResolutionContext context, Type memberType)
 {
     _value = value;
     _context = context;
     _type = ResolveType(value, memberType);
     _memberType = memberType;
 }

 private void DryRunTypeMap(ICollection<TypeMap> typeMapsChecked, ResolutionContext context)
 {
     var typeMap = context.TypeMap;
     if (typeMap != null)
     {
         typeMapsChecked.Add(typeMap);
         CheckPropertyMaps(typeMapsChecked, context);
     }
     else
     {
         var mapperToUse = _config.GetMappers().FirstOrDefault(mapper => mapper.IsMatch(context.Types));
         if (mapperToUse == null && context.SourceType.IsNullableType())
         {
             var nullableTypes = new TypePair(Nullable.GetUnderlyingType(context.SourceType),
                 context.DestinationType);
             mapperToUse = _config.GetMappers().FirstOrDefault(mapper => mapper.IsMatch(nullableTypes));
         }
         if (mapperToUse == null)
         {
             throw new AutoMapperConfigurationException(context);
         }
         if (mapperToUse is ArrayMapper || mapperToUse is EnumerableMapper || mapperToUse is CollectionMapper)
         {
             CheckElementMaps(typeMapsChecked, context);
         }
     }
 }

 private void DryRunTypeMap(ICollection<TypeMap> typeMapsChecked, TypePair types, TypeMap typeMap, ResolutionContext context)
 {
     if (typeMap != null)
     {
         typeMapsChecked.Add(typeMap);
         if(typeMap.CustomMapper != null || typeMap.TypeConverterType != null)
         {
             return;
         }
         CheckPropertyMaps(typeMapsChecked, typeMap, context);
     }
     else
     {
         var mapperToUse = _config.GetMappers().FirstOrDefault(mapper => mapper.IsMatch(types));
         if (mapperToUse == null && types.SourceType.IsNullableType())
         {
             var nullableTypes = new TypePair(Nullable.GetUnderlyingType(types.SourceType),
                 types.DestinationType);
             mapperToUse = _config.GetMappers().FirstOrDefault(mapper => mapper.IsMatch(nullableTypes));
         }
         if (mapperToUse == null)
         {
             throw new AutoMapperConfigurationException(types);
         }
         if (mapperToUse is ArrayMapper || mapperToUse is EnumerableMapper || mapperToUse is CollectionMapper)
         {
             CheckElementMaps(typeMapsChecked, types, context);
         }
     }
 }

 protected object MapAbstractModel(ResolutionContext context)
 {
     var assemblyQualifiedName = context.DestinationType.AssemblyQualifiedName;
     var baseFullName = context.DestinationType.FullName;
     var childtype = ((AbstractForm)context.SourceValue).BindingType;
     var destinationType = Type.GetType(assemblyQualifiedName.Replace(baseFullName, baseFullName + childtype));
     return Mapper.Map(context.SourceValue, context.SourceType, destinationType);
 }

        /// <summary>
        /// Resolves the value.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <returns></returns>
        public object ResolveValue(ResolutionContext context)
        {
            var ctorArgs = CtorParams
                        .Select(p => p.ResolveValue(context))
                        .Select(result => result.Value)
                        .ToArray();

            return _runtimeCtor(ctorArgs);
        }

            public void ReturnsTrueWhenBothSourceAndDestinationTypesAreNameValueCollection()
            {
                var rc = new ResolutionContext(null, null, null, typeof(NameValueCollection), typeof(NameValueCollection), null);
                var nvcm = new NameValueCollectionMapper();

                var result = nvcm.IsMatch(rc);

                result.ShouldBeTrue();
            }

            public void ReturnsIsFalseWhenSourceTypeIsNotNameValueCollection()
            {
                var rc = new ResolutionContext(null, null, null, typeof(Object), typeof(NameValueCollection), null);
                var nvcm = new NameValueCollectionMapper();

                var result = nvcm.IsMatch(rc);

                result.ShouldBeFalse();
            }

        /// <summary>
        /// Determines whether the specified context is match.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <returns><c>true</c> if the specified context is match; otherwise, <c>false</c>.</returns>
        public bool IsMatch( ResolutionContext context )
        {
            if (Mapper.GetAllTypeMaps().Count(m => m.SourceType == context.SourceType && m.DestinationType == context.DestinationType) == 0)
            {
                return true;
            }

            return false;
        }

        private ResolutionResult(object value, ResolutionContext context)
        {
            if (context == null) throw new ArgumentNullException("context");

            _value = value;
            _context = context;
            _type = ResolveType(value, typeof(object));
            _memberType = _type;
        }

            public void ReturnsNullIfSourceValueIsNull()
            {
                var rc = new ResolutionContext(null, null, new NameValueCollection(), typeof(NameValueCollection), typeof(NameValueCollection), null, Mapper.Engine);
                var nvcm = new NameValueCollectionMapper();

                var result = nvcm.Map(rc, null);

                result.ShouldBeNull();
            }

            public void ReturnsIsFalseWhenDestinationTypeIsNotNameValueCollection()
            {
                var rc = new ResolutionContext(null, null, null, typeof(NameValueCollection), typeof(Object), null);
                var nvcm = new NameValueCollectionMapper();

                var result = nvcm.IsMatch(rc);

                Assert.IsFalse(result);
            }

 public string FormatValue(ResolutionContext context)
 {
     if (context.SourceValue is decimal)
     {
         var money = (decimal)context.SourceValue;
         return money.FormatMoney();
     }
     return context.SourceValue.ToString();
 }

 public string FormatValue(ResolutionContext context)
 {
     var sourceType = context.SourceType;
     if(sourceType != typeof(DateTime) && sourceType != typeof(DateTime?)) {
         throw new ArgumentException(sourceType.GetType().FullName + " is not a System.DateTime.", "context");
     }
     var dateTime = context.SourceValue as DateTime?;
     return dateTime.HasValue ? dateTime.Value.ToLongDateString() : "";
 }

 public string FormatValue(ResolutionContext context)
 {
     var items = context.DestinationValue as IList<SearchingFor>;
     if (items != null) {
         var list = new List<string>(items.Count);
         list.AddRange(items.Select(item => item.Search.ToString(CultureInfo.InvariantCulture)));
         return string.Join("", list);
     }
     return "";
 }