anchor.diff:          ]
       let expectedDeferred2 =
           NameValueLookup.ofList [
  -            "data", upcast "Delayed value"
  +            "data", upcast NameValueLookup.ofList [
  +                "value", upcast "Delayed value"
  +            ]
               "path", upcast ["testData"; "delayed"]
           ]
       let query = parse """{
           testData {
               b @defer
  -            delayed @defer
  +            delayed @defer {
  +                value
  +            }
           }
       }"""
       use mre1 = new ManualResetEvent(false)
       use mre2 = new ManualResetEvent(false)
  -    let actualDeferred = ConcurrentBag<Output>()
  +    let actualDeferred = List<Output>()
       let result = query |> executor.AsyncExecute |> sync
       match result with
       | Deferred(data, errors, deferred) ->
  
positive.code:             actualDeferred.Add(x)
              if actualDeferred.Count = 1 then mre1.Set() |> ignore
              if actualDeferred.Count = 2 then mre2.Set() |> ignore)
          // The second result is the delayed async field, which is set to compute the value for 5 seconds.
          // The first result should come almost instantly, as it is not a delayed computed field.
          // Therefore, if it does not come in at least 2 seconds, we fail the test.
          if TimeSpan.FromSeconds(float 2) |> mre1.WaitOne |> not
  
negative.code: open FSharp.Data.GraphQL.Parser
  open FSharp.Data.GraphQL.Execution
  open System.Threading
  open System.Collections.Generic
  open System.Collections.Concurrent
  open FSharp.Data.GraphQL.Types
  
  