Fixed tests

Author: ENikS

src/Processors/Abstracts/MemberExpression.cs

@@ -31,15 +31,13 @@ protected virtual IEnumerable<Expression> ExpressionsFromSelection(Type type, IE
 
                         yield return GetResolverExpression(info, value);
                         break;
-
 
                         // Injection Member
                     case InjectionMember<TMemberInfo, TData> injectionMember:
                         yield return GetResolverExpression(injectionMember.MemberInfo(type), 
                                                            injectionMember.Data);
                         break;
 
-
                     // Unknown
                     default:
                         throw new InvalidOperationException($"Unknown MemberInfo<{typeof(TMemberInfo)}> type");

src/Processors/Constructor/ConstructorExpression.cs

@@ -4,6 +4,7 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using Unity.Builder;
+using Unity.Exceptions;
 using Unity.Injection;
 using Unity.Lifetime;
 using Unity.Policy;
@@ -96,13 +97,21 @@ protected override Expression GetResolverExpression(ConstructorInfo info, object
             var variable = Expression.Variable(info.DeclaringType);
             var parametersExpr = CreateParameterExpressions(info.GetParameters(), resolvers);
 
-            return Expression.IfThen(
-                Expression.Equal(Expression.Constant(null), BuilderContextExpression.Existing),
-                Expression.Block(new[] { variable }, new Expression[]
-                {
-                    Expression.Assign(variable, Expression.New(info, parametersExpr)),
-                    Expression.Assign(BuilderContextExpression.Existing, Expression.Convert(variable, typeof(object)))
-                }));
+            try
+            {
+                return Expression.IfThen(
+                    Expression.Equal(Expression.Constant(null), BuilderContextExpression.Existing),
+                    Expression.Block(new[] { variable }, new Expression[]
+                    {
+                        Expression.Assign(variable, Expression.New(info, parametersExpr)),
+                        Expression.Assign(BuilderContextExpression.Existing, Expression.Convert(variable, typeof(object)))
+                    }));
+            }
+            catch (ArgumentException ex)
+            {
+                throw new InvalidRegistrationException("Invalid Argument", ex);
+            }
+
         }
 
         #endregion

src/Processors/Methods/MethodProcessor.cs

@@ -4,6 +4,7 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using Unity.Builder;
+using Unity.Exceptions;
 using Unity.Policy;
 using Unity.Resolution;
 
@@ -37,9 +38,16 @@ protected override IEnumerable<MethodInfo> DeclaredMembers(Type type)
 
         protected override Expression GetResolverExpression(MethodInfo info, object resolvers)
         {
-            return Expression.Call(
-                Expression.Convert(BuilderContextExpression.Existing, info.DeclaringType),
-                info, CreateParameterExpressions(info.GetParameters(), resolvers));
+            try
+            {
+                return Expression.Call(
+                    Expression.Convert(BuilderContextExpression.Existing, info.DeclaringType),
+                    info, CreateParameterExpressions(info.GetParameters(), resolvers));
+            }
+            catch (ArgumentException ex)
+            {
+                throw new InvalidRegistrationException("Invalid Argument", ex);
+            }
         }
 
         #endregion

src/Storage/RegistrationSet.cs

@@ -48,13 +48,13 @@ public ref Entry this[int index]
 
         public void Add(Type type, string name, InternalRegistration registration)
         {
-            var hashCode = ((type?.GetHashCode() ?? 0 + 37) ^ (name?.GetHashCode() ?? 0 + 17)) & 0x7FFFFFFF; 
+            var hashCode = (37 ^ (name?.GetHashCode() ?? 0 + 17)) & 0x7FFFFFFF; 
             var bucket = hashCode % _buckets.Length;
             var collisionCount = 0;
             for (int i = _buckets[bucket]; --i >= 0; i = _entries[i].Next)
             {
                 ref var entry = ref _entries[i];
-                if (entry.HashCode == hashCode && entry.RegisteredType == type)
+                if (entry.HashCode == hashCode && entry.Name == name)
                 {
                     entry.RegisteredType = type;
                     entry.Name = name;

src/Strategies/BuildPlanStrategy.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Reflection;
 using Unity.Builder;
+using Unity.Exceptions;
 using Unity.Injection;
 using Unity.Lifetime;
 using Unity.Policy;
@@ -47,16 +48,21 @@ public override void PreBuildUp(ref BuilderContext context)
             if (null == resolver)
             {
                 // Check if can create at all
-                if (!(context.Registration is ContainerRegistration) &&  
+
 #if NETCOREAPP1_0 || NETSTANDARD1_0
-                      context.RegistrationType.GetTypeInfo().IsGenericTypeDefinition)
+                if (!(context.Registration is ContainerRegistration) &&  context.RegistrationType.GetTypeInfo().IsGenericTypeDefinition)
 #else
-                      context.RegistrationType.IsGenericTypeDefinition)
+                if (!(context.Registration is ContainerRegistration) && context.RegistrationType.IsGenericTypeDefinition)
 #endif
                 {
                     throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
                         "The type {0} is an open generic type. An open generic type cannot be resolved.",
-                        context.RegistrationType.FullName));
+                        context.RegistrationType.FullName), new InvalidRegistrationException());
+                }
+                else if (context.Type.IsArray && context.Type.GetArrayRank() > 1)
+                {
+                    var message = $"Invalid array {context.Type}. Only arrays of rank 1 are supported";
+                    throw new ArgumentException(message, new InvalidRegistrationException());
                 }
 
                 // Get resolver factory

src/UnityContainer.Diagnostic.cs

@@ -1,7 +1,10 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Reflection;
+using System.Text;
 using Unity.Policy;
 using Unity.Registration;
 
@@ -18,6 +21,64 @@ public partial class UnityContainer
         #endregion
 
 
+        #region Error Message
+
+        private static Func<Exception, string> CreateMessage = (Exception ex) =>
+        {
+            return $"Resolution failed with error: {ex.Message}\n\nFor more detailed information run Unity in debug mode: new UnityContainer(ModeFlags.Diagnostic)";
+        };
+
+        private static string CreateDiagnosticMessage(Exception ex)
+        {
+            const string line = "_____________________________________________________";
+
+            var builder = new StringBuilder();
+            builder.AppendLine(ex.Message);
+            builder.AppendLine(line);
+            builder.AppendLine("Exception occurred while:");
+
+            foreach (DictionaryEntry item in ex.Data)
+                builder.AppendLine(DataToString(item.Value));
+
+            return builder.ToString();
+        }
+
+        private static string DataToString(object value)
+        {
+            switch (value)
+            {
+                case ParameterInfo parameter:
+                    return $"    for parameter:  {parameter.Name}";
+
+                case ConstructorInfo constructor:
+                    var ctorSignature = string.Join(", ", constructor.GetParameters().Select(p => $"{p.ParameterType.Name} {p.Name}"));
+                    return $"   on constructor:  {constructor.DeclaringType.Name}({ctorSignature})";
+
+                case MethodInfo method:
+                    var methodSignature = string.Join(", ", method.GetParameters().Select(p => $"{p.ParameterType.Name} {p.Name}"));
+                    return $"        on method:  {method.Name}({methodSignature})";
+
+                case PropertyInfo property:
+                    return $"    for property:   {property.Name}";
+
+                case FieldInfo field:
+                    return $"       for field:   {field.Name}";
+
+                case Type type:
+                    return $"\n• while resolving:  {type.Name}";
+
+                case Tuple<Type, string> tuple:
+                    return $"\n• while resolving:  {tuple.Item1.Name} registered with name: {tuple.Item2}";
+
+                case Tuple<Type, Type> tuple:
+                    return $"        mapped to:  {tuple.Item1?.Name}";
+            }
+
+            return value.ToString();
+        }
+        #endregion
+
+
         #region Debug Support
 
         private string DebugName()

src/UnityContainer.IUnityContainer.cs

@@ -27,20 +27,20 @@ public partial class UnityContainer : IUnityContainer
         /// <inheritdoc />
         IUnityContainer IUnityContainer.RegisterType(Type typeFrom, Type typeTo, string name, ITypeLifetimeManager lifetimeManager, InjectionMember[] injectionMembers)
         {
+            var mappedToType = typeTo;
+            var registeredType = typeFrom ?? typeTo;
+            if (null == registeredType) throw new ArgumentNullException(nameof(typeTo));
+
+            // Validate if they are assignable
+            TypeValidator?.Invoke(typeFrom, typeTo);
+
             try
             {
-                var mappedToType = typeTo;
-                var registeredType = typeFrom ?? typeTo;
                 LifetimeManager manager = (null != lifetimeManager) 
                                         ? (LifetimeManager)lifetimeManager 
                                         : TypeLifetimeManager.CreateLifetimePolicy();
-                // Validate input
-                if (null == typeTo) throw new ArgumentNullException(nameof(typeTo));
                 if (manager.InUse) throw new InvalidOperationException(LifetimeManagerInUse);
 
-                // Validate if they are assignable
-                TypeValidator?.Invoke(typeFrom, typeTo);
-
                 // Create registration and add to appropriate storage
                 var container = manager is SingletonLifetimeManager ? _root : this;
                 var registration = new ContainerRegistration(_validators, typeTo, manager, injectionMembers);
@@ -232,7 +232,6 @@ object IUnityContainer.Resolve(Type type, string name, params ResolverOverride[]
         {
             // Verify arguments
             if (null == type) throw new ArgumentNullException(nameof(type));
-            name = string.IsNullOrEmpty(name) ? null : name;
 
             var registration = (InternalRegistration)GetRegistration(type, name);
             var context = new BuilderContext

src/UnityContainer.Implementation.cs

@@ -213,14 +213,26 @@ internal static void SetDiagnosticPolicies(UnityContainer container)
                 var infoFrom = typeFrom.GetTypeInfo();
                 var infoTo = typeTo.GetTypeInfo();
 
-                if (typeFrom != null && !infoFrom.IsGenericType && !infoTo.IsGenericType && !infoFrom.IsAssignableFrom(infoTo))
+                if (null != typeFrom && typeFrom != null && !infoFrom.IsGenericType && 
+                    null != typeTo && !infoTo.IsGenericType && !infoFrom.IsAssignableFrom(infoTo))
 #else
-                if (typeFrom != null && !typeFrom.IsGenericType && !typeTo.IsGenericType && !typeFrom.IsAssignableFrom(typeTo))
+                if (null != typeFrom && typeFrom != null && !typeFrom.IsGenericType && 
+                    null != typeTo && !typeTo.IsGenericType && !typeFrom.IsAssignableFrom(typeTo))
 #endif
                 {
                     throw new ArgumentException($"The type {typeTo} cannot be assigned to variables of type {typeFrom}.");
                 }
 
+#if NETSTANDARD1_0 || NETCOREAPP1_0
+                if (null != typeFrom && null != typeTo && infoFrom.IsGenericType && infoTo.IsArray && 
+                    infoFrom.GetGenericTypeDefinition() == typeof(IEnumerable<>))
+#else
+                if (null != typeFrom && null != typeTo && typeFrom.IsGenericType && typeTo.IsArray && 
+                    typeFrom.GetGenericTypeDefinition() == typeof(IEnumerable<>))
+#endif
+                    throw new ArgumentException($"Type mapping of IEnumerable<T> to array T[] is not supported.");
+
+
 #if NETSTANDARD1_0 || NETCOREAPP1_0
                 if (null == typeFrom && infoTo.IsInterface)
 #else

src/UnityContainer.Resolution.cs

@@ -353,8 +353,14 @@ internal ResolveDelegate<BuilderContext> ResolvingFactory(ref BuilderContext con
                 {
                     context.RequiresRecovery?.Recover();
 
-                    throw new ResolutionFailedException(context.RegistrationType, context.Name,
-                        "For more information add Diagnostic extension: Container.AddExtension(new Diagnostic())", ex);
+                    if (!(ex.InnerException is InvalidRegistrationException) && 
+                        !(ex is InvalidRegistrationException) &&
+                        !(ex is ObjectDisposedException) && 
+                        !(ex is MemberAccessException) && 
+                        !(ex is MakeGenericTypeFailedException))
+                        throw;
+
+                    throw new ResolutionFailedException(context.RegistrationType, context.Name, CreateMessage(ex), ex);
                 }
 
                 return context.Existing;
@@ -380,6 +386,7 @@ private object ExecuteValidatingPlan(ref BuilderContext context)
             catch (Exception ex)
             {
                 context.RequiresRecovery?.Recover();
+
                 ex.Data.Add(Guid.NewGuid(), null == context.Name
                     ? context.RegistrationType == context.Type
                         ? (object)context.Type
@@ -388,64 +395,12 @@ private object ExecuteValidatingPlan(ref BuilderContext context)
                         ? (object)new Tuple<Type, string>(context.Type, context.Name)
                         : new Tuple<Type, Type, string>(context.RegistrationType, context.Type, context.Name));
 
-                var builder = new StringBuilder();
-                builder.AppendLine(ex.Message);
-                builder.AppendLine("_____________________________________________________");
-                builder.AppendLine("Exception occurred while:");
-                builder.AppendLine();
-
-                var indent = 0;
-                foreach (DictionaryEntry item in ex.Data)
-                {
-                    for (var c = 0; c < indent; c++) builder.Append(" ");
-                    builder.AppendLine(CreateErrorMessage(item.Value));
-                    indent += 1;
-                }
-
-                var message = builder.ToString();
+                var message = CreateDiagnosticMessage(ex);
 
                 throw new ResolutionFailedException( context.RegistrationType, context.Name, message, ex);
             }
 
             return context.Existing;
-
-
-            string CreateErrorMessage(object value)
-            {
-                switch (value)
-                {
-                    case ParameterInfo parameter:
-                        return $" for parameter:  '{parameter.Name}'";
-
-                    case ConstructorInfo constructor:
-                        var ctorSignature = string.Join(", ", constructor.GetParameters().Select(p => $"{p.ParameterType.Name} {p.Name}"));
-                        return $"on constructor:  {constructor.DeclaringType.Name}({ctorSignature})";
-
-                    case MethodInfo method:
-                        var methodSignature = string.Join(", ", method.GetParameters().Select(p => $"{p.ParameterType.Name} {p.Name}"));
-                        return $"     on method:  {method.Name}({methodSignature})";
-
-                    case PropertyInfo property:
-                        return $"  for property:  '{property.Name}'";
-
-                    case FieldInfo field:
-                        return $"     for field:  '{field.Name}'";
-
-                    case Type type:
-                        return $"·resolving type:  '{type.Name}'";
-
-                    case Tuple<Type, string> tuple:
-                        return $"•resolving type:  '{tuple.Item1.Name}' registered with name: '{tuple.Item2}'";
-
-                    case Tuple<Type, Type> tuple:
-                        return $"•resolving type:  '{tuple.Item1?.Name}' mapped to '{tuple.Item2?.Name}'";
-
-                    case Tuple<Type, Type, string> tuple:
-                        return $"•resolving type:  '{tuple.Item1?.Name}' mapped to '{tuple.Item2?.Name}' and registered with name: '{tuple.Item3}'";
-                }
-
-                return value.ToString();
-            }
         }
 
         #endregion
@@ -529,7 +484,7 @@ object GetPerResolveValue(IntPtr parent, Type registrationType, string name)
                     if (LifetimeManager.NoValue != result) return result;
 
                     throw new InvalidOperationException($"Circular reference for Type: {parentRef.Type}, Name: {parentRef.Name}",
-                            new CircularDependencyException());
+                            new CircularDependencyException(parentRef.Type, parentRef.Name));
                 }
             }
 #endif
@@ -552,8 +507,7 @@ internal static object ContextValidatingResolvePlan(ref BuilderContext thisConte
                 {
                     var parentRef = Unsafe.AsRef<BuilderContext>(parent.ToPointer());
                     if (thisContext.RegistrationType == parentRef.RegistrationType && thisContext.Name == parentRef.Name)
-                        throw new InvalidOperationException($"Circular reference for Type: {thisContext.Type}, Name: {thisContext.Name}",
-                            new CircularDependencyException());
+                        throw new CircularDependencyException(thisContext.Type, thisContext.Name);
 
                     parent = parentRef.Parent;
                 }