anchor.diff:              | PredUntyped(p) -> (p :?> Func<obj,bool>).Invoke(actual)
           let actualCalls = 
               mock.Invocations 
  -            |> Seq.filter (fun xs -> 
  -                let invoked = xs.[0] :?> MethodBase
  -                invoked.Name = mi.Name &&
  -                invoked.GetParameters().Length = mi.GetParameters().Length &&
  -                Array.zip (invoked.GetParameters()) (mi.GetParameters())
  +            |> Seq.filter (fun invoked ->
  +                invoked.Method.Name = mi.Name &&
  +                invoked.Method.GetParameters().Length = mi.GetParameters().Length &&
  +                Array.zip (invoked.Method.GetParameters()) (mi.GetParameters())
                   |> Array.mapi (fun i x -> i,x)
                   |> Array.forall (fun (i,(a,b)) -> 
                       a.ParameterType = b.ParameterType &&
  -                    matches a.ParameterType (args.[i]) (xs.[i+1])
  +                    matches a.ParameterType (args.[i]) (invoked.Args.[i])
                   )
               )
               |> Seq.length
           actualCalls
   
  +/// Specifies valid invocation count
   type Times private (predicate:int -> bool) =
       member __.Match(n) = predicate(n)       
       static member Exactly(n:int) = Times((=) n)
  
positive.code:         let ps = abstractMethod.GetParameters()
          // Create local array to store arguments
          let local0 = il.DeclareLocal(typeof<obj[]>).LocalIndex
          il.Emit(OpCodes.Ldc_I4, ps.Length + 1)
          il.Emit(OpCodes.Newarr, typeof<obj>)
          il.Emit(OpCodes.Stloc,local0)
          // Store method
          il.Emit(OpCodes.Ldloc,local0)
          il.Emit(OpCodes.Ldc_I4_0)
          il.Emit(OpCodes.Call, typeof<MethodBase>.GetMethod("GetCurrentMethod"))
          il.Emit(OpCodes.Stelem_Ref)
          // Store arguments
          for argIndex = 0 to ps.Length - 1 do
              il.Emit(OpCodes.Ldloc, local0)
              il.Emit(OpCodes.Ldc_I4, argIndex + 1)
              il.Emit(OpCodes.Ldarg, argIndex + 1)
              let argType = ps.[argIndex].ParameterType
              il.Emit(OpCodes.Box, argType)
  
negative.code:         /// Field for method arguments 
          let argsField = typeBuilder.DefineField("_args", typeof<obj[][]>, fields)
          /// Field for invocation tracking
          let invocationsField = typeBuilder.DefineField("_invocations", typeof<Invocations>, fields)
          // Generate default constructor
          generateConstructor typeBuilder [||] (fun il -> ())
          // Set fields from constructor arguments
  