anchor.diff:              a
               b
               c
  +            hasFoo
           }
       }"""
   
  
positive.code:             Define.Field("a", String, resolve = fun _ dt -> dt.a)
              Define.Field("b", String, resolve = fun _ dt -> dt.b)
              Define.Field("c", String, resolve = fun _ dt -> dt.c)
          ])
  let Query =
      Define.Object<TestSubject>(
  
negative.code:     let fieldDef = Define.Field("a", String, fun _ dt -> dt.c)
      ctx.FieldExecuteMap.SetExecute("Data", fieldDef)
      next ctx
  
  // After the schema has been compiled, inject a fake variable "foo" to every input object
  let postCompileMiddleware (schema : ISchema) (next : ISchema -> unit) =
      schema.TypeMap.ToSeq()
      |> Seq.iter(fun (n, def) ->
                      match def with
                      | InputObject iobj ->
                          iobj.Fields
                          |> Array.iter(fun f -> f.ExecuteInput <- (fun value vars -> f.ExecuteInput value (Map.add "foo" (upcast 1) vars)))
                      | _ -> ())
      next schema
  
  // On the planning phase, we watch the time needed to do the operation
  let planningMiddleware (ctx : PlanningContext) (next : PlanningContext -> ExecutionPlan) =
  