anchor.diff:          NameValueLookup.ofList [
               "testData", upcast NameValueLookup.ofList [
                   "a", upcast "Apple"
  -                "list", [
  -                    NameValueLookup.ofList [
  +                "list", upcast [
  +                    box <| NameValueLookup.ofList [
                           "id", upcast "2"
                       ]
  -                    NameValueLookup.ofList [
  +                    upcast NameValueLookup.ofList [
                           "id", upcast "3"
                           "b", upcast 4
                       ]
  -                ] :> obj
  +                ]
               ]
           ]
       let expectedDeferred =
           NameValueLookup.ofList [
               "data", upcast "Union A"
  -            "path", upcast ["testData" :> obj; "list" :> obj; 0 :> obj; "a" :> obj]
  +            "path", upcast [box "testData"; upcast "list"; upcast 0; upcast "a"]
           ]
       let query = sprintf """{
           testData {
  
positive.code:         ]
      let expectedDeferred2 =
          NameValueLookup.ofList [
              "data", [
                  NameValueLookup.ofList [
                      "a", upcast "Inner A"
                  ] :> obj
              ] :> obj
              "path", upcast ["testData"; "innerList"]
          ]
      let query s = 
          sprintf """{
              testData {
                  a @%s
                  b
                  innerList @%s {
                      a                    
                  }
              }
          }""" s s
      asts query
      |> Seq.iter (fun query ->
          use mre = new ManualResetEvent(false)
          let actualDeferred = ConcurrentBag<Output>()
          let result = query |> executor.AsyncExecute |> sync
          match result with
          | Deferred(data, errors, deferred) -> 
              empty errors
              data.["data"] |> equals (upcast expectedDirect)
              deferred
              |> Observable.add (fun x -> 
                  actualDeferred.Add(x)
                  if actualDeferred.Count = 2 then set mre)
              wait mre "Timeout while waiting for Deferred GQLResponse"
              actualDeferred
              |> Seq.cast<NameValueLookup>
              |> contains expectedDeferred1
              |> contains expectedDeferred2
              |> ignore
          | _ -> fail "Expected Deferred GQLResponse")
  
  [<Fact>]
  let ``Inner Object List Defer and Stream`` () =
      let expectedDirect =
          NameValueLookup.ofList [
             "testData", upcast NameValueLookup.ofList [
                  "b", upcast "Banana"
              ]
          ]
      let expectedDeferred =
          NameValueLookup.ofList [
              "data", [
                  NameValueLookup.ofList [
                      "a", upcast "Inner A"
                  ] :> obj
              ] :> obj
              "path", upcast ["testData"; "innerList"]
          ]
      let query = sprintf """{
              testData {
                  b
                  innerList @%s {
                      a                    
                  }
              }
          }"""
      asts query
      |> Seq.iter (fun query ->
          use mre = new ManualResetEvent(false)
          let actualDeferred = ConcurrentBag<Output>()
          let result = query |> executor.AsyncExecute |> sync
          match result with
          | Deferred(data, errors, deferred) -> 
              empty errors
              data.["data"] |> equals (upcast expectedDirect)
              deferred |> Observable.add (fun x -> actualDeferred.Add(x); set mre)
              wait mre "Timeout while waiting for Deferred GQLResponse"
              actualDeferred |> single |> equals (upcast expectedDeferred)
          | _ -> fail "Expected Deferred GQLResponse")
  
  [<Fact>]
  let ``Nested Inner Object List Defer`` () =
      let expectedDirect =
          NameValueLookup.ofList [
             "testData", upcast NameValueLookup.ofList [
                  "b", upcast "Banana"
              ]
          ]
      let expectedDeferred1 =
          NameValueLookup.ofList [
              "data", [
                  NameValueLookup.ofList [
                      "a", upcast "Inner A"
                  ] :> obj
              ] :> obj
              "path", upcast ["testData"; "innerList"]
          ]
      let expectedDeferred2 =
          NameValueLookup.ofList [
              "data", [
                  NameValueLookup.ofList [
                      "a", upcast "Inner B"
                  ] :> obj
                  NameValueLookup.ofList [
                      "a", upcast "Inner C"
                  ] :> obj
              ] :> obj
              "path", upcast ["testData" :> obj; "innerList" :> obj; 0 :> obj; "innerList" :> obj]
          ]
      let query = parse """{
              testData {
  
negative.code:         ]
      let expectedDeferred1 =
          NameValueLookup.ofList [
              "data", upcast [
                  box <| NameValueLookup.ofList [
                      "a", upcast "Inner A"
                  ]
              ]
              "path", upcast ["testData"; "innerList"]
          ]
      let expectedDeferred2 =
          NameValueLookup.ofList [
              "data", upcast [
                  box <| NameValueLookup.ofList [
                      "a", upcast "Inner B"
                  ]
              ]
              "path", upcast [box "testData"; upcast "innerList"; upcast 0; upcast "innerList"; upcast 0]
          ]
      let expectedDeferred3 =
          NameValueLookup.ofList [
              "data", upcast [
                  box <| NameValueLookup.ofList [
                      "a", upcast "Inner C"
                  ]
              ]
              "path", upcast [box "testData"; upcast "innerList"; upcast 0; upcast "innerList"; upcast 1]
          ]
      let query = parse """{
              testData {
  