// Called via reflection.
        private static void CallAsyncResult <TActionResult>(
            LambdaExpression methodCall,
            WhichControllerInstanceBuilder <TController> builder,
            MethodInfo invokeAsyncResultMethod)
        {
            var actionCall = Expression.Lambda <Func <TController, Task <TActionResult> > >(
                methodCall.Body,
                methodCall.Parameters);

            invokeAsyncResultMethod
            .MakeGenericMethod(typeof(TActionResult))
            .Invoke(builder, new[] { actionCall });
        }
        public static void Invoke(
            LambdaExpression methodCall,
            WhichControllerInstanceBuilder <TController> builder)
        {
            var methodInfo       = ExpressionParser.GetMethodInfo(methodCall);
            var methodReturnType = methodInfo.ReturnType;

            if (Reflection.AreSameTypes(methodReturnType, VoidType))
            {
                var actionCall = Expression.Lambda <Action <TController> >(
                    methodCall.Body,
                    methodCall.Parameters);

                InvokeVoidMethod.Invoke(builder, new[] { actionCall });
            }
            else if (Reflection.AreSameTypes(methodReturnType, TaskType))
            {
                var actionCall = Expression.Lambda <Func <TController, Task> >(
                    methodCall.Body,
                    methodCall.Parameters);

                InvokeAsyncVoidMethod.Invoke(builder, new[] { actionCall });
            }
            else
            {
                var methodName   = nameof(CallInvokeResult);
                var invokeMethod = InvokeResultMethod;

                if (Reflection.HasGenericTypeDefinition(methodReturnType, GenericTaskType))
                {
                    methodName       = nameof(CallAsyncResult);
                    invokeMethod     = InvokeAsyncResultMethod;
                    methodReturnType = methodReturnType.GetGenericArguments().First();
                }

                var invokeActionOpenGeneric = Reflection.GetNonPublicMethod(
                    ActionCallExpressionInvokerType,
                    methodName);

                var invokeActionClosedGeneric = invokeActionOpenGeneric
                                                .MakeGenericMethod(methodReturnType);

                invokeActionClosedGeneric
                .Invoke(null, new object[] { methodCall, builder, invokeMethod });
            }
        }
        private static IActionResultTestBuilder <MethodResult> GetBuilder <TController>(
            IControllerRouteTestBuilder <TController> builder,
            Func <TController> construction,
            Action <IWhichControllerInstanceBuilder <TController> > controllerInstanceBuilder)
            where TController : class
        {
            var actualBuilder = (ControllerRouteTestBuilder <TController>)builder;

            var routeContext = actualBuilder.RouteContext;
            var actionCall   = actualBuilder.ActionCallExpression;

            var whichControllerInstanceBuilder = new WhichControllerInstanceBuilder <TController>(new ControllerTestContext
            {
                HttpContext = routeContext.HttpContext,
                RouteData   = routeContext.RouteData,
                ComponentConstructionDelegate = construction,
                MethodCall = actionCall
            });

            controllerInstanceBuilder?.Invoke(whichControllerInstanceBuilder);

            return(whichControllerInstanceBuilder);
        }