/// <summary>
        /// Sets up an errored execute setup.
        /// </summary>
        /// <param name="methodData">The method data.</param>
        /// <returns>A <see cref="Func{T}"/> returning an errored <see cref="Task"/> setup with the <see cref="Exception"/>.</returns>
        /// <exception cref="ArgumentNullException">The <paramref name="methodData"/> parameter is <see langword="null"/>.</exception>
        Func<Task> IExecutionSetup.Setup(MethodData methodData)
        {
            if (methodData == null)
                throw new ArgumentNullException("methodData");

            return Execute;
        }

 public StateContext(string jobId, MethodData methodData)
 {
     if (String.IsNullOrEmpty(jobId)) throw new ArgumentNullException("jobId");
     
     JobId = jobId;
     MethodData = methodData;
 }

        public static IEnumerable<MethodData> GetBaseAndImplementedMethods(MethodData method)
        {
            if (!(method.Inner is MethodInfo)) // constructor
                return Enumerable.Empty<MethodData>();

            return Inheritance.GetBaseAndImplementedMethodsForMethod(method);
        }

        public void ToCode_given_ConstructorDataWithoutParameters_should_ReturnDefaultConstructorCode()
        {
            //	#	Arrange.
            var sut = new MethodData();
            sut.Comment = new CommentData("Default constructor.");
            sut.IsConstructor = true;
            sut.Scope = Common.VisibilityScope.Public;
            sut.Name = "MyClassName";

            //	#	Act.
            var res = sut.ToCode();

            //	#	Assert.
            Assert.AreEqual(5, res.Count);
            CollectionAssert.AreEqual(
                new[]
                {
                    "/// <summary> Default constructor.",
                    "/// </summary>",
                    "public MyClassName()",
                    "{",
                    "}",
                },
                res.ToList());
        }

        private static IEnumerable<MethodData> GetBaseAndImplementedMethodsForMethod(MethodData method)
        {
            var bases = Inheritance.GetBaseMethods(method);
            var implements = Inheritance.GetImplementedMethods(method);

            return Enumerable.Concat(bases, implements);
        }

        public static string JobType(MethodData methodData)
        {
            if (methodData == null)
            {
                return "Could not find the target method.";
            }

            return methodData.Type.FullName;
        }

        public static string DisplayMethod(MethodData methodData)
        {
            if (methodData == null)
            {
                return null;
            }

            var separator = methodData.MethodInfo.IsStatic ? "." : "::";
            return String.Format("{0}{1}{2}", methodData.Type.Name, separator, methodData.MethodInfo.Name);
        }

        public void Ctor_CorrectlySets_PropertyValues()
        {
            var type = typeof (TestJob);
            var methodInfo = type.GetMethod("Perform");
            var method = new MethodData(type, methodInfo);

            Assert.Equal(type, method.Type);
            Assert.Equal(methodInfo, method.MethodInfo);
            Assert.False(method.OldFormat);
        }

        public JobAsMethodPerformStrategy(
            MethodData methodData,
            string[] arguments)
        {
            if (methodData == null) throw new ArgumentNullException("methodData");
            if (arguments == null) throw new ArgumentNullException("arguments");

            _methodData = methodData;
            _arguments = arguments;
        }

        public virtual IEnumerable<JobFilter> GetFilters(MethodData methodData)
        {
            var typeFilters = GetTypeAttributes(methodData)
                .Select(attr => new JobFilter(attr, JobFilterScope.Type, null));

            var methodFilters = GetMethodAttributes(methodData)
                .Select(attr => new JobFilter(attr, JobFilterScope.Method, null));

            return typeFilters.Union(methodFilters).ToList();
        }

        public JobAsClassPerformStrategy(
            MethodData methodData,
            Dictionary<string, string> arguments)
        {
            if (methodData == null) throw new ArgumentNullException("methodData");
            if (arguments == null) throw new ArgumentNullException("arguments");

            _methodData = methodData;
            _arguments = arguments;
        }

        public ApplyStateContextFacts()
        {
            _methodData = MethodData.FromExpression(() => Console.WriteLine());
            _newStateMock = new Mock<State>();
            _newStateMock.Setup(x => x.Name).Returns(NewState);

            _transaction = new Mock<IWriteOnlyTransaction>();
            
            _filters = new List<IApplyStateFilter>();
            _handlers = new StateHandlerCollection();
        }

        public static IEnumerable<MethodData> GetImplementedMethods(MethodData method)
        {
            var type = method.DeclaringType;
            if (type.Inner.IsInterface)
                return Enumerable.Empty<MethodData>();

            return from implementation in type.ImplementedInterfaces
                   from map in implementation.Members.AsEnumerable()
                   where map.Value == method
                   select (MethodData)map.Key;
        }

        /// <summary>
        /// Sets up a reflected asynchronous <see cref="MethodBase"/> execution.
        /// </summary>
        /// <param name="methodData">The method data.</param>
        /// <returns>A reflected asynchronous <see cref="MethodBase"/> execution.</returns>
        /// <exception cref="ArgumentNullException">The <paramref name="methodData"/> parameter is <see langword="null"/>.</exception>
        Func<Task> IExecutionSetup.Setup(MethodData methodData)
        {
            if (methodData == null)
                throw new ArgumentNullException("methodData");

            _methodUnderTest = methodData.MethodUnderTest;
            _parameters = methodData.Parameters;
            _sut = methodData.InstanceUnderTest;

            return Execute;
        }

        public static IEnumerable<MethodData> GetBaseMethods(MethodData method)
        {
            var lastBaseMethod = method;
            var baseMethod = method.Base;

            while (lastBaseMethod != baseMethod) {
                yield return baseMethod;

                lastBaseMethod = baseMethod;
                baseMethod = baseMethod.Base;
            }
        }

        private void CollectDirectlyUsedBy(MethodData method)
        {
            method.GetReferencedMethods().Cast<IMemberData>().ForEach(this.Collect);
            this.methodsByBases[method].Cast<IMemberData>().ForEach(this.Collect);

            var generic = method.GetGenericDefinition();
            if (generic != null)
                this.Collect(generic);

            var propertyOrEvent = method.DeclaringMember;
            if (propertyOrEvent != null)
                this.Collect(propertyOrEvent);
        }

        public async Task SetupThrowingExecution(
            [Frozen(Matching.DirectBaseType)] ApplicationException expected,
            ErroredExecutionSetup sut,
            MethodData methodData)
        {
            // Act
            Func<Task> execute = ((IExecutionSetup) sut).Setup(methodData);

            // Executing method should not throw but return a faulted task.
            Task task = execute();

            // Assert
            Assert.True(task.IsFaulted);
            ApplicationException actual = await Assert.ThrowsAsync<ApplicationException>(() => task);
            Assert.Same(expected, actual);
        }

        public void ToCode_given_ConstructorDataWithBody_should_ReturnProper()
        {
            //	#	Arrange.
            const string ClassName = "Customer";

            var sut = new MethodData
            {
                IsConstructor = true,
                Scope = Common.VisibilityScope.Internal,
                Name = ClassName,
                Parameters = new List<ParameterData>
                {
                    new ParameterData
                    {
                        Name=ClassName,
                        SystemTypeString = ClassName
                    }
                },
                Body = new BodyData
                {
                    Lines= new List<string>
                    {
                        "this.CustomerId = customer.CustomerId;",
                        "this.CustomerName = customer.CustomerName;"
                    }
                }
            };

            //	#	Act.
            var res = sut.ToCode();

            //	#	Assert.
            CollectionAssert.AreEqual(
                new[]
                {
                    "internal Customer( Customer customer )",
                    "{",
                    "\tthis.CustomerId = customer.CustomerId;",
                    "\tthis.CustomerName = customer.CustomerName;",
                    "}"
                },
                res.ToList());
        }

			public void AddNewMethod (MethodBase mb, int il_size)
			{
				if (methods == null)
					methods = new ArrayList ();

				MethodData md = new MethodData (mb, il_size);
				md.Checked = true;
				methods.Add (md);
			}

        private static IconAccess GetAccess(MethodData method)
        {
            if (method.Inner.IsPrivate)
                return IconAccess.Private;

            if (method.Inner.IsFamily)
                return IconAccess.Protected;

            if (method.Inner.IsAssembly || method.Inner.IsFamilyOrAssembly)
                return IconAccess.Internal;

            return IconAccess.Public;
        }