/// <summary>
        /// Matches the specified call against the expression.
        /// </summary>
        /// <param name="call">The call to match.</param>
        /// <returns>True if the call is matched by the expression.</returns>
        public virtual bool Matches(IFakeObjectCall call)
        {
            Guard.AgainstNull(call, "call");

            return this.InvokesSameMethodOnTarget(call.FakedObject.GetType(), call.Method, this.Method)
                && this.ArgumentsMatches(call.Arguments);
        }

 private static IEnumerable<CancellationToken> GetCanceledTokens(IFakeObjectCall call)
 {
     return call.Method.GetParameters()
         .Select((param, index) => new { param, index })
         .Where(x => x.param.ParameterType == typeof(CancellationToken))
         .Select(x => (CancellationToken)call.Arguments[x.index])
         .Where(token => token.IsCancellationRequested);
 }

 protected override bool OnIsApplicableTo(IFakeObjectCall fakeObjectCall)
 {
     return
         this.argumentsPredicate(fakeObjectCall.Arguments) &&
             (this.ApplicableToMembersWithReturnType == null
             || (this.ApplicableToMembersWithReturnType == fakeObjectCall.Method.ReturnType)
             || (this.ApplicableToAllNonVoidReturnTypes && fakeObjectCall.Method.ReturnType != typeof(void)));
 }

        private void GetFakeErrors(IFakeObjectCall obj)
        {
            var errors = (Dictionary<string, ErrorRecord>)obj.Arguments[2];

            for (var i = 0; i < _given.ExpectedErrorCount; i++)
            {
                errors.Add(i.ToString(), Random.ErrorRecord);
            }
        }

        /// <summary>
        /// Gets a human readable description of the specified
        /// fake object call.
        /// </summary>
        /// <param name="call">The call to get a description for.</param>
        /// <returns>A description of the call.</returns>
        public string GetDescription(IFakeObjectCall call)
        {
            var builder = new StringBuilder();

            builder
                .Append(this.fakeManagerAccessor.GetFakeManager(call.FakedObject).FakeObjectType)
                .Append(".");

            AppendMethodName(builder, call.Method);

            this.AppendArgumentsList(builder, call);

            return builder.ToString();
        }

 protected override bool OnIsApplicableTo(IFakeObjectCall fakeObjectCall)
 {
     return this.ExpressionMatcher.Matches(fakeObjectCall);
 }

 protected abstract bool OnIsApplicableTo(IFakeObjectCall fakeObjectCall);

 /// <summary>
 /// Gets if this rule is applicable to the specified call.
 /// </summary>
 /// <param name="fakeObjectCall">The call to validate.</param>
 /// <returns>True if the rule applies to the call.</returns>
 public virtual bool IsApplicableTo(IFakeObjectCall fakeObjectCall)
 {
     return this.wherePredicates.All(x => x.Item1.Invoke(fakeObjectCall))
         && this.OnIsApplicableTo(fakeObjectCall);
 }

 public bool IsApplicableTo(IFakeObjectCall fakeObjectCall)
 {
     return this.IsPropertySetter(fakeObjectCall) || this.IsPropertyGetter(fakeObjectCall);
 }

        private static IFakeObjectCall MakeEqualCopy(IFakeObjectCall call)
        {
            var copy = A.Fake<IFakeObjectCall>();

            A.CallTo(() => copy.Method).Returns(call.Method);
            A.CallTo(() => copy.Arguments).Returns(call.Arguments);
            A.CallTo(() => copy.FakedObject).Returns(call.FakedObject);

            return copy;
        }

 private static IEnumerable<object> GetOutputArgumentsForCall(IFakeObjectCall call)
 {
     return
         from valueAndParameterInfo in call.Method.GetParameters().Zip(call.Arguments.AsEnumerable())
         where valueAndParameterInfo.Item1.ParameterType.IsByRef
         select valueAndParameterInfo.Item2;
 }

 private static IEnumerable<object> GetOutputArgumentsForCall(IFakeObjectCall call)
 {
     return
         from valueAndParameterInfo in call.Method.GetParameters().Zip(
             call.Arguments.AsEnumerable(),
             (parameter, argument) => new { parameter.ParameterType, Argument = argument })
         where valueAndParameterInfo.ParameterType.IsByRef
         select valueAndParameterInfo.Argument;
 }

 private static ArgumentValueInfo[] GetArgumentValueInfos(IFakeObjectCall call)
 {
     return
         (from argument in
             call.Method.GetParameters()
                 .Zip(call.Arguments, (parameter, value) => new { parameter.Name, Value = value })
             select new ArgumentValueInfo
             {
                 ArgumentName = argument.Name,
                 ArgumentValue = argument.Value
             }).ToArray();
 }

 protected override bool OnIsApplicableTo(IFakeObjectCall fakeObjectCall)
 {
     return
         this.argumentsPredicate(fakeObjectCall.Arguments) &&
             (this.ApplicableToMembersWithReturnType == null || this.ApplicableToMembersWithReturnType.Equals(fakeObjectCall.Method.ReturnType));
 }

 private static bool IsObjetMethod(IFakeObjectCall fakeObjectCall)
 {
     return ObjectMethodsMethodHandles.Contains(fakeObjectCall.Method.MethodHandle);
 }

 public bool IsApplicableTo(IFakeObjectCall fakeObjectCall)
 {
     return IsObjetMethod(fakeObjectCall);
 }

 private static string GetParametersString(IFakeObjectCall fakeObjectCall)
 {
     return fakeObjectCall.Arguments.ToCollectionString(x => GetArgumentAsString(x), ", ");
 }

 /// <summary>
 /// Gets whether this interceptor is applicable to the specified
 /// call, if true is returned the Apply-method of the interceptor will
 /// be called.
 /// </summary>
 /// <param name="fakeObjectCall">The call to check for applicability.</param>
 /// <returns>True if the interceptor is applicable.</returns>
 public bool IsApplicableTo(IFakeObjectCall fakeObjectCall)
 {
     return true;
 }

                public static EventCall GetEventCall(
                    IFakeObjectCall fakeObjectCall)
                {
                    var eventInfo = GetEvent(fakeObjectCall.Method);

                    return new EventCall
                               {
                                   Event = eventInfo, 
                                   CallingMethod = fakeObjectCall.Method, 
                                   EventHandler = (Delegate)fakeObjectCall.Arguments[0],
                               };
                }

 /// <summary>
 /// Gets whether this interceptor is applicable to the specified
 /// call, if true is returned the Apply-method of the interceptor will
 /// be called.
 /// </summary>
 /// <param name="fakeObjectCall">The call to check for applicability.</param>
 /// <returns>True if the interceptor is applicable.</returns>
 public bool IsApplicableTo(IFakeObjectCall fakeObjectCall)
 {
     return this.wrappedRule.IsApplicableTo(fakeObjectCall);
 }